it-swarm-vi.tech

Thuật toán tìm hình ảnh tương tự

Tôi cần một thuật toán có thể xác định xem hai hình ảnh có giống nhau hay không và nhận ra các kiểu màu, độ sáng, hình dạng tương tự, v.v. Tôi có thể cần một số gợi ý về thông số mà bộ não con người sử dụng để phân loại hình ảnh. ..

Tôi đã xem xét kết hợp dựa trên hausdorff nhưng dường như chủ yếu để khớp các đối tượng biến đổi và mô hình hình dạng.

76
kitsune

Tôi đã làm một cái gì đó tương tự, bằng cách phân tách hình ảnh thành chữ ký bằng cách sử dụng biến đổi wavelet .

Cách tiếp cận của tôi là chọn các hệ số có ý nghĩa n từ mỗi kênh được chuyển đổi và ghi lại vị trí của chúng. Điều này đã được thực hiện bằng cách sắp xếp danh sách các bộ dữ liệu (sức mạnh, vị trí) theo abs (sức mạnh). Hình ảnh tương tự sẽ chia sẻ sự tương đồng ở chỗ chúng sẽ có hệ số đáng kể ở cùng một nơi.

Tôi thấy tốt nhất là chuyển đổi hình ảnh thành định dạng YUV, cho phép bạn có hiệu quả tương tự về trọng lượng về hình dạng (kênh Y) và màu sắc (kênh UV).

Bạn có thể tìm thấy cách triển khai của tôi ở trên trong mactorii , thật không may là tôi đã không làm việc nhiều như tôi nên có :-)

Một phương pháp khác, mà một số người bạn của tôi đã sử dụng với kết quả tốt đáng ngạc nhiên, chỉ đơn giản là thay đổi kích thước hình ảnh của bạn xuống để nói, một pixel 4 x 4 và lưu trữ là chữ ký của bạn. Làm thế nào có thể ghi được 2 hình ảnh tương tự bằng cách nói, tính toán khoảng cách Manhattan giữa 2 hình ảnh, sử dụng các pixel tương ứng. Tôi không có chi tiết về cách họ thực hiện thay đổi kích thước, vì vậy bạn có thể phải chơi với các thuật toán khác nhau có sẵn cho tác vụ đó để tìm một thuật toán phù hợp.

55
freespace

pHash có thể bạn quan tâm.

băm tri giác n. dấu vân tay của tệp âm thanh, video hoặc hình ảnh dựa trên toán học dựa trên nội dung âm thanh hoặc hình ảnh có trong đó. Không giống như các hàm băm mật mã dựa trên hiệu ứng tuyết lở của những thay đổi nhỏ trong đầu vào dẫn đến những thay đổi mạnh mẽ trong đầu ra, các giá trị băm nhận thức sẽ "gần gũi" với nhau nếu các đầu vào tương tự về mặt thị giác hoặc thính giác.

43
Alvis

Tôi đã sử dụng SIFT để phát hiện lại cùng một đối tượng trong các hình ảnh khác nhau. Nó thực sự mạnh mẽ nhưng khá phức tạp và có thể là quá mức cần thiết. Nếu các hình ảnh được cho là khá giống nhau, một số thông số đơn giản dựa trên sự khác biệt giữa hai hình ảnh có thể cho bạn biết khá nhiều. Một số gợi ý:

  • Bình thường hóa hình ảnh tức là làm cho độ sáng trung bình của cả hai hình ảnh giống nhau bằng cách tính độ sáng trung bình của cả hai và giảm độ sáng xuống theo tỷ lệ (để tránh cắt ở mức cao nhất)) đặc biệt nếu bạn quan tâm đến hình dạng hơn trong màu.
  • Tổng chênh lệch màu so với hình ảnh chuẩn hóa trên mỗi kênh.
  • tìm các cạnh trong ảnh và đo khoảng cách giữa các pixel cạnh trong cả hai ảnh. (cho hình dạng)
  • Chia hình ảnh trong một tập hợp các vùng riêng biệt và so sánh màu trung bình của từng vùng.
  • Ngưỡng các hình ảnh ở một (hoặc một bộ) (s) và đếm số pixel mà hình ảnh đen/trắng thu được khác nhau.
12
jilles de wit

Bạn có thể sử dụng Nhận dạng hình ảnh khác biệt

