1.Tout d'abord

Voici ATcat, un stagiaire d'Aidemy. Utilisez-vous Instagram? J'utilise souvent Instagram pour regarder des images de chats, mais lorsque je recherche des images de chats, je me mélange souvent avec des images autres que celles de chats comme le montre la figure ci-dessous. Il semble donc que seule l'image d'un chat a du mal à changer le système côté Insta, et je n'ai pas assez de temps pour créer une application dédiée, j'ai donc une image qui est dite "chat" sur Insta J'ai créé un système qui ne peut extraire que des images de chats.

2. Détection d'objets

Cette fois, j'ai utilisé la détection d'objets pour extraire l'image d'un chat, et j'expliquerai brièvement cette technique appelée détection d'objets. La reconnaissance d'image est une technologie qui identifie uniquement ce qui est capturé à partir des caractéristiques de l'image entière lorsqu'il y a un objet d'intérêt dans l'image. La détection d'objet est une technologie qui identifie où et ce qui est capturé. En d'autres termes, pour les objets contenus dans l'image, quel est l'objet remarquable dans l'objet et où l'objet est spécifié, et il est représenté par un rectangle appelé boîte englobante. Il existe également une technique appelée segmentation sémantique, qui est plus compliquée car elle trie par pixel. Cette fois, nous avons mis en œuvre le modèle pré-entraîné de Google, mais la raison en est que la préparation d'un ensemble de données, l'apprentissage du temps, la définition d'un nombre approprié de classes, etc. pour créer et apprendre un modèle à partir de zéro prennent énormément de temps. En effet, les modèles pré-formés sont très souvent utilisés dans l'industrie.

3. Préparation préalable

Tout d'abord, j'ai décidé de collecter des images à partir des hash tags de #cat et #cat afin de collecter des images de chats d'Instagram. À cette époque, j'utilisais une API appelée Instagram Scraper.

pip install instagram-scraper

Tout d'abord, installez avec pip. Instagram Scraper vous permet de récupérer les publications d'utilisateurs spécifiques et les images et vidéos publiées avec des balises de hachage spécifiées. Cette fois, je l'ai exécuté comme suit.

`insta.sh`


#!/bin/sh
instagram_login_user='' #Ton nom d'utilisateur
instagram_login_pass='' #Votre mot de passe

target_tag='cat' #Balises à gratter

instagram-scraper \
 --login_user $instagram_login_user \
 --login_pass $instagram_login_pass \
 --tag $target_tag \ 
 --media-types image \　#Spécifiez le type de données à acquérir
 --maximum 100 \ #Nombre maximum de données à récupérer
 --latest \ #Commencez par où vous avez gratté pour la dernière fois

J'ai mis le nombre à 200.

J'ai pu obtenir l'image comme ça.

4. Mise en œuvre

Ensuite, l'image acquise est déterminée comme étant un chat par détection d'objet. Ici, nous avons implémenté Faster R-CNN et SSD, qui sont les modèles pré-appris de Google, en utilisant Google Colaboratory via Tensorflow Hub.

Cette fois, je l'ai implémenté en référence au site suivant. https://qiita.com/code0327/items/3b23fd5002b373dc8ae8

Le flux ici est d'acquérir et de définir un modèle pré-entraîné via le Tensorflow Hub, et d'effectuer une détection d'objet sur l'image du chat acquise sur l'insta. Après cela, seulement lorsqu'un chat est détecté, une image montrant le résultat de la détection sera sortie.

Tout d'abord, sélectionnez le modèle importé et entraîné.


# For running inference on the TF-Hub module.
import tensorflow as tf
import tensorflow_hub as hub
import os 
import glob
import time
import numpy as np
import matplotlib.patheffects as pe 
import matplotlib.pyplot as plt
import tempfile
from six.moves.urllib.request import urlopen
from six import BytesIO
import numpy as np
from PIL import Image
from PIL import ImageColor
from PIL import ImageDraw
from PIL import ImageFont
from PIL import ImageOps

