[PYTHON] Machine Sommelier par Keras-

Dans cet article, l'auteur, qui se méfie du deep learning, examine la capacité de classification du deep learning. Il y a des endroits où des images de sites Web et de Youtube sont citées après vérification (description de la source). Bien que ce soit à des fins académiques, nous le supprimerons s'il y a un problème. ** En outre, collectez les images vous-même lorsque vous utilisez le programme. ** **

introduction

Introduction Introduction

Pourquoi avez-vous décidé que c'était le vide ...

Figure 0.Réseau neuronal d'images d'hommes manipulant R2D2(VGG16)Le résultat de la classification par. Dans le graphique ci-dessous, les classes de prédiction sont organisées par ordre décroissant de certitude à partir de la gauche.

7 machines-outils majeures (détails dans Nikkan Kogyo Shimbun, 11 mars 2020)

Figure 1.7 grandes entreprises de machines-outils (commandes reçues en février 2020) Si vous êtes intéressé par le contenu de cet article, veuillez consulter la page Web actuelle. https://www.nikkan.co.jp/articles/view/00551108

Quelle est la puissance de la classification par apprentissage profond?

Cela n'a rien à voir avec le contenu de l'article (ventes de chaque entreprise), mais je me demandais si les produits de ces 7 entreprises pouvaient être classés par apprentissage profond, alors je l'ai essayé. ―― Puisque la machine-outil est un produit, il semble que des données seront collectées et j'ai pensé qu'il serait facile de la modéliser mathématiquement, alors je voulais voir comment elle était classée. ――Cette définition du problème n'est pas pratique, mais je pense que vous pouvez utiliser ce cadre de classification.

Points d'attention du réseau neuronal par Grad-CAM

Enfin, les critères de classification des images par Grad-CAM sont indiqués, mais ils ne sont pas inclus dans le programme publié. Je peux le publier à un moment donné dans le futur. Que ce soit pour juger en fonction du logo sans définir explicitement pour apprendre avec le logo, ou pour juger en fonction de points étranges. Eh bien, tous les produits n'ont pas de logo, il peut donc s'agir d'une vitrine de la puissance de l'apprentissage en profondeur.

À propos du titre

Le mot sommelier est un mot utilisé uniquement pour le vin, mais récemment il semble qu'il soit également utilisé pour d'autres que le vin sous la forme de "~ sommelier".

Environnement d'exécution du programme

• Windows10
• CPU:Core i7-7700HQ
• Memory: 16GB
• Graphic board: GTX1060 6GB
• Strage: NVMe M.2 SSD 1TB
• CUDA 9.0.176

Créez un modèle avec Keras pour classer les produits de 7 machines-outils majeures