Đây là một tiện ích dòng lệnh so sánh hai hình ảnh bằng cách sử dụng một số liệu cảm nhận. Đó là, nó sử dụng một mô hình tính toán của hệ thống thị giác của con người để xác định xem hai hình ảnh có khác nhau về mặt thị giác hay không, vì vậy những thay đổi nhỏ về pixel bị bỏ qua. Thêm vào đó, nó làm giảm đáng kể số lượng dương tính giả gây ra bởi sự khác biệt trong việc tạo số ngẫu nhiên, hệ điều hành hoặc sự khác biệt về kiến ​​trúc máy.

5
Alejandro Bologna

Phòng thí nghiệm của tôi cũng cần phải giải quyết vấn đề này và chúng tôi đã sử dụng Tensorflow. Đây là một ứng dụng đầy đủ triển khai để hiển thị hình ảnh tương tự.

Để xem hướng dẫn về hình ảnh vector hóa cho tính toán tương tự, hãy xem trang này . Đây là Python (một lần nữa, xem bài đăng để biết quy trình làm việc đầy đủ):

from __future__ import absolute_import, division, print_function

"""

This is a modification of the classify_images.py
script in Tensorflow. The original script produces
string labels for input images (e.g. you input a picture
of a cat and the script returns the string "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
# distributed under the License is distributed 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
strings 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 string.
# imagenet_2012_challenge_label_map_proto.pbtxt:
#   Text representation of a protocol buffer mapping a label to synset ID.
tf.app.flags.DEFINE_string(
    '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_string('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: string UID to integer node ID.
      uid_lookup_path: string UID to human-readable string.

    Returns:
      dict from integer node ID to human-readable string.
    """
    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 string UID to human-readable string
    proto_as_ascii_lines = tf.gfile.GFile(uid_lookup_path).readlines()
    uid_to_human = {}
    p = re.compile(r'[n\d]*[ \S,]*')
    for line in proto_as_ascii_lines:
      parsed_items = p.findall(line)
      uid = parsed_items[0]
      human_string = parsed_items[2]
      uid_to_human[uid] = human_string

    # Loads mapping from string 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_string:'):
        target_class_string = line.split(': ')[1]
        node_id_to_uid[target_class] = target_class_string[1:-2]

    # Loads the final mapping of integer node ID to human-readable string
    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_string(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.ParseFromString(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 string 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 string lookup.
          node_lookup = NodeLookup()

          top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]
          for node_id in top_k:
            human_string = node_lookup.id_to_string(node_id)
            score = predictions[node_id]
            print("results for", image)
            print('%s (score = %.5f)' % (human_string, score))
            print("\n")

            image_to_labels[image].append(
              {
                "labels": human_string,
                "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.urlretrieve(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, e.g.")
    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 __== '__main__':
  tf.app.run()
5
duhaime

Đó là một vấn đề khó khăn! Nó phụ thuộc vào mức độ chính xác mà bạn cần phải có, và nó phụ thuộc vào loại hình ảnh bạn đang làm việc. Bạn có thể sử dụng biểu đồ để so sánh màu sắc, nhưng điều đó rõ ràng không tính đến sự phân bố không gian của các màu đó trong hình ảnh (tức là các hình dạng). Phát hiện cạnh theo sau là một số loại phân đoạn (nghĩa là chọn ra các hình dạng) có thể cung cấp một mẫu để khớp với hình ảnh khác. Bạn có thể sử dụng ma trận phối hợp để so sánh kết cấu, bằng cách xem hình ảnh là ma trận của các giá trị pixel và so sánh các ma trận đó. Có một số cuốn sách hay về khả năng khớp hình ảnh và thị giác máy - Một tìm kiếm trên Amazon sẽ tìm thấy một số.

Hi vọng điêu nay co ich!

4
Ben

Một số giải pháp phần mềm nhận dạng hình ảnh thực sự không hoàn toàn dựa trên thuật toán, nhưng sử dụng khái niệm mạng thần kinh để thay thế. Hãy xem http://en.wikipedia.org/wiki/Art mẫu_neural_network và cụ thể là NeuronDotNet, cũng bao gồm các mẫu thú vị: http://neurondotnet.freehostia.com/index.html = =

3
petr k.

Có nghiên cứu liên quan sử dụng mạng lưới thần kinh Kohonen/bản đồ tự tổ chức

Cả hai hệ thống học thuật hơn (Google cho PicSOM) hoặc ít học hơn
[.__.] ( http://www.generation5.org/content/2004/aiSomPic.asp , (có thể không phù hợp với tất cả các môi trường làm việc)) tồn tại.

3
EPa

Tính tổng bình phương của sự khác biệt của các giá trị màu pixel của phiên bản giảm mạnh (ví dụ: 6x6 pixel) hoạt động độc đáo. Hình ảnh giống hệt nhau mang lại 0, hình ảnh tương tự mang lại số lượng nhỏ, hình ảnh khác nhau mang lại hình ảnh lớn.

Những người khác ở trên ý tưởng đột nhập vào YUV nghe có vẻ hấp dẫn - trong khi ý tưởng của tôi hoạt động tốt, tôi muốn hình ảnh của mình được tính là "khác biệt" để nó mang lại kết quả chính xác - ngay cả từ góc nhìn của người quan sát màu.

3
chris

Điều này nghe có vẻ như một vấn đề tầm nhìn. Bạn có thể muốn xem xét Tăng cường thích ứng cũng như thuật toán trích xuất dòng Burns. Các khái niệm trong hai điều này sẽ giúp tiếp cận vấn đề này. Phát hiện cạnh là một nơi thậm chí đơn giản hơn để bắt đầu nếu bạn chưa quen với thuật toán thị giác, vì nó giải thích những điều cơ bản.

Theo như các tham số để phân loại:

  • Bảng màu & Vị trí (Tính toán độ dốc, biểu đồ màu sắc)
  • Hình dạng có chứa (Ada. Tăng cường/Đào tạo để phát hiện hình dạng)
2
willasaywhat

Tùy thuộc vào mức độ chính xác mà bạn cần, bạn chỉ cần phá vỡ hình ảnh trong các khối n x n pixel và phân tích chúng. Nếu bạn nhận được kết quả khác nhau trong khối đầu tiên, bạn không thể ngừng xử lý, dẫn đến một số cải tiến hiệu suất.

Để phân tích các hình vuông, ví dụ bạn có thể lấy tổng các giá trị màu.

2
JValente

Xin lỗi vì tham gia muộn trong cuộc thảo luận.

Chúng tôi thậm chí có thể sử dụng phương pháp ORB để phát hiện các điểm tính năng tương tự giữa hai hình ảnh. Liên kết sau đây cho phép triển khai trực tiếp ORB trong python

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

Ngay cả openCV cũng đã triển khai ORB trực tiếp. Nếu bạn biết thêm thông tin theo bài viết nghiên cứu được đưa ra dưới đây.

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

1
Vivek Srinivasan

Tôi thấy bài viết này rất hữu ích giải thích cách thức hoạt động:

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

1
andi

Bạn có thể thực hiện một số loại ước tính chuyển động khớp khối giữa hai hình ảnh và đo tổng tổng phần dư và chi phí vectơ chuyển động (giống như cách thực hiện trong bộ mã hóa video). Điều này sẽ bù cho chuyển động; đối với các điểm thưởng, hãy ước lượng chuyển động affine (bù cho thu phóng và kéo dài và tương tự). Bạn cũng có thể thực hiện các khối chồng chéo hoặc luồng quang.

1
Dark Shikari

Khi vượt qua lần đầu tiên, bạn có thể thử sử dụng biểu đồ màu. Tuy nhiên, bạn thực sự cần phải thu hẹp miền vấn đề của bạn. Phù hợp với hình ảnh chung là một vấn đề rất khó khăn.

1
Dima

Có một số câu trả lời tốt trong chủ đề khác về vấn đề này, nhưng tôi tự hỏi nếu một cái gì đó liên quan đến phân tích quang phổ sẽ làm việc? Tức là, chia hình ảnh xuống thông tin về pha và biên độ của nó và so sánh chúng. Điều này có thể tránh một số vấn đề với cắt xén, biến đổi và cường độ khác nhau. Dù sao, đó chỉ là tôi suy đoán vì đây có vẻ là một vấn đề thú vị. Nếu bạn đã tìm kiếm http://scholar.google.com Tôi chắc chắn rằng bạn có thể đưa ra một số bài viết về điều này.

0
dbrien