#SSD ou Faster R-Sélectionnez CNN
#module_handle = 'https://tfhub.dev/google/openimages_v4/ssd/mobilenet_v2/1' 
module_handle = 'https://tfhub.dev/google/faster_rcnn/openimages_v4/inception_resnet_v2/1'

detector = hub.load(module_handle).signatures['default']

L'image du résultat de la détection d'objet est la suivante.


def showImage(img, r, imgfile, min_score=0.1):
  fig = plt.figure(dpi=150,figsize=(8,8))
  ax = plt.gca()
  ax.tick_params(axis='both', which='both', left=False, 
                 labelleft=False, bottom=False, labelbottom=False)
  ax.imshow(img)

  decode = np.frompyfunc( lambda p : p.decode("ascii"), 1, 1)

  boxes =       r['detection_boxes']
  scores =      r['detection_scores']
  class_names = decode( r['detection_class_entities'] )

  n = np.count_nonzero(scores >= min_score)

  # class_Préparation de la couleur correspondant aux noms
  class_set = np.unique(class_names[:n])
  colors = dict()
  cmap = plt.get_cmap('tab10')
  for i, v in enumerate(class_set):
    colors[v] =cmap(i)

  #Dessinez un rectangle Dessinez celui avec le score le plus bas
  img_w = img.shape[1]
  img_h = img.shape[0]
  for i in reversed(range(n)):
    text = f'{class_names[i]} {100*scores[i]:.0f}%'
    color = colors[class_names[i]]
    y1, x1, y2, x2 = tuple(boxes[i])
    y1, y2 = y1*img_h, y2*img_h
    x1, x2 = x1*img_w, x2*img_w

    #Cadre
    r = plt.Rectangle(xy=(x1, y1), width=(x2-x1), height=(y2-y1),
                      fill=False, edgecolor=color, joinstyle='round', 
                      clip_on=False, zorder=8+(n-i) )
    ax.add_patch( r )

    #Tags: texte
    t = ax.text(x1+img_w/200, y1-img_h/300, text, va='bottom', fontsize=6, color=color,zorder=8+(n-i))
    t.set_path_effects([pe.Stroke(linewidth=1.5,foreground='white'), pe.Normal()])
    fig.canvas.draw()
    r = fig.canvas.get_renderer()
    coords = ax.transData.inverted().transform(t.get_window_extent(renderer=r))
    tag_w = abs(coords[0,0]-coords[1,0])+img_w/100
    tag_h = abs(coords[0,1]-coords[1,1])+img_h/120

    #Tags: arrière-plan
    r = plt.Rectangle(xy=(x1, y1-tag_h), width=tag_w, height=tag_h,
                      edgecolor=color, facecolor=color,
                      joinstyle='round', clip_on=False, zorder=8+(n-i))
    ax.add_patch( r )
  #sauvegarder
  plt.savefig('/content/save/'+imgfile)
  plt.close()

J'essaye de localiser en le plaçant avec un rectangle pour ceux avec une fiabilité de min_score ou plus.

Enfin, définissez la fonction à détecter.


import time
import numpy as np
import PIL.Image as Image