--Les images sont collectées en ligne (principalement collectées à partir de la page produit de la page d'accueil de chaque entreprise) ――Nous allons réduire à un certain degré d'uniformité (je supprimerai le type de porte, etc. Surtout Toshiba Machine n'est que TUE-100. J'ai senti qu'il ne serait pas possible de le classer séparément si j'y mettais d'autres choses.) --Nommez l'ensemble de données comme 1_0001.jpg (expliqué au début du programme public) et placez-le dans le dossier de l'ensemble de données du programme (Figure2-a, Figure2-b).

• Vous pouvez deviner s'il faut apprendre avec Jupyter notebook, ou utiliser ResNet50 ou Mobilenet V1 (décrit plus loin) pour Backbone avec GUI (Tkinter)
• Les détails sur les paramètres et l'utilisation du notebook Jupyter sont expliqués au début du notebook.
• Le programme est sur la page github. https://github.com/moriitkys/MachineSommelier

Figure 2-a	Figure 2-b

Glossaire

Apprentissage profond Apprentissage profond

L'apprentissage en profondeur est une méthode d'apprentissage automatique. L'apprentissage automatique est une méthode qui permet de donner des échantillons de données, d'apprendre des modèles cachés dans les données et de trouver la relation entre l'entrée et la sortie. Parmi eux, le réseau neuronal est un modèle qui tente de réaliser l'apprentissage en imitant un circuit neuronal humain. Ce que l'on peut appeler l'origine du réseau de neurones est le simple perceptron proposé en 1958. L'apprentissage en profondeur est une couche plus profonde du réseau neuronal, et la base de ceci est le réseau neuronal de type propagation directe (Figure 3-b.). Un perceptron simple multiplie les nœuds d'entrée $ n $ par $ n $ poids $ w $ et les ajoute tous ensemble par la fonction $ f_ {(x)} $, comme le montre la figure 3-a. Suite à l'ajout de w_ {n + 1} $, 1 est généré si la sortie est au-dessus d'une certaine valeur, et 0 est généré si elle est inférieure à une certaine valeur.

Figure 3-a.Schéma conceptuel du perceptron simple	Figure 3-b.Schéma conceptuel du réseau neuronal à propagation directe

En outre, le réseau neuronal de type propagation directe dans la reconnaissance d'image est largement utilisé comme réseau neuronal convolutif.

Réseau de neurones à convolution

Un réseau neuronal convolutif (CNN) est un réseau neuronal à propagation directe dans lequel des unités du côté de la couche de sortie sont connectées à des unités spécifiques du côté de la couche d'entrée adjacente. CNN a une couche spéciale appelée couche de convolution et couche de regroupement. Dans la couche de convolution, une carte d'entités est obtenue en appliquant un filtre (noyau) aux données d'entrée. Bien que omis dans cet article, CNN est un processus très important dans la reconnaissance d'image. La figure 4 ci-dessous montre un exemple de traitement CNN.

Figure 4.Exemple de traitement CNN

Classification Classification des images

Je pense qu'il existe principalement quatre types dans le domaine de la reconnaissance d'image. Certaines applications ont une sortie plus complexe, mais cette fois, nous l'omettons.

** ・ Classification Classification de l'image ** Devinez à quelle classe l'entrée correspond (chaque sortie la probabilité), (Figure 5-a)

Figure 5-a.Exemple de classification. La classification avec VGG16 (un type de réseau, décrit ci-dessous) qui a été appris avec ImageNet (décrit plus tard) échoue à la suite de cet exemple (expliqué à la fin).

<détails> <résumé> [Pliage. Cliquez sur ▶] Au fait (vide) </ summary> ImageNet semble contenir des données comme les sites suivants. Il n'est pas étonnant que cela soit pris pour du vide ... https://www.myhenry.co.uk/

** ・ Détection de détection d'objet ** Devinez quelle classe d'objet existe dans quelle zone de coordonnées pour l'entrée avec un rectangle (Figure 5-b)

Figure 5-b.Exemple de détection. La détection par Yolo (un type d'architecture d'apprentissage) formé à Pascal VOC2012 (décrit plus loin) permet de bien détecter les personnes dans cet exemple, mais le robot"parking meter"Est mal reconnu.

<détails> <résumé> [Pliage. Cliquez sur ▶] Au fait (parcmètre) </ résumé> Ce à quoi ressemble le parcmètre était dans l'article suivant. https://arxiv.org/pdf/2003.07003.pdf Cela ressemble à un robot, mais ...

** ・ Division sémantique de la zone de segmentation sémantique ** Classez chaque pixel d'entrée (Figure 5-c)

Figure 5-c.Un exemple de segmentation sémantique. Deeplab V3 appris à Pascal VOC 2018+La segmentation sémantique par, dans cet exemple, devine correctement le domaine humain. Le robot est reconnu comme l'arrière-plan.

** · Segmentation d'instance ** = Détection + Segmentation (Figure 5-d)

Figure 5-d. Exemple de segmentation d'instance. La segmentation d'instance par masque R-CNN formé par Microsoft COCO (décrite plus loin) peut déduire le domaine humain dans cet exemple, mais c'est approximatif. Le robot est reconnu comme l'arrière-plan.

Cette fois, nous appliquons softmax à la fin du réseau et faisons une "** Classification **" pour deviner à quelle classe correspond l'entrée.

Backbone Backbone est un réseau d'extraction de fonctionnalités. Il s'agit de la partie dans laquelle la couche de la partie d'entrée et la partie de sortie (Tête) sont supprimées. Cette fois, nous utiliserons ResNet50 et Mobilenet (décrits plus loin). Les deux sont fournis par Keras, vous n'avez donc pas à créer votre propre réseau. Vous pouvez l'importer comme suit.

from keras.applications.resnet50 import ResNet50

base_model = ResNet50(
    include_top = False,
    weights = "imagenet",
    input_shape = INPUT_SHAPE
)

Puisque Backbone est un réseau de neurones, l'entraînement dans un certain ensemble de données détermine certains poids (poids dans le programme ci-dessus).

• ** "Un certain jeu de données" ** est publié sur le net et peut être téléchargé (bien qu'il s'agisse d'une très grande quantité de données comme de plusieurs Go à plusieurs dizaines de Go). Par exemple, Microsoft COCO, ImageNet, Pascal VOC, etc. sont-ils connus?
• ** "Un peu de poids" ** est également ouvert au public. Cependant, cela est important dans quel réseau vous avez appris avec quel jeu de données. Par exemple, ResNet 50 et Mobilenet V1 utilisent cette fois les poids appris par ImageNet respectivement. Cette fois, vous pouvez facilement l'exécuter avec la fonction de Keras, mais si vous définissez vous-même le problème et obtenez le poids, vous devez faire attention au réseau et à l'ensemble de données.

Head (Top) C'est la partie près de la sortie du réseau neuronal. Vous pouvez modifier la sortie en définissant include_top = False lors du chargement d'un backbone existant. Il est possible de changer en fonction du but, comme augmenter le nombre de couches et concevoir pour améliorer la précision, ou changer le nombre de classes de classification (je pense que le nombre de classes peut être changé avec l'argument ...). Cette fois, la partie Head a été construite comme suit.

top_model.add(Flatten(input_shape=base_model.output_shape[1:]))
top_model.add(Dropout(0.5))
top_model.add(Dense(nb_classes, activation='softmax'))
# Concatenate base_model(backbone) with top model
model = Model(input=base_model.input, output=top_model(base_model.output))

Grad-CAM Le papier Grad-CAM est ci-dessous. Veuillez lire pour plus de détails. Ramprasaath R. Selvaraju · Michael Cogswell · Abhishek Das · Ramakrishna Vedantam · Devi Parikh · Dhruv Batra, Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization, arXiv:1610.02391v4 [cs.CV] 3 Dec 2019 (https://arxiv.org/abs/1610.02391) Cet article est appelé ci-dessous le papier Grad-CAM. Certains des résumés de l'article Grad-CAM sont:

We propose a technique for producing ‘visual explanations’ for decisions from a large class of Convolutional Neural Network (CNN)-based models, making them more transparent and explainable. Our approach–Gradient-weighted Class Activation Mapping (Grad-CAM), uses the gradients of any target concept (say ‘dog’ in a classification network or a sequence of words in captioning network) flowing into the final convolutional layer to produce a coarse localization map highlighting the important regions in the image for predicting the concept.

→ La méthode proposée explique visuellement les décisions prises à partir d'une grande classe de modèles basés sur CNN, améliorant la transparence et l'interprétabilité du modèle. Grad-CAM utilise un gradient du concept d'intérêt (comme une étiquette en forme de chien), qui entre dans la couche finale pour générer une carte des caractéristiques approximative et met en évidence les positions importantes sur l'image lors des prédictions. ..

Figure 6. Grad-Fig dans le papier CAM.2 images

Le résultat de la "mise en évidence des positions importantes sur l'image lors de la prédiction" est la carte des couleurs (a sur la figure 6) étiquetée Grad-CAM dans l'image ci-dessus. Cette fois, nous allons générer cette carte de couleurs et vérifier où dans l'image d'entrée nous nous sommes concentrés lors de la prédiction de la classe.

** Résumé du flux de traitement de Grad-CAM ** (je suis désolé si j'ai fait une erreur). ** 1. Entrée et prédiction vers CNN **: Dans l'architecture d'apprentissage en profondeur, une carte de caractéristiques est sortie lorsque l'image d'entrée passe par le CNN, et sur cette base, un tableau de probabilités de la classe à laquelle l'entrée correspond. Est affiché comme (b sur la figure 6.).

    plobs_pred = model.predict(input_tests)
    cls_idx = np.argmax(model.predict(x))
    cls_output = model.output[:, cls_idx]
    conv_output = model.get_layer(layer_name).output 

** 2. Calcul du gradient $ \ frac {\ partial y ^ {c}} {\ partial A_ {ij} ^ {k}} $ **: rétropropagation avec 1 pour la classe cible et 0 pour les autres Je le ferai. Puisqu'il suffit de prendre le dégradé avec la couche finale, calculez comme suit. Dans ce cas, la variable nom_couche est activation_49 pour ResNet50 et conv_pw_13_relu pour Mobilenet. $ A_ {i j} ^ {k} $ dans l'article Grad-CAM a été trouvé par la fmap_activation suivante. $ \ frac {\ partial y ^ {c}} {\ partial A_ {ij} ^ {k}} $ est le score $ y ^ {c} de la classe $ c $ pour $ A_ {ij} ^ {k} $ C'est un gradient de $, et fmap_activation n'est pas utilisé pour calculer le gradient. Je pense que c'est une question de sens.

    grads = keras.backend.gradients(cls_output, conv_output)[0]  
    gradient_function = keras.backend.function([model.input], [conv_output, grads]) 
    fmap_activation, grads_val = gradient_function([x])
    fmap_activation, grads_val = output[0], grads_val[0]

** Attention ** L'entrée x ci-dessus doit être prétraitée avec img_to_array etc.

** 3. Calcul du poids $ \ alpha_ {k} ^ {c} $ **: Prenez la moyenne des dégradés pour chaque canal et utilisez-la comme poids. Il s'agit du traitement de la partie correspondant à l'équation (1) du papier Grad-CAM suivant. Avant Grad-CAM, la cartographie d'activation de classe (CAM) nécessitait l'ajout d'une couche de mise en commun moyenne globale (GAP) (CAM est calculée comme le produit de la carte d'entités et du poids de la couche finale, et la carte d'entités est pondérée par GAP. Avoir). Cependant, avec Grad-CAM, la pièce GAP peut être remplacée par un calcul de gradient de rétropropagation, et la visualisation est possible sans modifier le modèle.

    alpha = np.mean(grads_val, axis=(0, 1))

** 4. Carte locale d'identification de classe (Grad-CAM) $ L_ {\ text {Grad} - \ mathrm {C} A \ mathrm {M}} ^ {c} $ Calcul **: Grad-CAM Le calcul de l'équation (2) est effectué comme suit. La partie sigma est calculée par le produit interne de numpy, et ReLU a zéro négatif comme le montre la figure 7. Par conséquent, nous pouvons voir que le maximum de numpy doit être utilisé.

Figure 7.Graphique ReLU

    l_gradcam = np.dot(fmap_activation, alpha)#Partie Sigma
    l_gradcam = cv2.resize(l_gradcam, (img_h, img_w), cv2.INTER_LINEAR) 
    l_gradcam = np.maximum(l_gradcam, 0) #Equivalent au calcul ReLU
    l_gradcam = l_gradcam / l_gradcam.max()

Le reste est complété par la conversion JET en utilisant cv2.applyColorMap etc. pour créer une carte de couleurs.

Abandonner

Une technique appelée abandon est appliquée pour empêcher le réseau de surentraînement (un phénomène dans lequel les données de validation sont inexactes en raison d'un surajustement aux données de formation uniquement). Répétez l'apprentissage en désactivant certains nœuds du réseau pour améliorer les performances de généralisation.

Fonction de perte

Je l'ai brièvement expliqué la dernière fois (classification des vins par Keras), je vais donc l'omettre. Puisque ce temps est également une classification multi-classes, ** category_crossentropy ** est utilisé. Classification des vins par Keras: https://qiita.com/moriitkys/items/2ac240437a31131108c7

Fonction d'optimisation

Je l'ai brièvement expliqué la dernière fois (classification des vins par Keras), je vais donc l'omettre. À la suite de divers essais cette fois, ** SGD ** a été le meilleur à apprendre, je vais donc l'adopter.

La fonction de perte et la fonction d'optimisation ci-dessus se trouvent dans la partie qui compile le modèle dans la cellule 2 du code téléchargé sur github.

model.compile(
    optimizer = SGD(lr=0.001),
    loss = 'categorical_crossentropy',
    metrics = ["accuracy"]
)

Tkinter Puisqu'il s'agit d'une bibliothèque standard (boîte à outils de widgets) pour la construction et l'exploitation de l'interface graphique à partir de Python, c'est une bibliothèque qui peut être utilisée si Python est installé sans rien faire. La fenêtre GUI qui fonctionne avec le notebook posté sur github cette fois ressemble à ce qui suit.

Le programme est ci-dessous. Je pense que cela fonctionnera même si vous le copiez et collez tel quel. Il existe trois types de boutons, et la fonction click_flag_train devient rouge lorsqu'elle est enfoncée et la valeur de l'indicateur change. Au départ, en mode Inférence, appuyez sur pour le mode Train, appuyez sur pour le mode Inference, et ainsi de suite. L'étiquette changera également. Un bouton radio est également installé et vous pouvez sélectionner le backbone à utiliser avec tkinter.Radiobutton. Enfin, appuyez sur le bouton Démarrer en bas pour fermer la fenêtre et passez au programme en dessous.

Figure 8.État de fonctionnement de Tkinter

import os
import numpy as np

flag_train = False
type_backbone = "ResNet50"
layer_name_gradcam = "activation_49"

# --- Setting buttons ---
import tkinter
tki = tkinter.Tk()
tki.geometry('300x400')
tki.title('Settings')

radio_value_aug = tkinter.IntVar() 
radio_value_split = tkinter.IntVar() 
radio_value = tkinter.IntVar() 

label = tkinter.Label(tki, text='Mode: Inference')
label.place(x=50, y=60)

def callback(event):
    if event.widget["bg"] == "SystemButtonFace":
        event.widget["bg"] = "red"
    else:
        event.widget["bg"] = "SystemButtonFace"
def click_flag_train():
    global flag_train
    if flag_train == True:
        label['text'] = 'Mode: Inference'
        flag_train = False
    else:
        label['text'] = 'Mode: Train'
        flag_train = True
def click_start():
    tki.destroy()
    
# Create buttons
btn_flag_train = tkinter.Button(tki, text='Train', command = click_flag_train)
btn_start = tkinter.Button(tki, text='Start', command = click_start)
label1 = tkinter.Label(tki,text="1. Select Train or Inference")
label1.place(x=50, y=30)
btn_flag_train.place(x=50, y=100)

label2 = tkinter.Label(tki,text="2. Select ResNet50 or Mobilenet")
label2.place(x=50, y=150)
rdio_one = tkinter.Radiobutton(tki, text='ResNet',
                             variable=radio_value, value=1) 
rdio_two = tkinter.Radiobutton(tki, text='Mobilenet',
                             variable=radio_value, value=2) 
rdio_one.place(x=50, y=180)
rdio_two.place(x=150, y=180)

label3 = tkinter.Label(tki,text="3. Start")
label3.place(x=50, y=250)
btn_start.place(x=50, y=280)

# Display the button window
btn_flag_train.bind("<1>",callback)
btn_start.bind("<1>",callback)
tki.mainloop()

if radio_value.get() == 1:
    type_backbone = "ResNet50"
    layer_name_gradcam = "activation_49"
elif radio_value.get() == 2 :
    type_backbone = "Mobilenet"
    layer_name_gradcam = "conv_pw_13_relu"

print(flag_train)
print(type_backbone)

Ce n'est pas le sujet principal de cette époque, mais Tkinter est devenu long.

** Fin du glossaire **

ResNet50 VS Mobilenet V1

En gros, la différence entre les deux est que ResNet est lourd et très précis, et Mobilenet est léger et légèrement imprécis. Voici une comparaison détaillée.

ResNet --Réseau qui a remporté l'ILSVRC en 2015 --Modèle structure 176 couches de Deep CNN comme le montre la figure 9-a. --Utiliser la structure résiduelle (Figure 9-b.) --Nombre de paramètres dans ce programme 23548935 (Figure 10-a.) --126 s par époque (Figure 10-b.)

• Référence Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun, Deep Residual Learning for Image Recognition, arXiv: 1512.03385 [cs.CV] 10 décembre 2015, (https://arxiv.org/abs/1512.03385)

Figure 9-a.Structure du modèle ResNet	Figure 9-b.Structure résiduelle

Figure 10-a.Nombre de paramètres ResNet	Figure 10-b.Apprentissage ResNet

La structure résiduelle a une structure dans laquelle la fonction d'identité est ajoutée à la sortie telle quelle, comme le montre la figure 9-b., Et le gradient est moins susceptible de disparaître lorsque la couche est approfondie. Par conséquent, ResNet a acquis une expressivité plus complexe.

Mobilenet V1 --Google a publié un article en 2015 --Modèle structure 97 couches de Deep CNN comme le montre la figure 11-a. --Utilisez la convolution séparable en profondeur (Figure 11-b.) --Nombre de paramètres d'apprentissage dans ce programme 3465031 (Figure 12-a.) --65 s par époque (Figure 12-b.) --Référence Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, Hartwig Adam, MobileNets: Réseaux de neurones convolutifs efficaces pour les applications de vision mobile, arXiv: 1704.04861 [cs.CV] 17 avril 2017 , (https://arxiv.org/abs/1704.04861)

Figure 11-a.Structure Mobilenet V1	Figure 11-b. Depthwise Separable Convolution

Figure 12-a.Nombre de paramètres de Mobilenet V1	Figure 12-b.Apprentissage Mobilenet V1

Comme le montre la figure 11-b., La structure de la convolution séparable en profondeur exécute le processus de convolution en deux étapes: convolution dans la direction spatiale (verticale et horizontale) puis convolution dans la direction du canal. Normalement, vous faites tout cela en même temps. Le principe de la réduction du poids en deux étapes est expliqué en détail dans l'article en lisant le papier ou dans l'article Qiita écrit par une autre personne, donc je l'omettrai cette fois (peut-être que je l'écrirai dans le futur).

Paramètres d'apprentissage

・ Il existe 7 types de classes: catégories = ["Makino", "Okuma", "OKK", "Toshiba", "JTEKT", "Tsugami", "Mitsubishi"] -Le nombre d'ensembles de données est indiqué dans le tableau 1 ci-dessous. L'expansion effectue un changement de luminosité, un bruit de poivre, une coupure et une transformation. ・ Train de division du jeu de données: validation = 6: 4 -La taille verticale et horizontale de l'image est de 197x197 pour ResNet50 et 192x192 pour Mobilenet. ・ L'abandon, la fonction de perte, la fonction d'optimisation ont déjà été expliquées. ・ Toutes les couches sont des cibles d'apprentissage -Exécuter batch_size = 32, 30 époques de formation sur ResNet50 ou Mobilenet V1 respectivement

Tableau 1. Répartition de l'ensemble de données

résultat

Perte et précision

Je pense que l'apprentissage a convergé à partir de la transition de la perte et de la précision. (Bien qu'il soit dérangeant que la note soit de 1,0) Premièrement, la transition de la perte et de la précision lors de l'apprentissage avec ResNet 50 est de 30 époques est la suivante. Plus la perte est petite et plus la précision est grande, meilleur est l'apprentissage. Le bleu est l'exactitude des données de train et l'orange est l'exactitude des données de valodation. Vous pouvez également voir l'effet de l'abandon (moins précis dans les données du train).

Figure 13-a.Perte pour chaque époque dans ResNet 50	Figure 13-b.Précision pour chaque époque de ResNet 50

Ensuite, la transition de la perte et de la précision lors de l'apprentissage de 30 époques avec Mobilenet V1 est la suivante. Le bleu est l'exactitude des données de train et l'orange est l'exactitude des données de valodation.

Figure 14-a.Perte pour chaque époque sur Mobilenet	Figure 14-b.Précision pour chaque époque de Mobilenet

Deviner les résultats à l'aide d'images de test inconnues

En utilisant ce poids entraîné de 30 époques, 28 images inconnues qui ne sont pas utilisées pour l'entraînement ou l'évaluation sont collectées et estimées, et les résultats sont résumés dans le tableau 2 ci-dessous.

Tableau 2. Résultats estimatifs pour chaque image de test de chaque modèle

À partir de là, ResNet était environ 10% plus précis.

Visualisation avec Grad-CAM

De plus, Grad-CAM visualise la zone d'intérêt, mais il semble que nous prêtions attention à la partie légèrement en forme de logo (en particulier ResNet).

Figure 15-1.Devinez les résultats et la visualisation de l'image de test de Makino https://www.youtube.com/watch?v=mMgyLnV7l6M

Figure 15-2.Estimation des résultats et visualisation de l'image de test d'Okuma https://www.youtube.com/watch?v=f_qI1sxj9fU

Figure 15-3.Deviner les résultats et visualiser l'image de test de Tsugami https://www.youtube.com/watch?v=rSTW2hEfSns

Ce n'est peut-être pas le cas ...

Figure 15-4.Résultats et visualisation de l'estimation des images de test JTEKT://www.youtube.com/watch?v=SVtN08ASIrI

De nombreuses visualisations ont donné l'impression que ResNet était fortement axé sur les logos, les couleurs et les formes distinctives (bords, etc.), mais Mobilenet était généralement flou et ne pouvait pas saisir pleinement les caractéristiques. Cela ressemble aussi à.

Il semble que le gars d'OKK se distingue par sa couleur.

Figure 15-5.Résultat de l'estimation et visualisation de l'image de test OKK https://www.youtube.com/watch?v=Xfk3wXWleUs&t=21s

À propos de "Introduction au début"

• La forme du robot dans l'image était similaire à l'image de Vacuum utilisée pour ImageNet (le site décrit dans la partie «À propos» ci-dessus). --Dans ImageNet, il y a peu de données que les humains tournent de côté (?) (Non confirmé)
• Dans ImageNet, il y a peu de données sur les humains avec des masques (?) (Non confirmé)

Cependant, je crains que Person ne figure dans le top 10. Puis, quand j'ai deviné l'image d'un être humain face à l'avant, il y avait beaucoup de suppositions sur des vêtements tels que des chemises, des cravates et des costumes. À partir de là, je pense que le port d'un masque réduira la précision des devinettes humaines avec ImageNet.

Impressions

Le site de Makino Milling était le meilleur moyen de collecter des ensembles de données. En effet, certains produits sont pris sous des angles différents et de nombreuses images se ressemblent. OKK a également une couleur distinctive à l'exception de certains, donc il peut être apprécié pour NN. «Puisqu'il s'agit d'un apprentissage par transfert, s'il s'agit d'une image similaire, je pourrais apprendre dans une certaine mesure même s'il est inférieur à 100, mais cet exemple est trop spécial et peut ne pas être très utile. En particulier, la transition entre la perte et la précision est si belle que je ne pense pas que l'ensemble de données et le réglage des paramètres soient appropriés. «Ce que je réalise le plus, c'est que ** les ensembles de données sont très importants **, mais compte tenu des résultats et de la précision de cette visualisation, il s'avère que le réseau a également une certaine influence. J'ai fait. ――Pour la visualisation, j'espérais découvrir des fonctionnalités qui ne sont pas immédiatement perceptibles, plutôt que des fonctionnalités telles que les logos et les couleurs, mais je ne les ai pas encore toutes vues. Même si je peux le faire, je ne pense pas qu'il soit bon de publier beaucoup d'images ici ... ――Dans cette vérification, la définition du problème lui-même n'est pas pratique, mais je pense que c'est devenu un cahier facile à utiliser si vous voulez voir les résultats d'apprentissage rapidement. ――Les articles et les programmes ont quelques parties approximatives, mais vous devez les séparer. Si vous avez des corrections ou des commentaires, veuillez nous contacter.

référence

https://www.ling.upenn.edu/courses/cogs501/Rosenblatt1958.pdf https://keras.io/ja/models/sequential/ https://keras.io/ja/applications/ https://www.bigdata-navi.com/aidrops/2611/ https://qiita.com/simonritchie/items/f6d6196b1b0c41ca163c https://qiita.com/kinziro/items/69f996065b4a658c42e8 http://www.image-net.org/ https://cocodataset.org/#home http://host.robots.ox.ac.uk/pascal/VOC/ https://arxiv.org/pdf/1409.1556.pdf https://pjreddie.com/darknet/yolo/ https://github.com/tensorflow/models/tree/master/research/deeplab https://arxiv.org/abs/1703.06870

https://docs.python.org/ja/3/library/tkinter.html https://qiita.com/simonritchie/items/da54ff0879ad8155f441

https://www.makino.co.jp/ja-jp/ https://www.okuma.co.jp/mold-industry/index.html https://www.okk.co.jp/product/index.html https://www.shibaura-machine.co.jp/jp/product/machinetool/ https://www.jtekt.co.jp/ https://www.tsugami.co.jp/ https://www.mhi-machinetool.com/

https://qiita.com/moriitkys/private/2ac240437a31131108c7