_ 2ème jour jusqu'à ce qu'une bonne précision soit obtenue par la classification des feuilles

Je fais un tutoriel sur tensorflow, et je commence enfin à le comprendre, donc cette fois je vais utiliser tensorflow pour la classification des feuilles.

À propos, les ** 192 quantités de caractéristiques que j'ai comprises dans le précédent article en anglais ne sont pas utilisées, mais sont traitées comme un problème de classification de 99 classes pour 990 images **.

J'ai utilisé ** OpenCV ** pour le prétraitement.

Prétraitement d'image

Première lecture

Lis.py

import cv2
import matplotlib.pyplot as plt

images = []
for i in range(1,1585):
    image = cv2.imread("images/%d.jpg "%i)
    grayed = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    images.append(grayed)

Tout d'abord, lisez chaque image à partir du dossier "image" dans le même dossier en la mettant en niveaux de gris, et enregistrez-la dans la liste appelée images.

Ensuite, essayons le prétraitement de l'article précédent. Le premier en images est à l'origine presque carré, nous allons donc ici regarder les images [1]. Soit dit en passant, les images [1] c'est ça.

Vous pouvez voir qu'il a une forme allongée sur le côté.

Le premier. C'est une méthode pour reconsidérer le rapport à (100,100) sans trop réfléchir.

Prétraitement 1.py

plt.imshow(cv2.resize(images[1], (100, 100)), "gray")
plt.show()

Après tout, ** la fonction d'élancement a disparu **, donc cela ne semble pas être bon.

Puis le second. Faites enfin un carré en gardant le ratio.

Prétraitement 2.py

end_size = 100 #Taille finale verticale et horizontale
max_ = np.maximum(images[1].shape[0], images[1].shape[1]) #Maximisez le plus grand dans les directions verticale et horizontale_Affectez à la variable.
scale = end_size / max_
height, width = images[1].shape
size = (int(width*scale), int(height*scale)) #Réglez le plus grand sur 100 tout en conservant l'échelle.

rescale_image = cv2.resize(images[1], size, interpolation=cv2.INTER_CUBIC) #Redimensionner.

height, width = rescale_image.shape #Puis réessayez.

#Si la largeur est plus grande,[(Largeur hauteur)/2,largeur]C'est un processus pour créer une matrice 0 et l'ajouter de haut en bas.
#Cela gardera l'image au milieu.
if width > height:
    z_pad = np.zeros([int((width-height)/2), width], dtype=np.uint8)
    end_image = np.vstack((z_pad, rescale_image, z_pad))
else:
    z_pad = np.zeros([height, int((height - width)/2)], dtype=np.uint8)
    end_image = np.hstack((z_pad, rescale_image, z_pad))

#Si la valeur largeur-hauteur est impaire, elle sera de 99, elle est donc redimensionnée à 100.
end_image = cv2.resize(end_image, (100, 100))
    
print(end_image.shape)
plt.imshow(end_image, "gray")

Apparemment, cela a réussi.

Au fait, avec quelques changements

Prétraitement 2_2.py

if width > height:
    z_pad = np.zeros([width-height, width], dtype=np.uint8)
    attempt_image = np.vstack((z_pad, rescale_image))
    M = np.float32([[1,0,0],[0,1,-(width-height)/2]])
    end_image = cv2.warpAffine(attempt_image, M,(end_size,end_size))
else:
    z_pad = np.zeros([height, height - width], dtype=np.uint8)
    attempt_image = np.hstack((z_pad, rescale_image))
    M = np.float32([[1,0,-(height-width)/2],[0,1,0]])
    end_image = cv2.warpAffine(attempt_image, M,(end_size,end_size))

Vous pouvez également obtenir la même image en faisant. Ici d'abord

Après avoir créé une telle image (tentative_image), elle est tirée vers le centre en se déplaçant en parallèle.

Appliquez-le à tous et le prétraitement est terminé.

Une autre méthode consiste à créer un tableau numpy 100x100 rempli de 0, puis à placer une image avec une échelle changée en 100 $ x K (k ≤ 100) $.

La version d'implémentation sera probablement encore longue, je vais donc la diviser une fois.