def run_detector(detector, path,img_file):
  #Importez l'image et convertissez-la dans un format pouvant être entré dans le détecteur
  img = Image.open(path+img_file) # Pillow(PIL)
  if img.mode == 'RGBA' :
    img = img.convert('RGB')
  converted_img = img.copy()
  converted_img = converted_img.resize((227,227),Image.LANCZOS) #Réduire à la taille d'entrée
  converted_img = np.array(converted_img, dtype=np.float32)     # np.Convertir en tableau
  converted_img = converted_img / 255. # 0.0 ～ 1.Normalisé à 0
  converted_img = converted_img.reshape([1,227,227,3])
  converted_img = tf.constant(converted_img)

  t1 = time.time()
  result = detector(converted_img) #Détection générale des objets (corps principal)
  t2 = time.time()
  print(f'Temps de détection: {t2-t1:.3f}Secondes' )

  #Préparation à la sortie du résultat sous forme de texte
  r = {key:value.numpy() for key,value in result.items()}
  boxes =       r['detection_boxes']
  scores =      r['detection_scores']
  decode = np.frompyfunc( lambda p : p.decode('ascii'), 1, 1)
  class_names = decode( r['detection_class_entities'] )

  #Le score est de 0.Sortie texte pour plus de 25 résultats (n)
  print(f'Objet de découverte' )
  n = np.count_nonzero(scores >= 0.25 )
  for i in range(n):
    y1, x1, y2, x2 = tuple(boxes[i])
    x1, x2 = int(x1*img.width), int(x2*img.width)
    y1, y2 = int(y1*img.height),int(y2*img.height)
    t = f'{class_names[i]:10} {100*scores[i]:3.0f}%  '
    t += f'({x1:>4},{y1:>4}) - ({x2:>4},{y2:>4})'
    print(t)
  #Sortie lorsqu'un chat est détecté
    if "Cat" in t:
      showImage(np.array(img), r, img_file,min_score=0.25) #Superposer le résultat de la détection sur l'image
  return t2-t1

Cette fois, je veux sortir quand un chat est détecté, donc je l'ai fait sortir quand la classe "Cat" est détectée.

5. Résultat

À la suite de cette période, 73 images sur 100 ont été détectées et sorties grâce à Faster R-CNN. Voici un exemple qui pourrait être détecté par les deux.

<img width="340" alt="代替テキスト" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/689144/66be9ed0-b85c-9f6f-64d2-d384179cf23f.jpeg " "SSDの結果"><img width="340" alt="代替テキスト" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/689144/3b5b960a-26e5-90aa-3187-ac236aefcb60.jpeg " "Faster R-CNNの結果"> Dans cette figure, le côté gauche est le résultat SSD et le côté droit est le résultat Faster R-CNN. Le temps de détection moyen était de 0,23 seconde pour le SSD et de 1,30 seconde pour le Faster R-CNN. De plus, le résultat était de 74 pour SSD. Bien que le nombre de feuilles soit proche, je pense qu'il est bien entendu qu'il y a étonnamment beaucoup d'images détectées comme des chats qui ne sont pas couvertes, et qu'il y a des forces et des faiblesses dans les images par la méthode de détection. Les deux résultats ne contenaient presque aucune image autre que des chats, on peut donc dire qu'ils n'ont réussi à capturer que des images de chats. L'image suivante était un exemple de ce que j'ai obtenu même si je n'étais pas un chat. 代替テキスト Quand j'ai regardé la liste, j'ai pensé que c'était un chat, mais quand j'ai regardé de près, c'était un chien. De plus, parmi les images détectées comme chats, celle qui détectait le chat sur la photo était rare. Je pensais que c'était assez intéressant de pouvoir détecter ne serait-ce qu'un chat photo, mais il semble difficile de définir une classe car il est nécessaire d'étudier là-bas pour faire la distinction entre un chat photo et un vrai chat. 代替テキスト

Résumé

J'ai pu détecter l'image du chat et l'empêcher de capter d'autres images. Cependant, comme il a été constaté qu'il y a des omissions dans chaque méthode de détection, à l'avenir, il sera possible d'acquérir les deux en combinaison, de mettre en œuvre la détection d'objets à l'aide des désormais populaires DETR et YOLOv5, et d'utiliser la segmentation sémantique. Je voudrais essayer de créer un système qui ne peut extraire que la partie chat de l'image. Merci de rester avec nous jusqu'à la fin!

Site référencé

https://qiita.com/code0327/items/3b23fd5002b373dc8ae8 https://github.com/arc298/instagram-scraper https://githubja.com/rarcega/instagram-scraper

[PYTHON] Je veux détecter des images de chats d'Instagram