def connect(self):
"""
This function tries to connects to the selected embedder if it is not
successful due to any server/connection error it switches to the
local embedder and warns the user about that.
"""
self.Warning.switched_local_embedder.clear()
# try to connect to current embedder
embedder = ImageEmbedder(
model=self.embedders[self.cb_embedder_current_id],
layer='penultimate'
)
if not embedder.is_local_embedder() and \
not embedder.is_connected_to_server(use_hyper=False):
# there is a problem with connecting to the server
# switching to local embedder
self.Warning.switched_local_embedder()
del embedder # remove current embedder
self.cb_embedder_current_id = self.embedders.index("squeezenet")
print(self.embedders[self.cb_embedder_current_id])
embedder = ImageEmbedder(
model=self.embedders[self.cb_embedder_current_id],
layer='penultimate'
)
return embedder
def test_different_models_caches(self):
embedder = ImageEmbedder(
model='painters',
layer='penultimate',
server_url='example.com',
)
embedder.clear_cache()
self.assertEqual(len(embedder._cache_dict), 0)
embedder(self.single_example)
self.assertEqual(len(embedder._cache_dict), 1)
embedder.persist_cache()
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder._cache_dict), 0)
self.embedder.persist_cache()
embedder = ImageEmbedder(
model='painters',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(embedder._cache_dict), 1)
embedder.clear_cache()
def test_with_statement(self):
# server embedder
with self.embedder_server as embedder:
embedder(self.single_example)
self.assertEqual(self.embedder_server.is_connected_to_server(), False)
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
# local embedder
with self.embedder_local as embedder:
embedder(self.single_example)
self.assertEqual(self.embedder_local.is_connected_to_server(), False)
self.embedder_local = ImageEmbedder(
model='squeezenet',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(
len(self.embedder_local._embedder._cache._cache_dict), 1)
def setUp(self):
logging.disable(logging.CRITICAL)
self.embedder_server = ImageEmbedder(model='inception-v3', )
self.embedder_server.clear_cache()
self.embedder_local = ImageEmbedder(model='squeezenet', )
self.embedder_local.clear_cache()
self.single_example = [_EXAMPLE_IMAGE_JPG]
def run_embedding(
images: Table,
file_paths_attr: Variable,
embedder_name: str,
state: TaskState,
) -> Result:
"""
Run the embedding process
Parameters
----------
images
Data table with images to embed.
file_paths_attr
The column of the table with images.
embedder_name
The name of selected embedder.
state
State object used for controlling and progress.
Returns
-------
The object that holds embedded images, skipped images, and number
of skipped images.
"""
embedder = ImageEmbedder(model=embedder_name)
file_paths = images[:, file_paths_attr].metas.flatten()
file_paths_mask = file_paths == file_paths_attr.Unknown
file_paths_valid = file_paths[~file_paths_mask]
# init progress bar and fuction
ticks = iter(np.linspace(0.0, 100.0, file_paths_valid.size))
def advance(success=True):
if state.is_interruption_requested():
embedder.set_canceled()
if success:
state.set_progress_value(next(ticks))
try:
emb, skip, n_skip = embedder(images,
col=file_paths_attr,
callback=advance)
except EmbeddingConnectionError:
# recompute ticks to go from current state to 100
ticks = iter(np.linspace(next(ticks), 100.0, file_paths_valid.size))
state.set_partial_result("squeezenet")
embedder = ImageEmbedder(model="squeezenet")
emb, skip, n_skip = embedder(images,
col=file_paths_attr,
callback=advance)
return Result(embedding=emb, skip_images=skip, num_skipped=n_skip)
def test_different_models_caches(self):
embedder = ImageEmbedder(model='painters')
embedder.clear_cache()
self.assertEqual(len(embedder._embedder._cache._cache_dict), 0)
embedder(self.single_example)
self.assertEqual(len(embedder._embedder._cache._cache_dict), 1)
embedder._embedder._cache.persist_cache()
self.embedder_server = ImageEmbedder(model='inception-v3')
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
self.embedder_server._embedder._cache.persist_cache()
embedder = ImageEmbedder(model='painters')
self.assertEqual(len(embedder._embedder._cache._cache_dict), 1)
embedder.clear_cache()
def test_invalid_model(self):
with self.assertRaises(ValueError):
self.embedder = ImageEmbedder(
model='invalid_model',
layer='penultimate',
server_url='example.com',
)
def main(argv=None):
import sys
from orangecontrib.imageanalytics.import_images import ImportImages
from orangecontrib.imageanalytics.image_embedder import ImageEmbedder
if argv is None:
argv = sys.argv
argv = list(argv)
app = QApplication(argv)
if len(argv) > 1:
image_dir = argv[1]
else:
raise ValueError("Provide the image directory as the first argument.")
import_images = ImportImages()
images, err = import_images(image_dir)
image_embedder = ImageEmbedder()
embeddings, _, _ = image_embedder(images)
ow = OWImageGrid()
ow.show()
ow.raise_()
ow.set_data(Orange.data.Table(embeddings))
rval = app.exec()
ow.saveSettings()
ow.onDeleteWidget()
return rval
def test_invalid_layer(self):
with self.assertRaises(ValueError):
self.embedder = ImageEmbedder(
model='inception-v3',
layer='first',
server_url='example.com',
)
def test_invalid_layer(self):
# test server embedder
with self.assertRaises(ValueError):
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='first',
server_url='example.com',
)
# test local embedder
with self.assertRaises(ValueError):
self.embedder_server = ImageEmbedder(
model='squeezenet',
layer='first',
server_url='example.com',
)
def _cb_embedder_changed(self):
current_embedder = self.embedders[self.cb_embedder_current_id]
self._image_embedder = ImageEmbedder(model=current_embedder,
layer='penultimate')
self.embedder_info.setText(
EMBEDDERS_INFO[current_embedder]['description'])
self.commit()
def test_persistent_caching(self):
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
self.embedder_server(self.single_example)
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
self.embedder_server._embedder._cache.persist_cache()
self.embedder_server = ImageEmbedder(model='inception-v3')
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
self.embedder_server.clear_cache()
self.embedder_server = ImageEmbedder(model='inception-v3')
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
def setUp(self):
logging.disable(logging.CRITICAL)
self.embedder = ImageEmbedder(model='inception-v3',
layer='penultimate',
server_url='example.com',
server_port=80)
self.embedder.clear_cache()
self.single_example = [_EXAMPLE_IMAGE_JPG]
def test_server_url_env_var(self):
url_value = 'url:1234'
self.assertTrue(self.embedder_server._embedder.server_url != url_value)
environ['ORANGE_EMBEDDING_API_URL'] = url_value
self.embedder_server = ImageEmbedder(model='inception-v3', )
self.assertTrue(self.embedder_server._embedder.server_url == url_value)
del environ['ORANGE_EMBEDDING_API_URL']
def _init_server_connection(self):
self.setBlocking(False)
self._image_embedder = ImageEmbedder(
model=self.embedders[self.cb_embedder_current_id],
layer='penultimate'
)
self._set_server_info(
self._image_embedder.is_connected_to_server()
)
def test_with_statement(self):
# server embedder
with self.embedder_server as embedder:
np.testing.assert_array_equal(embedder(self.single_example),
[[0, 1]])
self.embedder_server = ImageEmbedder(model='inception-v3')
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
# local embedder
with self.embedder_local as embedder:
self.assertTupleEqual((1, 1000),
embedder(self.single_example).shape)
self.embedder_local = ImageEmbedder(model='squeezenet')
self.assertEqual(len(self.embedder_local._embedder._cache._cache_dict),
1)
def test_persistent_caching(self):
self.assertEqual(len(self.embedder._cache_dict), 0)
self.embedder(self.single_example)
self.assertEqual(len(self.embedder._cache_dict), 1)
self.embedder.persist_cache()
self.embedder = ImageEmbedder(model='inception-v3',
layer='penultimate',
server_url='example.com',
server_port=80)
self.assertEqual(len(self.embedder._cache_dict), 1)
self.embedder.clear_cache()
self.embedder = ImageEmbedder(model='inception-v3',
layer='penultimate',
server_url='example.com',
server_port=80)
self.assertEqual(len(self.embedder._cache_dict), 0)
def test_with_statement(self):
with self.embedder as embedder:
embedder(self.single_example)
self.assertEqual(self.embedder.is_connected_to_server(), False)
self.embedder = ImageEmbedder(model='inception-v3',
layer='penultimate',
server_url='example.com',
server_port=80)
self.assertEqual(len(self.embedder._cache_dict), 1)
def test_server_url_env_var(self):
url_value = "http://example.com"
self.embedder_server([_EXAMPLE_IMAGE_JPG]) # to init server embedder
self.assertTrue(self.embedder_server._embedder.server_url != url_value)
environ["ORANGE_EMBEDDING_API_URL"] = url_value
self.embedder_server = ImageEmbedder(model="inception-v3")
self.embedder_server([_EXAMPLE_IMAGE_JPG]) # to init server embedder
self.assertTrue(self.embedder_server._embedder.server_url == url_value)
del environ["ORANGE_EMBEDDING_API_URL"]
def setUp(self):
logging.disable(logging.CRITICAL)
self.embedder_server = ImageEmbedder(model="inception-v3", )
self.embedder_server.clear_cache()
self.embedder_local = ImageEmbedder(model="squeezenet", )
self.embedder_local.clear_cache()
self.single_example = [_EXAMPLE_IMAGE_JPG]
str_var = StringVariable("Image")
str_var.attributes["origin"] = path.dirname(path.abspath(__file__))
self.data_table = Table.from_numpy(
Domain([], [], metas=[str_var]),
np.empty((3, 0)),
np.empty((3, 0)),
metas=np.array([
[_EXAMPLE_IMAGE_JPG],
[_EXAMPLE_IMAGE_TIFF],
[_EXAMPLE_IMAGE_GRAYSCALE],
]),
)
def _cb_embedder_changed(self):
current_embedder = self.embedders[self.cb_embedder_current_id]
self._image_embedder = ImageEmbedder(
model=current_embedder,
layer='penultimate'
)
self.embedder_info.setText(
EMBEDDERS_INFO[current_embedder]['description'])
self.input_data_info.setText(
"Data with {:d} instances.".format(len(self._input_data)))
self.commit()
def get_embeddings(dataset_number, image_file_paths, use_cached=True):
file_name = '../data/saved_embeddings/' + datasets[dataset_number] + '.npy'
# read from file if it exists to save time
if os.path.isfile(file_name) and use_cached:
return np.load(file_name)
else:
with ImageEmbedder(model='inception-v3',
layer='penultimate') as embedder:
embeddings = embedder(image_file_paths)
np.save(file_name, embeddings)
return embeddings
def test_server_url_env_var(self):
url_value = 'url:1234'
self.assertTrue(self.embedder._server_url != url_value)
environ['ORANGE_EMBEDDING_API_URL'] = url_value
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertTrue(self.embedder._server_url == url_value)
del environ['ORANGE_EMBEDDING_API_URL']
def _cb_embedder_changed(self):
current_embedder = self.embedders[self.cb_embedder_current_id]
self._image_embedder = ImageEmbedder(model=current_embedder,
layer='penultimate')
self.embedder_info.setText(
EMBEDDERS_INFO[current_embedder]['description'])
if self._input_data:
self.input_data_info.setText("Data with {:d} instances.".format(
len(self._input_data)))
self.commit()
else:
self.input_data_info.setText(self._NO_DATA_INFO_TEXT)
self._set_server_info(self._image_embedder.is_connected_to_server())
def run_embeddings(model, image_dir):
image_file_paths = [
os.path.join(dr, ff) for dr, _, ffs in os.walk(image_dir) for ff in ffs
if ff not in ["index.html", "README.md"]
]
print(image_file_paths)
print("#of pics: {0}".format(len(image_file_paths)))
with ImageEmbedder(model=model, layer='penultimate') as embedder:
embedder.clear_cache()
embeddings = embedder(image_file_paths)
print(embeddings)
def get_result(image_name):
print(image_name)
model = pickle.load(open('oil2.pkcls', 'rb'))
print("model loaded")
image_file_paths = [image_name]
print(image_file_paths)
with ImageEmbedder(model='vgg16', layer='penultimate') as embedder:
embeddings = embedder(image_file_paths)
print(embeddings.shape)
print("embedded")
pred_ind = model(embeddings)
pred_cls = [model.domain.class_var.str_val(i) for i in pred_ind]
print(pred_ind)
print(pred_cls)
k.clear_session()
return pred_cls
print(testpath)
# Initialize Image Import
imimp = ImportImages()
# Import Training images
imdata, err = imimp(path)
# Check images properly imported.
# print(imdata.domain)
# print(imdata)
# print(type(imdata))
# print(testdata)
# Initialize Image Embedder
imemb = ImageEmbedder(model="squeezenet")
# Embed Training images
imembdata, skippedim, numskippedim = imemb(imdata, col="image")
# print(imembdata)
# print(skippedim)
# print(numskippedim)
# Initialize learner
# learner = classification.naive_bayes.NaiveBayesLearner()
# learner = classification.TreeLearner
learner = classification.KNNLearner()
# Train learner for model
lmodel = learner(imembdata)
image_file_paths = [None] * len(data)
for i in range(len(data)):
from orangecontrib.imageanalytics.image_embedder import ImageEmbedder
image_file_paths[i] = path + "/" + str(data[i,'image'])
imgnames[i] = os.path.basename(image_file_paths[i])
from orangecontrib.imageanalytics.image_embedder import ImageEmbedder
"""
with ImageEmbedder(model='inception-v3') as emb:
embeddings1 = emb(image_file_paths)
with ImageEmbedder(model='vgg16') as emb:
embeddings2 = emb(image_file_paths)
"""
with ImageEmbedder(model='vgg19') as emb:
embeddings3 = emb(image_file_paths)
myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient[db]
mycol = mydb["fs.files"]
i = 0
for x in imgnames:
myquery = {"filename": x}
"""
newvalues1 = { "$set": { "metadata.Inception-v3": embeddings1[i]} }
mycol.update_one(myquery, newvalues1)
newvalues2 = { "$set": { "metadata.vgg16Features": embeddings2[i]} }
mycol.update_one(myquery, newvalues2)
def test_invalid_model(self):
with self.assertRaises(ValueError):
self.embedder_server = ImageEmbedder(model="invalid_model")
image_file_paths = [None] * len(data)
i = 0
for i in range(len(data)):
image_file_paths[i] = path + "/" + str(data[i,'image'])
image_file_paths2 = [None] * len(data_up)
for i in range(len(data_up)):
image_file_paths2[i] = path2 + "/" + str(data_up[i,'image'])
# extracting features from images (embedding) of uploaded image
from orangecontrib.imageanalytics.image_embedder import ImageEmbedder
with ImageEmbedder(model=f_algo) as emb:
emb_up = emb(image_file_paths2)
#storing the images of uploaded image in database temporarily (required)
mydb = myclient[upload.db]
mycol = mydb["file_up"]
mycol.update_one({"client_id":upload.cid2},{"$set": { "metadata.features": emb_up[0]}})
#retrieving the just stored featues again
myquery = {"client_id":upload.cid2}
mydoc = mycol.find(myquery)
for x in mydoc:
embeddings[u] = x["metadata"]
data_2 = data