Dans le type ndarray de python, il est devenu nécessaire de convertir (32,32,3) en un tenseur à 4 dimensions (1,32,32,1). Le but est de fournir des données d'apprentissage automatique.
Un tableau de type ndarray tel que (1,32,32,1) est appelé un "tenseur à quatre dimensions". Le contenu de l'image pouvant être lu à partir de ce tenseur à 4 dimensions est (nombre d'images, hauteur d'image, largeur d'image, nombre de canaux d'image). Le nombre de canaux dans l'image signifie RVB en échelle de gris quand 1 et en couleur quand 3. Une image est représentée par un tableau de type ndarray (32,32,3), et on peut juger qu'il ne s'agit pas d'un ensemble de données d'image.
Addendum) Quand je dis à une personne spécialisée en mathématiques qu'il s'agit d'un tenseur à 4 dimensions, il semble être véhiculé dans une image différente, mais j'aime la façon dont il dit: "Vous ne pouvez pas l'utiliser dans Keras à moins d'utiliser un ensemble de données de tenseur à 4 dimensions." Je l'utilise beaucoup (rires)
Je pense qu'il est assez difficile de convertir le type ndarray comme vous le souhaitez. Pour le moment, j'ai confirmé que le type ndarray peut être converti comme suit.
import numpy as np
a = np.arange(6)
a = a.reshape(2, 3)
print(a)
#↓ Résultat de sortie
#[[0 1 2]
# [3 4 5]]
print("===============\n")
a = a.reshape(2,3,1)
print(a)
#↓ Résultat de sortie
#[[[0]
# [1]
# [2]]
#
# [[3]
# [4]
# [5]]]
print("---------------\n")
a = a.reshape(1,2,3,1)
print(a)
#↓ Résultat de sortie
#[[[[0]
# [1]
# [2]]
#
# [[3]
# [4]
# [5]]]]
Vous pouvez maintenant le mettre dans la fonction de prédiction ci-dessous. y_pred = model.predict(x) Si vous n'entrez pas les données de (1, 32, 16, 1) dans le type ndarray pour x, une erreur se produira. Une erreur se produira même avec (32, 16, 1).
from PIL import Image
import numpy as np
# 3 *Où 2 est en fait 32*Veuillez le remplacer par 32 ou quelque chose.
c = np.arange(3 * 2)
c = c.reshape(3, 2)
pilImg = Image.fromarray(np.uint8(c))
# pilImg_1 = pilImg.convert("RGB")
pilImg_1 = pilImg.convert("L")
data = np.array(pilImg_1, dtype='int64')
print(type(data))
print(data)
print(data.shape)
a = data
print("===============\n")
a = a.reshape(3,2,1)
print(a)
print("===============\n")
a = data.reshape(1,3,2,1)
print(a)
C'est un bonus. Il est utilisé lorsque vous souhaitez changer l'image de RVB en échelle de gris. Je ne sais pas quelle est la demande.
from PIL import Image
import numpy as np
file = "neko.png "
image = Image.open(file)
image = image.convert("RGB")
data_rgb = np.array(image, dtype='int64')
#Parce que c'est RVB(height, width, 3)Sera un tableau
print(type(data_rgb))
print("data_rgb ... " + str(data_rgb.shape))
pilImg_rgb = Image.fromarray(np.uint8(data_rgb))
pilImg_gray = pilImg_rgb.convert("L")
data_gray = np.array(pilImg_gray, dtype='int64')
#Parce que c'est une échelle de gris(height, width)Sera un tableau
print(type(data_gray))
print("data_gray ... " + str(data_gray.shape))
#
pilImg_rgb_2 = Image.fromarray(np.uint8(data_gray))
pilImg_rgb_2 = pilImg_rgb_2.convert("RGB")
data_rgb_2 = np.array(pilImg_rgb_2, dtype='int64')
#Je l'ai à nouveau converti en RVB, donc(height, width, 3)Sera un tableau
print(type(data_rgb_2))
print("data_rgb ... " + str(data_rgb_2.shape))
Donc, en faisant (hauteur, largeur) ⇔ (hauteur, largeur, 3), c'était un exemple de faire cela. Ce sera un tableau de (hauteur, largeur) au lieu de (hauteur, largeur, 1).
P.S. C'était mal écrit. Après tout, je pense que le code ci-dessous est suffisant.
from PIL import Image
import numpy as np
file = "neko.png "
image = Image.open(file)
image = image.convert("RGB")
data_rgb = np.array(image, dtype='int64')
#Parce que c'est RVB(height, width, 3)Sera un tableau
print(type(data_rgb))
print("data_rgb ... " + str(data_rgb.shape))
pilImg_rgb = Image.fromarray(np.uint8(data_rgb))
pilImg_gray = pilImg_rgb.convert("L")
data_gray = np.array(pilImg_gray, dtype='int64')
#Parce que c'est une échelle de gris(height, width)Sera un tableau
print(type(data_gray))
print("data_gray ... " + str(data_gray.shape))
#Parce que c'est une échelle de gris(height, width)Sera un tableau
print(type(data_gray))
print("data_gray ... " + str(data_gray.shape))
a = data_gray.reshape(1, image.height, image.width, 1)
print(a.shape)
#Résultat d'exécution
# <class 'numpy.ndarray'>
# data_rgb ... (210, 160, 3)
# <class 'numpy.ndarray'>
# data_gray ... (210, 160)
# (1, 210, 160, 1)
La séquence est (1, 210, 160, 1), donc c'est la même chose que (1, 32, 32, 1). Vous pouvez désormais l'utiliser pour prédire l'apprentissage automatique. Cependant, comme il semble que vous utilisiez généralement une image couleur, la fin est 3 au lieu de 1. Si vous voulez apprendre des lettres, etc., l'échelle de gris convient, je pense donc que vous pouvez utiliser l'exemple de cet article.
Addendum) Maintenant, je vais bien et je travaille.
print("img ... " + str(img.shape))
# img ... (1, 32, 32, 3)
print("img ..." + str(img[0].shape))
# img ... (32, 32, 3)
imwrite(img_path, img)
#↑ Ceci est une erreur
imwrite(img_path, img[0])
#↑ C'est un succès
Recommended Posts