code: def test_simple_case(self):
      data = copy(binary_test_data)
      deep_features = tc.sound_classifier.get_deep_features(
          data["audio"]
      )
  
      # Verify deep features in correct format
      self.assertTrue(isinstance(deep_features, tc.SArray))
      self.assertEqual(len(data), len(deep_features))
      self.assertEqual(deep_features.dtype, list)
      self.assertEqual(len(deep_features[0]), 3)
      self.assertTrue(isinstance(deep_features[0][0], np.ndarray))
      self.assertEqual(deep_features[0][0].dtype, np.float64)
      self.assertEqual(len(deep_features[0][0]), 12288)
  
      # Test helper methods
      self.assertTrue(
          tc.sound_classifier._is_audio_data_sarray(data["audio"])
      )
      self.assertTrue(
          tc.sound_classifier._is_deep_feature_sarray(deep_features)
      )
  
      original_audio_data = data["audio"]
      del data["audio"]
  
      # Create a model using the deep features
      data["features"] = deep_features
      model = tc.sound_classifier.create(
          data, "labels", feature="features"
      )
  
      # Test predict
      predictions_from_audio = model.predict(
          original_audio_data, output_type="probability_vector"
      )
      predictions_from_deep_features = model.predict(
          deep_features, output_type="probability_vector"
      )
      for a, b in zip(
          predictions_from_audio, predictions_from_deep_features
      ):
          np.testing.assert_array_almost_equal(a, b, decimal=6)
  
      # Test classify
      predictions_from_audio = model.classify(original_audio_data)
      predictions_from_deep_features = model.classify(deep_features)
      for a, b in zip(
          predictions_from_audio, predictions_from_deep_features
      ):
          self.assertEqual(a["class"], b["class"])
          np.testing.assert_array_almost_equal(
              a["probability"], b["probability"], decimal=6
          )
  
      # Test predict_topk
      predictions_from_audio = model.predict_topk(
          original_audio_data, k=2
      )
      predictions_from_deep_features = model.predict_topk(
          deep_features, k=2
      )
      for a, b in zip(
          predictions_from_audio, predictions_from_deep_features
      ):
          self.assertEqual(a["id"], b["id"])
          self.assertEqual(a["class"], b["class"])
          np.testing.assert_array_almost_equal(
              a["probability"], b["probability"], decimal=6
          )
  
      # Test evaluate
      predictions_from_audio = model.evaluate(
          tc.SFrame(
              {
                  "features": original_audio_data,
                  "labels": data["labels"],
              }
          )
      )
      predictions_from_deep_features = model.evaluate(
          tc.SFrame(
              {"features": deep_features, "labels": data["labels"]}
          )
      )
      self.assertEqual(
          predictions_from_audio["f1_score"],
          predictions_from_deep_features["f1_score"],
      )
  
imports: from __future__ import print_function
  from __future__ import division
  from __future__ import absolute_import
  from .util import TempDirectory
  from copy import copy
  import math
  from os import mkdir
  import unittest
  import pytest
  import numpy
  import sys
  import turicreate
  from turicreate.toolkits._internal_utils import _raise_error_if_not_sarray
  from turicreate.toolkits._main import ToolkitError
  from turicreate.toolkits._internal_utils import _mac_ver
label_desc: Use image node_id 1 for calling the ReuseDeepFeatures obj's underlying member method code with example usage: obj.test_simple_case() without return types