Algorithme pour trouver des images similaires

J’ai fait quelque chose de similaire en décomposant les images en signatures en utilisant la transformée en ondelettes .

Mon approche consistait à choisir les n coefficients les plus significatifs de chaque canal transformé et à enregistrer leur emplacement. Cela a été fait en sortingant la liste des tuples (puissance, emplacement) en fonction de l’abs (puissance). Des images similaires partageront des similitudes en ce sens qu’elles auront des coefficients significatifs aux mêmes endroits.

J’ai trouvé qu’il était préférable de transformer l’image au format YUV, ce qui vous permet effectivement une similitude de poids dans la forme (canal Y) et la couleur (canaux UV).

Vous pouvez trouver mon implémentation ci-dessus dans mactorii , sur lequel je n’ai malheureusement pas travaillé autant que je devrais avoir 🙂

Une autre méthode, que certains amis ont utilisée avec des résultats étonnamment bons, est de redimensionner simplement votre image en un pixel 4×4 et de stocker votre signature. La similarité des 2 images peut être notée par exemple, en calculant la distance de Manhattan entre les 2 images, en utilisant les pixels correspondants. Je n’ai pas les détails de la façon dont ils ont effectué le redimensionnement, vous devrez peut-être jouer avec les différents algorithmes disponibles pour cette tâche pour en trouver un qui soit approprié.

pHash pourrait vous intéresser.

hash perceptuel n. une empreinte d’un fichier audio, vidéo ou image basé mathématiquement sur le contenu audio ou visuel contenu dans le fichier. Contrairement aux fonctions de hachage cryptographiques qui reposent sur l’effet d’avalanche de petits changements dans les entrées entraînant des changements radicaux dans la sortie, les hachages perceptifs sont “proches” les uns des autres si les entrées sont visuellement ou auditives.

J’ai utilisé SIFT pour détecter le même object dans différentes images. Il est vraiment puissant mais plutôt complexe et peut être excessif. Si les images sont supposées être assez similaires, des parameters simples basés sur la différence entre les deux images peuvent vous en dire beaucoup. Quelques indications:

• Normaliser les images, c’est-à-dire rendre la luminosité moyenne des deux images identique en calculant la luminosité moyenne des deux images et en redimensionnant les couleurs les plus claires en fonction de la ration (pour éviter les coupures) Couleur.
• Somme de la différence de couleur sur l’image normalisée par canal.
• trouver des contours dans les images et mesurer la distance entre les pixels du bord dans les deux images. (pour la forme)
• Diviser les images dans un ensemble de régions discrètes et comparer la couleur moyenne de chaque région.
• Seuil les images à un (ou un ensemble de) niveau (s) et compte le nombre de pixels où les images noir / blanc résultantes diffèrent.

C’est un problème difficile! Cela dépend de la précision dont vous avez besoin, et cela dépend du type d’images avec lequel vous travaillez. Vous pouvez utiliser des histogrammes pour comparer les couleurs, mais cela ne prend évidemment pas en compte la dissortingbution spatiale de ces couleurs dans les images (les formes). La détection des contours suivie d’une segmentation (c.-à-d. La sélection des formes) peut fournir un motif pour une correspondance avec une autre image. Vous pouvez utiliser des masortingces de coocurence pour comparer des textures, en considérant les images comme des masortingces de valeurs de pixels et en comparant ces masortingces. Il existe de bons livres sur la mise en correspondance des images et la vision artificielle – Une recherche sur Amazon en trouvera.

J’espère que cela t’aides!

Vous pouvez utiliser Perceptual Image Diff

C’est un utilitaire de ligne de commande qui compare deux images en utilisant une mésortingque perceptuelle. En d’autres termes, il utilise un modèle informatique du système visuel humain pour déterminer si deux images sont visuellement différentes, de sorte que des modifications mineures des pixels sont ignorées. De plus, il réduit considérablement le nombre de faux positifs causés par les différences de génération de nombres aléatoires, les différences de système d’exploitation ou d’architecture de la machine.

