def test_pickle_save_restore(self, m_cdg_setupNetwork):
# Mocking set_network so we don't have to worry about actually
# initializing any caffe things for this test.
expected_params = {
'network_prototxt': DataMemoryElement(),
'network_model': DataMemoryElement(),
'image_mean': DataMemoryElement(),
'return_layer': 'layer name',
'batch_size': 777,
'use_gpu': False,
'gpu_device_id': 8,
'network_is_bgr': False,
'data_layer': 'data-other',
'load_truncated_images': True,
'pixel_rescale': (.2, .8),
'input_scale': 1.5,
}
g = CaffeDescriptorGenerator(**expected_params)
# Initialization sets up the network on construction.
self.assertEqual(m_cdg_setupNetwork.call_count, 1)
g_pickled = pickle.dumps(g, -1)
g2 = pickle.loads(g_pickled)
# Network should be setup for second class class just like in
# initial construction.
self.assertEqual(m_cdg_setupNetwork.call_count, 2)
self.assertIsInstance(g2, CaffeDescriptorGenerator)
self.assertEqual(g.get_config(), g2.get_config())
def test_get_config(self, _m_cdg_setupNetwork):
# Mocking set_network so we don't have to worry about actually
# initializing any caffe things for this test.
expected_params = {
'network_prototxt_uri': 'some_prototxt_uri',
'network_model_uri': 'some_caffemodel_uri',
'image_mean_uri': 'some_imagemean_uri',
'return_layer': 'layer name',
'batch_size': 777,
'use_gpu': False,
'gpu_device_id': 8,
'network_is_bgr': False,
'data_layer': 'data-other',
'load_truncated_images': True,
'pixel_rescale': (.2, .8),
'input_scale': 1.5,
}
# make sure that we're considering all constructor parameter options
expected_param_keys = \
set(inspect.getargspec(CaffeDescriptorGenerator.__init__)
.args[1:])
self.assertSetEqual(set(expected_params.keys()),
expected_param_keys)
g = CaffeDescriptorGenerator(**expected_params)
self.assertEqual(g.get_config(), expected_params)
def test_pickle_save_restore(self, m_cdg_setupNetwork):
# Mocking set_network so we don't have to worry about actually
# initializing any caffe things for this test.
expected_params = {
'network_prototxt_uri': 'some_prototxt_uri',
'network_model_uri': 'some_caffemodel_uri',
'image_mean_uri': 'some_imagemean_uri',
'return_layer': 'layer name',
'batch_size': 777,
'use_gpu': False,
'gpu_device_id': 8,
'network_is_bgr': False,
'data_layer': 'data-other',
'load_truncated_images': True,
'pixel_rescale': (.2, .8),
'input_scale': 1.5,
}
g = CaffeDescriptorGenerator(**expected_params)
# Initialization sets up the network on construction.
self.assertEqual(m_cdg_setupNetwork.call_count, 1)
g_pickled = pickle.dumps(g, -1)
g2 = pickle.loads(g_pickled)
# Network should be setup for second class class just like in
# initial construction.
self.assertEqual(m_cdg_setupNetwork.call_count, 2)
self.assertIsInstance(g2, CaffeDescriptorGenerator)
self.assertEqual(g.get_config(), g2.get_config())
def test_get_config(self, _m_cdg_setupNetwork):
# Mocking set_network so we don't have to worry about actually
# initializing any caffe things for this test.
expected_params = {
'network_prototxt': DataMemoryElement(),
'network_model': DataMemoryElement(),
'image_mean': DataMemoryElement(),
'return_layer': 'layer name',
'batch_size': 777,
'use_gpu': False,
'gpu_device_id': 8,
'network_is_bgr': False,
'data_layer': 'data-other',
'load_truncated_images': True,
'pixel_rescale': (.2, .8),
'input_scale': 1.5,
'threads': 14,
}
# make sure that we're considering all constructor parameter
# options
default_params = CaffeDescriptorGenerator.get_default_config()
assert set(default_params) == set(expected_params)
g = CaffeDescriptorGenerator(**expected_params)
# Shift to expecting sub-configs for DataElement params
for key in ('network_prototxt', 'network_model', 'image_mean'):
expected_params[key] = to_config_dict(expected_params[key])
assert g.get_config() == expected_params
def test_config_cycle_imagemean_nonetyped(self, m_cdg_setup_network):
"""
Test being able to get an instances config and use that config to
construct an equivalently parameterized instance where the second
instance is configured with a None-typed 'image_mean' parameter.
"""
# Mocking ``_setup_network`` so no caffe functionality is hit during
# this test
# Only required parameters, image_mean is empty SMQTK configuration
# dict
g1 = CaffeDescriptorGenerator(self.dummy_net_topo_elem,
self.dummy_caffe_model_elem)
g1_config = g1.get_config()
# Modify config for g2 to pass None for image_mean
for_g2 = dict(g1_config)
for_g2['image_mean'] = {'type': None}
g2 = CaffeDescriptorGenerator.from_config(for_g2)
expected_config = {
'network_prototxt': to_config_dict(self.dummy_net_topo_elem),
'network_model': to_config_dict(self.dummy_caffe_model_elem),
'image_mean': None,
'return_layer': 'fc7',
'batch_size': 1,
'use_gpu': False,
'gpu_device_id': 0,
'network_is_bgr': True,
'data_layer': 'data',
'load_truncated_images': False,
'pixel_rescale': None,
'input_scale': None,
'threads': None,
}
assert g1_config == g2.get_config() == expected_config
def test_get_config(self, _m_cdg_setupNetwork):
# Mocking set_network so we don't have to worry about actually
# initializing any caffe things for this test.
expected_params = {
'network_prototxt': DataMemoryElement(),
'network_model': DataMemoryElement(),
'image_mean': DataMemoryElement(),
'return_layer': 'layer name',
'batch_size': 777,
'use_gpu': False,
'gpu_device_id': 8,
'network_is_bgr': False,
'data_layer': 'data-other',
'load_truncated_images': True,
'pixel_rescale': (.2, .8),
'input_scale': 1.5,
}
# make sure that we're considering all constructor parameter options
expected_param_keys = \
set(inspect.getargspec(CaffeDescriptorGenerator.__init__)
.args[1:])
self.assertSetEqual(set(expected_params.keys()),
expected_param_keys)
g = CaffeDescriptorGenerator(**expected_params)
for key in ('network_prototxt', 'network_model', 'image_mean'):
expected_params[key] = to_config_dict(expected_params[key])
self.assertEqual(g.get_config(), expected_params)
def test_generate_arrays_no_data(self):
""" Test that generation method correctly returns an empty iterable
when no data is passed. """
g = CaffeDescriptorGenerator(self.dummy_net_topo_elem,
self.dummy_caffe_model_elem,
self.dummy_img_mean_elem,
return_layer='fc',
use_gpu=False)
r = list(g._generate_arrays([]))
assert r == []
def test_compute_descriptor_dummy_model(self):
# Caffe dummy network interaction test Lenna image)
# Construct network with an empty model just to see that our
# interaction with the Caffe API is successful. We expect a
# zero-valued descriptor vector.
g = CaffeDescriptorGenerator(self.dummy_net_topo_fp,
self.dummy_caffe_model_fp,
self.dummy_img_mean_fp,
return_layer='fc', use_gpu=False)
d = g.compute_descriptor(from_uri(self.lenna_image_fp))
self.assertAlmostEqual(d.vector().sum(), 0., 12)
def test_compute_descriptor_dummy_model(self):
# Caffe dummy network interaction test Lenna image)
# Construct network with an empty model just to see that our
# interaction with the Caffe API is successful. We expect a
# zero-valued descriptor vector.
g = CaffeDescriptorGenerator(self.dummy_net_topo_fp,
self.dummy_caffe_model_fp,
self.dummy_img_mean_fp,
return_layer='fc', use_gpu=False)
d = g.compute_descriptor(from_uri(self.lenna_image_fp))
nose.tools.assert_almost_equal(d.vector().sum(), 0., 12)
def test_compute_descriptor_from_url_lenna_description(self):
# Caffe AlexNet interaction test (Lenna image)
# This is a long test since it has to download data for remote URIs
d = CaffeDescriptorGenerator(
self.www_uri_alexnet_prototxt,
self.www_uri_alexnet_caffemodel,
self.www_uri_image_mean_proto,
return_layer='fc7',
use_gpu=False,
)
lenna_elem = from_uri(self.lenna_image_fp)
expected_descr = numpy.load(self.lenna_alexnet_fc7_descr_fp)
descr = d.compute_descriptor(lenna_elem).vector()
numpy.testing.assert_allclose(descr, expected_descr, atol=1e-5)
def compute_descriptors(task, folderId, dataElementUris, **kwargs):
"""
Celery task for computing descriptors for a series of data element URIs
belonging to a single folder.
After computing descriptors for a series of Girder files, the relevant items
are updated within Girder to contain the smqtk_uuid (sha1) value as metadata.
:param task: Celery provided task object.
:param folderId: The folder these images are related to, this is used for
namespacing the descriptor index table.
:param dataElementUris: A list of data element URIs, these are assumed to be
GirderDataElement URIs.
"""
task.job_manager.updateProgress(message='Computing descriptors',
forceFlush=True)
generator = CaffeDescriptorGenerator(
girderUriFromTask(
task, getSetting(task.girder_client, 'caffe_network_prototxt')),
girderUriFromTask(
task, getSetting(task.girder_client, 'caffe_network_model')),
girderUriFromTask(task,
getSetting(task.girder_client, 'caffe_image_mean')))
factory = DescriptorElementFactory(
PostgresDescriptorElement, {
'db_name': getSetting(task.girder_client, 'db_name'),
'db_host': getSetting(task.girder_client, 'db_host'),
'db_user': getSetting(task.girder_client, 'db_user'),
'db_pass': getSetting(task.girder_client, 'db_pass')
})
index = descriptorIndexFromFolderId(task.girder_client, folderId)
valid_elements = iter_valid_elements([x[1] for x in dataElementUris],
generator.valid_content_types())
descriptors = compute_functions.compute_many_descriptors(valid_elements,
generator,
factory,
index,
use_mp=False)
fileToItemId = dict([(y.split('/')[-1], x) for x, y in dataElementUris])
for de, descriptor in descriptors:
# TODO Catch errors that could occur here
with task.girder_client.session():
task.girder_client.addMetadataToItem(
fileToItemId[de.file_id], {'smqtk_uuid': descriptor.uuid()})
def test_compute_descriptor_dummy_model(self):
# Caffe dummy network interaction test Lenna image)
# Construct network with an empty model just to see that our
# interaction with the Caffe API is successful. We expect a
# zero-valued descriptor vector.
g = CaffeDescriptorGenerator(self.dummy_net_topo_elem,
self.dummy_caffe_model_elem,
self.dummy_img_mean_elem,
return_layer='fc',
use_gpu=False)
d = g.compute_descriptor(
DataFileElement(self.hopper_image_fp, readonly=True))
self.assertAlmostEqual(d.vector().sum(), 0., 12)
def test_compute_descriptor_from_url_hopper_description(self):
# Caffe AlexNet interaction test (Grace Hopper image)
# This is a long test since it has to download data for remote URIs
d = CaffeDescriptorGenerator(
self.alexnet_prototxt_elem,
self.alexnet_caffemodel_elem,
self.image_mean_proto_elem,
return_layer='fc7',
use_gpu=False,
)
hopper_elem = DataFileElement(self.hopper_image_fp, readonly=True)
expected_descr = numpy.load(self.hopper_alexnet_fc7_descr_fp)
descr = d.compute_descriptor(hopper_elem).vector()
numpy.testing.assert_allclose(descr, expected_descr, atol=1e-4)
def test_compute_descriptor_from_url_lenna_description(self):
# Caffe AlexNet interaction test (Lenna image)
# This is a long test since it has to download data for remote URIs
d = CaffeDescriptorGenerator(
self.www_uri_alexnet_prototxt,
self.www_uri_alexnet_caffemodel,
self.www_uri_image_mean_proto,
return_layer='fc7',
use_gpu=False,
)
lenna_elem = from_uri(self.lenna_image_fp)
expected_descr = numpy.load(self.lenna_alexnet_fc7_descr_fp)
descr = d.compute_descriptor(lenna_elem).vector()
numpy.testing.assert_allclose(descr, expected_descr, atol=1e-5)
def test_invalid_datatype(self, _m_cdg_setupNetwork):
# Test that a data element with an incorrect content type for this
# implementation raises an exception.
# TODO: This probably doesn't need to exist because this is mostly
# testing the parent class functionality that should already be
# covered by parent class unit tests.
# Passing purposefully bag constructor parameters and ignoring
# Caffe network setup (above mocking).
# noinspection PyTypeChecker
g = CaffeDescriptorGenerator(None, None, None)
bad_element = DataFileElement(os.path.join(TEST_DATA_DIR,
'test_file.dat'),
readonly=True)
with pytest.raises(ValueError):
list(g.generate_arrays([bad_element]))
def test_invalid_datatype(self, m_cdg_setupNetwork):
# dummy network setup
g = CaffeDescriptorGenerator(None, None, None)
bad_element = from_uri(os.path.join(TEST_DATA_DIR,
'test_file.dat'))
nose.tools.assert_raises(ValueError, g.compute_descriptor,
bad_element)
def test_generate_arrays_dummy_model(self):
# Caffe dummy network interaction test Grace Hopper image)
# Construct network with an empty model just to see that our
# interaction with the Caffe API is successful. We expect a
# zero-valued descriptor vector.
g = CaffeDescriptorGenerator(self.dummy_net_topo_elem,
self.dummy_caffe_model_elem,
self.dummy_img_mean_elem,
return_layer='fc',
use_gpu=False)
d_list = list(
g._generate_arrays(
[DataFileElement(self.hopper_image_fp, readonly=True)]))
assert len(d_list) == 1
d = d_list[0]
self.assertAlmostEqual(d.sum(), 0., 12)
def test_compute_descriptor_async_no_data(self):
# Should get a ValueError when given no descriptors to async method
g = CaffeDescriptorGenerator(self.dummy_net_topo_elem,
self.dummy_caffe_model_elem,
self.dummy_img_mean_elem,
return_layer='fc',
use_gpu=False)
self.assertRaises(ValueError, g.compute_descriptor_async, [])
def compute_descriptors(task, folderId, dataElementUris, **kwargs):
"""
Celery task for computing descriptors for a series of data element URIs
belonging to a single folder.
After computing descriptors for a series of Girder files, the relevant items
are updated within Girder to contain the smqtk_uuid (sha1) value as metadata.
:param task: Celery provided task object.
:param folderId: The folder these images are related to, this is used for
namespacing the descriptor index table.
:param dataElementUris: A list of data element URIs, these are assumed to be
GirderDataElement URIs.
"""
task.job_manager.updateProgress(message='Computing descriptors', forceFlush=True)
generator = CaffeDescriptorGenerator(
girderUriFromTask(task, getSetting(task.girder_client, 'caffe_network_prototxt')),
girderUriFromTask(task, getSetting(task.girder_client, 'caffe_network_model')),
girderUriFromTask(task, getSetting(task.girder_client, 'caffe_image_mean')))
factory = DescriptorElementFactory(PostgresDescriptorElement, {
'db_name': getSetting(task.girder_client, 'db_name'),
'db_host': getSetting(task.girder_client, 'db_host'),
'db_user': getSetting(task.girder_client, 'db_user'),
'db_pass': getSetting(task.girder_client, 'db_pass')
})
index = descriptorIndexFromFolderId(task.girder_client, folderId)
valid_elements = iter_valid_elements([x[1] for x in dataElementUris], generator.valid_content_types())
descriptors = compute_functions.compute_many_descriptors(valid_elements,
generator,
factory,
index,
use_mp=False)
fileToItemId = dict([(y.split('/')[-1], x) for x, y in dataElementUris])
for de, descriptor in descriptors:
# TODO Catch errors that could occur here
with task.girder_client.session():
task.girder_client.addMetadataToItem(fileToItemId[de.file_id], {
'smqtk_uuid': descriptor.uuid()
})
def test_init_no_prototxt_no_model(self):
"""
Test that the class fails to construct and initialize if no
network prototext or model are provided.
"""
with pytest.raises(AttributeError,
match="'NoneType' object has no attribute"):
# noinspection PyTypeChecker
CaffeDescriptorGenerator(network_prototxt=None, network_model=None)
def test_no_internal_compute_descriptor(self, m_cdg_setupNetwork):
# This implementation's descriptor computation logic sits in async
# method override due to caffe's natural multi-element computation
# interface. Thus, ``_compute_descriptor`` should not be
# implemented.
# dummy network setup because _setup_network is mocked out
g = CaffeDescriptorGenerator(0, 0, 0)
nose.tools.assert_raises(NotImplementedError,
g._compute_descriptor, None)
def test_init_no_prototxt(self):
"""
Test that the class fails to construct and initialize if only no
model DataElement is provided.
"""
with pytest.raises(AttributeError,
match="'NoneType' object has no attribute"):
# noinspection PyTypeChecker
CaffeDescriptorGenerator(network_prototxt=None,
network_model=self.dummy_caffe_model_elem)
def test_invalid_datatype(self, _m_cdg_setupNetwork):
# Test that a data element with an incorrect content type raises an
# exception.
# Passing purposefully bag constructor parameters and ignoring
# Caffe network setup (above mocking).
# noinspection PyTypeChecker
g = CaffeDescriptorGenerator(None, None, None)
bad_element = from_uri(os.path.join(TEST_DATA_DIR,
'test_file.dat'))
self.assertRaises(ValueError, g.compute_descriptor, bad_element)
def test_no_internal_compute_descriptor(self, _m_cdg_setupNetwork):
# This implementation's descriptor computation logic sits in async
# method override due to caffe's natural multi-element computation
# interface. Thus, ``_compute_descriptor`` should not be
# implemented.
# Passing purposefully bag constructor parameters and ignoring
# Caffe network setup (above mocking).
# noinspection PyTypeChecker
g = CaffeDescriptorGenerator(0, 0, 0)
self.assertRaises(NotImplementedError, g._compute_descriptor, None)
def test_config_cycle(self, m_cdg_setup_network):
"""
Test being able to get an instances config and use that config to
construct an equivalently parameterized instance. This test initializes
all possible parameters to non-defaults.
"""
# Mocking ``_setup_network`` so no caffe functionality is hit during
# this test
# When every parameter is provided.
g1 = CaffeDescriptorGenerator(self.dummy_net_topo_elem,
self.dummy_caffe_model_elem,
image_mean=self.dummy_img_mean_elem,
return_layer='foobar',
batch_size=9,
use_gpu=True,
gpu_device_id=99,
network_is_bgr=False,
data_layer='maybe data',
load_truncated_images=True,
pixel_rescale=(0.2, 0.3),
input_scale=8.9,
threads=7)
for inst in configuration_test_helper(
g1): # type: CaffeDescriptorGenerator
assert inst.network_prototxt == self.dummy_net_topo_elem
assert inst.network_model == self.dummy_caffe_model_elem
assert inst.image_mean == self.dummy_img_mean_elem
assert inst.return_layer == 'foobar'
assert inst.batch_size == 9
assert inst.use_gpu == True
assert inst.gpu_device_id == 99
assert inst.network_is_bgr == False
assert inst.data_layer == 'maybe data'
assert inst.load_truncated_images == True
assert inst.pixel_rescale == (0.2, 0.3)
assert inst.input_scale == 8.9
assert inst.threads == 7
"""
Test computing a descriptor on something.
"""
from smqtk.algorithms.descriptor_generator.caffe_descriptor import CaffeDescriptorGenerator
from smqtk.representation.data_element.file_element import DataFileElement
e = DataFileElement("/usr/local/lib/python2.7/dist-packages/smqtk/tests/data/"
"Lenna.png")
gen = CaffeDescriptorGenerator(
"/home/smqtk/caffe/msra_resnet/ResNet-50-deploy.prototxt",
"/home/smqtk/caffe/msra_resnet/ResNet-50-model.caffemodel",
"/home/smqtk/caffe/msra_resnet/ResNet_mean.binaryproto",
return_layer="pool5",
use_gpu=False,
load_truncated_images=True)
# Uses default DescriptorMemoryElement factory.
d = gen.compute_descriptor(e)
assert d.vector() is not None
import mock
import numpy
from smqtk.algorithms.descriptor_generator import get_descriptor_generator_impls
from smqtk.algorithms.descriptor_generator.caffe_descriptor import \
caffe, CaffeDescriptorGenerator
# Testing protected helper function
# noinspection PyProtectedMember
from smqtk.algorithms.descriptor_generator.caffe_descriptor import \
_process_load_img_array
from smqtk.representation.data_element import from_uri
from smqtk.representation.data_element.url_element import DataUrlElement
from smqtk.tests import TEST_DATA_DIR
if CaffeDescriptorGenerator.is_usable():
class TestCaffeDesctriptorGenerator (unittest.TestCase):
lenna_image_fp = os.path.join(TEST_DATA_DIR, 'Lenna.png')
lenna_alexnet_fc7_descr_fp = \
os.path.join(TEST_DATA_DIR, 'Lenna.alexnet_fc7_output.npy')
# Dummy Caffe configuration files + weights
# - weights is actually an empty file (0 bytes), which caffe treats
# as random/zero values (not sure exactly what's happening, but
# always results in a zero-vector).
dummy_net_topo_fp = \
os.path.join(TEST_DATA_DIR, 'caffe.dummpy_network.prototxt')
dummy_caffe_model_fp = \
os.path.join(TEST_DATA_DIR, 'caffe.empty_model.caffemodel')
OUTPUT_DESCR_PROB_INDEX = "cp1_img_prob_descriptors.pickle"
OUTPUT_MAX_JL = "cp1_scores_max.jl"
OUTPUT_AVG_JL = "cp1_scores_avg.jl"
###############################################################################
# Compute classification scores
initialize_logging(logging.getLogger('smqtk'), logging.DEBUG)
eval_data_set = DataMemorySet(EVAL_DATASET)
img_prob_descr_index = MemoryDescriptorIndex(OUTPUT_DESCR_PROB_INDEX)
img_prob_gen = CaffeDescriptorGenerator(CAFFE_DEPLOY,
CAFFE_MODEL,
CAFFE_IMG_MEAN,
'prob',
batch_size=1000,
use_gpu=True,
load_truncated_images=True)
img_c_mem_factory = ClassificationElementFactory(MemoryClassificationElement,
{})
img_prob_classifier = IndexLabelClassifier(CAFFE_LABELS)
eval_data2descr = {}
d_to_proc = set()
for data in eval_data_set:
if not img_prob_descr_index.has_descriptor(data.uuid()):
d_to_proc.add(data)
else:
eval_data2descr[data] = img_prob_descr_index[data.uuid()]
"""
Test computing a descriptor on something.
"""
from smqtk.algorithms.descriptor_generator.caffe_descriptor import CaffeDescriptorGenerator
from smqtk.representation.data_element.file_element import DataFileElement
e = DataFileElement("/usr/local/lib/python2.7/dist-packages/smqtk/tests/data/"
"Lenna.png")
gen = CaffeDescriptorGenerator(
"/home/smqtk/caffe/msra_resnet/ResNet-50-deploy.prototxt",
"/home/smqtk/caffe/msra_resnet/ResNet-50-model.caffemodel",
"/home/smqtk/caffe/msra_resnet/ResNet_mean.binaryproto",
return_layer="pool5",
use_gpu=False, load_truncated_images=True
)
# Uses default DescriptorMemoryElement factory.
d = gen.compute_descriptor(e)
assert d.vector() is not None
"""
Test computing a descriptor on something.
"""
from smqtk.algorithms.descriptor_generator.caffe_descriptor import CaffeDescriptorGenerator
from smqtk.representation.data_element.file_element import DataFileElement
e = DataFileElement(
"/home/smqtk/smqtk/source/python/smqtk/tests/data/Lenna.png")
gen = CaffeDescriptorGenerator(
"/home/smqtk/caffe/source/models/bvlc_alexnet/deploy.prototxt",
"/home/smqtk/caffe/source/models/bvlc_alexnet/bvlc_alexnet.caffemodel",
"/home/smqtk/caffe/source/data/ilsvrc12/imagenet_mean.binaryproto",
use_gpu=False,
load_truncated_images=True)
d = gen.compute_descriptor(e)
assert d.vector() is not None
from smqtk.algorithms.descriptor_generator import DescriptorGenerator
from smqtk.algorithms.descriptor_generator.caffe_descriptor import \
caffe, CaffeDescriptorGenerator
# Testing protected helper function
# noinspection PyProtectedMember
from smqtk.algorithms.descriptor_generator.caffe_descriptor import \
_process_load_img_array
from smqtk.representation.data_element.file_element import DataFileElement
from smqtk.representation.data_element.memory_element import DataMemoryElement
from smqtk.representation.data_element.url_element import DataUrlElement
from smqtk.utils.configuration import to_config_dict, configuration_test_helper
from tests import TEST_DATA_DIR
@unittest.skipUnless(CaffeDescriptorGenerator.is_usable(),
reason="CaffeDescriptorGenerator is not usable in"
"current environment.")
class TestCaffeDesctriptorGenerator(unittest.TestCase):
hopper_image_fp = os.path.join(TEST_DATA_DIR, 'grace_hopper.png')
hopper_alexnet_fc7_descr_fp = os.path.join(
TEST_DATA_DIR, 'Hopper.alexnet_fc7_output.npy')
# Dummy Caffe configuration files + weights
# - weights is actually an empty file (0 bytes), which caffe treats
# as random/zero values (not sure exactly what's happening, but
# always results in a zero-vector).
dummy_net_topo_elem = DataFileElement(os.path.join(
TEST_DATA_DIR, 'caffe.dummpy_network.prototxt'),
readonly=True)
OUTPUT_MAX_JL = "cp1_scores_max.jl"
OUTPUT_AVG_JL = "cp1_scores_avg.jl"
###############################################################################
# Compute classification scores
initialize_logging(logging.getLogger('smqtk'), logging.DEBUG)
eval_data_set = DataMemorySet(DataFileElement(EVAL_DATASET))
img_prob_descr_set = MemoryDescriptorSet(
DataFileElement(OUTPUT_DESCR_PROB_SET))
img_prob_gen = CaffeDescriptorGenerator(DataFileElement(CAFFE_DEPLOY),
DataFileElement(CAFFE_MODEL),
DataFileElement(CAFFE_IMG_MEAN),
'prob',
batch_size=1000,
use_gpu=True,
load_truncated_images=True)
img_c_mem_factory = ClassificationElementFactory(MemoryClassificationElement,
{})
img_prob_classifier = IndexLabelClassifier(CAFFE_LABELS)
eval_data2descr = {}
d_to_proc = set()
for data in eval_data_set:
if not img_prob_descr_set.has_descriptor(data.uuid()):
d_to_proc.add(data)
else:
eval_data2descr[data] = img_prob_descr_set[data.uuid()]
from smqtk.algorithms.descriptor_generator import DescriptorGenerator
from smqtk.algorithms.descriptor_generator.caffe_descriptor import \
caffe, CaffeDescriptorGenerator
# Testing protected helper function
# noinspection PyProtectedMember
from smqtk.algorithms.descriptor_generator.caffe_descriptor import \
_process_load_img_array
from smqtk.representation.data_element.file_element import DataFileElement
from smqtk.representation.data_element.memory_element import DataMemoryElement
from smqtk.representation.data_element.url_element import DataUrlElement
from smqtk.utils.configuration import to_config_dict
from tests import TEST_DATA_DIR
if CaffeDescriptorGenerator.is_usable():
class TestCaffeDesctriptorGenerator(unittest.TestCase):
hopper_image_fp = get_sample_data('grace_hopper.png', asfileobj=False)
hopper_alexnet_fc7_descr_fp = os.path.join(
TEST_DATA_DIR, 'Hopper.alexnet_fc7_output.npy')
# Dummy Caffe configuration files + weights
# - weights is actually an empty file (0 bytes), which caffe treats
# as random/zero values (not sure exactly what's happening, but
# always results in a zero-vector).
dummy_net_topo_elem = DataFileElement(os.path.join(
TEST_DATA_DIR, 'caffe.dummpy_network.prototxt'),
readonly=True)
dummy_caffe_model_elem = DataFileElement(os.path.join(
"""
Test computing a descriptor on something.
"""
from smqtk.algorithms.descriptor_generator.caffe_descriptor \
import CaffeDescriptorGenerator
from smqtk.representation.data_element.file_element import DataFileElement
from smqtk.representation.data_element.url_element import DataUrlElement
grace_hopper_img_url = "https://upload.wikimedia.org/wikipedia/commons/5/55/Grace_Hopper.jpg"
e = DataUrlElement(grace_hopper_img_url)
gen = CaffeDescriptorGenerator(
DataFileElement("/home/smqtk/caffe/msra_resnet/ResNet-50-deploy.prototxt"),
DataFileElement(
"/home/smqtk/caffe/msra_resnet/ResNet-50-model.caffemodel"),
DataFileElement("/home/smqtk/caffe/msra_resnet/ResNet_mean.binaryproto"),
return_layer="pool5",
use_gpu=True,
load_truncated_images=True)
# Uses default DescriptorMemoryElement factory.
d = gen.generate_one_element(e)
assert d.vector() is not None
print(d.vector())