Certaines solutions logicielles de reconnaissance d’images ne sont en réalité pas uniquement basées sur des algorithmes, mais utilisent plutôt le concept de réseau neuronal . Découvrez http://en.wikipedia.org/wiki/Artificial_neural_network et notamment NeuronDotNet, qui comprend également des exemples intéressants: http://neurondotnet.freehostia.com/index.html

Il existe des recherches connexes utilisant les réseaux de neurones / cartes auto-organisasortingces de Kohonen

Les deux systèmes académiques (Google for PicSOM) ou moins académiques
( http://www.generation5.org/content/2004/aiSomPic.asp (peut-être pas adapté à tous les environnements de travail)) des présentations existent.

Le calcul de la sum des carrés des différences entre les valeurs de couleur des pixels d’une version considérablement réduite (par exemple: 6×6 pixels) fonctionne parfaitement. Les images identiques produisent 0, les images similaires génèrent de petits nombres, les images différentes produisent de gros nombres.

L’idée des autres gars ci-dessus de pénétrer dans YUV semble d’abord insortinggante – alors que mon idée fonctionne très bien, je veux que mes images soient calculées comme “différentes” pour donner un résultat correct – même du sharepoint vue d’un observateur daltonien.

Mon laboratoire avait également besoin de résoudre ce problème et nous avons utilisé Tensorflow. Voici une implémentation complète de l’application pour visualiser la similarité des images.

Pour un tutoriel sur la vectorisation des images pour le calcul de similarité, consultez cette page . Voici le Python (encore une fois, voir le post pour le workflow complet):

from __future__ import absolute_import, division, print_function """ This is a modification of the classify_images.py script in Tensorflow. The original script produces ssortingng labels for input images (eg you input a picture of a cat and the script returns the ssortingng "cat"); this modification reads in a directory of images and generates a vector representation of the image using the penultimate layer of neural network weights. Usage: python classify_images.py "../image_dir/*.jpg" """ # Copyright 2015 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # dissortingbuted under the License is dissortingbuted on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Simple image classification with Inception. Run image classification with Inception trained on ImageNet 2012 Challenge data set. This program creates a graph from a saved GraphDef protocol buffer, and runs inference on an input JPEG image. It outputs human readable ssortingngs of the top 5 predictions along with their probabilities. Change the --image_file argument to any jpg image to compute a classification of that image. Please see the tutorial and website for a detailed description of how to use this script to perform image recognition. https://tensorflow.org/tutorials/image_recognition/ """ import os.path import re import sys import tarfile import glob import json import psutil from collections import defaultdict import numpy as np from six.moves import urllib import tensorflow as tf FLAGS = tf.app.flags.FLAGS # classify_image_graph_def.pb: # Binary representation of the GraphDef protocol buffer. # imagenet_synset_to_human_label_map.txt: # Map from synset ID to a human readable ssortingng. # imagenet_2012_challenge_label_map_proto.pbtxt: # Text representation of a protocol buffer mapping a label to synset ID. tf.app.flags.DEFINE_ssortingng( 'model_dir', '/tmp/imagenet', """Path to classify_image_graph_def.pb, """ """imagenet_synset_to_human_label_map.txt, and """ """imagenet_2012_challenge_label_map_proto.pbtxt.""") tf.app.flags.DEFINE_ssortingng('image_file', '', """Absolute path to image file.""") tf.app.flags.DEFINE_integer('num_top_predictions', 5, """Display this many predictions.""") # pylint: disable=line-too-long DATA_URL = 'http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz' # pylint: enable=line-too-long class NodeLookup(object): """Converts integer node ID's to human readable labels.""" def __init__(self, label_lookup_path=None, uid_lookup_path=None): if not label_lookup_path: label_lookup_path = os.path.join( FLAGS.model_dir, 'imagenet_2012_challenge_label_map_proto.pbtxt') if not uid_lookup_path: uid_lookup_path = os.path.join( FLAGS.model_dir, 'imagenet_synset_to_human_label_map.txt') self.node_lookup = self.load(label_lookup_path, uid_lookup_path) def load(self, label_lookup_path, uid_lookup_path): """Loads a human readable English name for each softmax node. Args: label_lookup_path: ssortingng UID to integer node ID. uid_lookup_path: ssortingng UID to human-readable ssortingng. Returns: dict from integer node ID to human-readable ssortingng. """ if not tf.gfile.Exists(uid_lookup_path): tf.logging.fatal('File does not exist %s', uid_lookup_path) if not tf.gfile.Exists(label_lookup_path): tf.logging.fatal('File does not exist %s', label_lookup_path) # Loads mapping from ssortingng UID to human-readable ssortingng proto_as_ascii_lines = tf.gfile.GFile(uid_lookup_path).readlines() uid_to_human = {} p = re.comstack(r'[n\d]*[ \S,]*') for line in proto_as_ascii_lines: parsed_items = p.findall(line) uid = parsed_items[0] human_ssortingng = parsed_items[2] uid_to_human[uid] = human_ssortingng # Loads mapping from ssortingng UID to integer node ID. node_id_to_uid = {} proto_as_ascii = tf.gfile.GFile(label_lookup_path).readlines() for line in proto_as_ascii: if line.startswith(' target_class:'): target_class = int(line.split(': ')[1]) if line.startswith(' target_class_ssortingng:'): target_class_ssortingng = line.split(': ')[1] node_id_to_uid[target_class] = target_class_ssortingng[1:-2] # Loads the final mapping of integer node ID to human-readable ssortingng node_id_to_name = {} for key, val in node_id_to_uid.items(): if val not in uid_to_human: tf.logging.fatal('Failed to locate: %s', val) name = uid_to_human[val] node_id_to_name[key] = name return node_id_to_name def id_to_ssortingng(self, node_id): if node_id not in self.node_lookup: return '' return self.node_lookup[node_id] def create_graph(): """Creates a graph from saved GraphDef file and returns a saver.""" # Creates graph from saved graph_def.pb. with tf.gfile.FastGFile(os.path.join( FLAGS.model_dir, 'classify_image_graph_def.pb'), 'rb') as f: graph_def = tf.GraphDef() graph_def.ParseFromSsortingng(f.read()) _ = tf.import_graph_def(graph_def, name='') def run_inference_on_images(image_list, output_dir): """Runs inference on an image list. Args: image_list: a list of images. output_dir: the directory in which image vectors will be saved Returns: image_to_labels: a dictionary with image file keys and predicted text label values """ image_to_labels = defaultdict(list) create_graph() with tf.Session() as sess: # Some useful tensors: # 'softmax:0': A tensor containing the normalized prediction across # 1000 labels. # 'pool_3:0': A tensor containing the next-to-last layer containing 2048 # float description of the image. # 'DecodeJpeg/contents:0': A tensor containing a ssortingng providing JPEG # encoding of the image. # Runs the softmax tensor by feeding the image_data as input to the graph. softmax_tensor = sess.graph.get_tensor_by_name('softmax:0') for image_index, image in enumerate(image_list): try: print("parsing", image_index, image, "\n") if not tf.gfile.Exists(image): tf.logging.fatal('File does not exist %s', image) with tf.gfile.FastGFile(image, 'rb') as f: image_data = f.read() predictions = sess.run(softmax_tensor, {'DecodeJpeg/contents:0': image_data}) predictions = np.squeeze(predictions) ### # Get penultimate layer weights ### feature_tensor = sess.graph.get_tensor_by_name('pool_3:0') feature_set = sess.run(feature_tensor, {'DecodeJpeg/contents:0': image_data}) feature_vector = np.squeeze(feature_set) outfile_name = os.path.basename(image) + ".npz" out_path = os.path.join(output_dir, outfile_name) np.savetxt(out_path, feature_vector, delimiter=',') # Creates node ID --> English ssortingng lookup. node_lookup = NodeLookup() top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1] for node_id in top_k: human_ssortingng = node_lookup.id_to_ssortingng(node_id) score = predictions[node_id] print("results for", image) print('%s (score = %.5f)' % (human_ssortingng, score)) print("\n") image_to_labels[image].append( { "labels": human_ssortingng, "score": str(score) } ) # close the open file handlers proc = psutil.Process() open_files = proc.open_files() for open_file in open_files: file_handler = getattr(open_file, "fd") os.close(file_handler) except: print('could not process image index',image_index,'image', image) return image_to_labels def maybe_download_and_extract(): """Download and extract model tar file.""" dest_directory = FLAGS.model_dir if not os.path.exists(dest_directory): os.makedirs(dest_directory) filename = DATA_URL.split('/')[-1] filepath = os.path.join(dest_directory, filename) if not os.path.exists(filepath): def _progress(count, block_size, total_size): sys.stdout.write('\r>> Downloading %s %.1f%%' % ( filename, float(count * block_size) / float(total_size) * 100.0)) sys.stdout.flush() filepath, _ = urllib.request.urlresortingeve(DATA_URL, filepath, _progress) print() statinfo = os.stat(filepath) print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.') tarfile.open(filepath, 'r:gz').extractall(dest_directory) def main(_): maybe_download_and_extract() if len(sys.argv) < 2: print("please provide a glob path to one or more images, eg") print("python classify_image_modified.py '../cats/*.jpg'") sys.exit() else: output_dir = "image_vectors" if not os.path.exists(output_dir): os.makedirs(output_dir) images = glob.glob(sys.argv[1]) image_to_labels = run_inference_on_images(images, output_dir) with open("image_to_labels.json", "w") as img_to_labels_out: json.dump(image_to_labels, img_to_labels_out) print("all done") if __name__ == '__main__': tf.app.run() 

Cela ressemble à un problème de vision. Vous voudrez peut-être examiner l’Adaptive Boosting ainsi que l’algorithme Burns Line Extraction. Les concepts dans ces deux devraient aider à aborder ce problème. La détection des contours est un endroit encore plus simple à démarrer si vous découvrez les algorithmes de vision, car elle explique les bases.

En ce qui concerne les parameters de catégorisation:

• Palette de couleurs et localisation (calcul du dégradé, histogramme des couleurs)
• Formes contenues (Boosting / Formation pour détecter les formes)

Selon la précision des résultats dont vous avez besoin, vous pouvez simplement casser les images en blocs nxn pixels et les parsingr. Si vous obtenez des résultats différents dans le premier bloc, vous ne pouvez pas arrêter le traitement, ce qui entraîne des améliorations de performances.

Pour parsingr les carrés, vous pouvez par exemple obtenir la sum des valeurs de couleur.

Vous pouvez effectuer une sorte d’estimation de mouvement de correspondance de bloc entre les deux images et mesurer la sum globale des résidus et des coûts de vecteur de mouvement (un peu comme on le ferait dans un encodeur vidéo). Cela compenserait le mouvement; pour les points bonus, effectuez une estimation du mouvement par transformation affine (compense les zooms et les étirements, etc.). Vous pouvez également faire des blocs superposés ou un stream optique.

En premier lieu, vous pouvez essayer d’utiliser des histogrammes de couleur. Cependant, vous devez vraiment limiter votre domaine de problème. La correspondance d’image générique est un problème très difficile.

J’ai trouvé cet article très utile pour expliquer comment cela fonctionne:

http://www.hackerfactor.com/blog/index.php?/archives/432-Looks-Like-It.html

Toutes mes excuses pour avoir participé tardivement à la discussion.

Nous pouvons même utiliser la méthodologie ORB pour détecter des points similaires entre deux images. Le lien suivant donne une implémentation directe d’ORB en python

http://scikit-image.org/docs/dev/auto_examples/plot_orb.html

Même openCV a implémenté directement ORB. Si vous avez plus d’informations, suivez l’article de recherche ci-dessous.

https://www.researchgate.net/publication/292157133_Image_Matching_Using_SIFT_SURF_BRIEF_and_ORB_Performance_Comparison_for_Distorted_Images

Il y a quelques bonnes réponses à ce sujet, mais je me demande si quelque chose impliquant une parsing spectrale pourrait fonctionner? C’est-à-dire diviser l’image en informations de phase et d’amplitude et les comparer. Cela peut éviter certains problèmes liés aux différences de culture, de transformation et d’intensité. Quoi qu’il en soit, c’est juste moi qui spécule car cela semble être un problème intéressant. Si vous avez effectué une recherche sur http://scholar.google.com, je suis sûr que vous pourriez proposer plusieurs articles à ce sujet.