1. Antecedentes de la selección de temas
El rugby se originó en el fútbol, los dos son similares pero también diferentes. Con el desarrollo de la tecnología informática, la tecnología de la IA también ha progresado mucho. A través del entrenamiento continuo del aprendizaje automático, la capacidad de la IA para reconocer el fútbol y el rugby puede ayudar a las personas a distinguir entre el fútbol y el rugby. El aprendizaje automático es un tipo de tecnología inteligente. La clasificación y el reconocimiento del fútbol y el rugby pueden ayudarnos a comprender las características diferentes del fútbol y el rugby, y utilizar la tecnología de aprendizaje automático para analizar estas diferencias, mejorando así la capacidad de la computadora para reconocer el fútbol y el rugby.
2. Esquema de diseño de casos de aprendizaje automático
Descargue conjuntos de datos relevantes del sitio web, organice los conjuntos de datos, etiquete los archivos en el conjunto de datos, procese previamente los datos en el entorno de python, use keras para construir la red, entrene el modelo y use los datos generados durante el proceso de entrenamiento Guardar como un archivo h5, vea la pérdida y precisión del conjunto de verificación, dibuje la curva de pérdida y la curva de precisión durante el proceso de entrenamiento, lea una muestra del conjunto de prueba, construya un modelo, ingrese la imagen original y emita los primeros 8 capas del modelo original El mapa de funciones de la salida de activación muestra el mapa de funciones del primer filtro de la función de salida de activación de la primera capa, lee la muestra de imagen, la redimensiona e importa la imagen para probar el modelo.
Introducción al conjunto de datos: puede haber diferentes aspectos en la imagen que ayuden a identificarlo como una pelota de fútbol y una pelota de fútbol, tal vez la forma de la pelota o la vestimenta de los jugadores. Como estoy trabajando en un problema de clasificación de imágenes, dividí la estructura de datos en: la carpeta de entrenamiento tiene 2448 imágenes, las categorías de fútbol y rugby tienen 1224 imágenes, la carpeta de validación tiene 610 imágenes, las categorías de fútbol y rugby tienen 350 imágenes, la carpeta de prueba tiene 20 imágenes.
La estructura de datos es la siguiente:
Entrada – 3078
----- Entrenamiento – 2448
------------ Fútbol -- 1224
------------ Rugby -- 1224
----- Verificación – 610
------------ Fútbol – 305
------------ Rugby – 305
----- Pruebas – 20
Fuente del conjunto de datos: plataforma Jishi https://www.cvmart.net/dataSets
3. Pasos de implementación del aprendizaje automático
1. Descarga el conjunto de datos
2. Verifique cuántas imágenes se incluyen en cada división (entrenamiento/validación/prueba)
#Consulta para ver cuántas imágenes se incluyen en cada grupo (entrenamiento/validación/prueba)
import os
train_path="C:/soccer and rugby/train/"
print('Número de imágenes de entrenamiento para fútbol:', len (os. listdir(train_path+"soccer")))
print('Número de imágenes del set de entrenamiento de fútbol:', len(os.listdir(train_path+"rugby")))
print('---------- --- ----------------------')
valid_path="C:/fútbol y rugby/validación/"
print('Número de imágenes del conjunto de validación de fútbol: ', len (os.listdir(ruta_válida+"fútbol")))
print('Número de imágenes de validación para fútbol:', len(os.listdir(ruta_válida+"rugby")))
print('------- --- -------------------------')
test_path="C:/soccer and rugby/test/"
print('Número de imágenes en el conjunto de prueba :', len(os.listdir(ruta_prueba)))
3. Crear una pequeña red neuronal convolucional para la clasificación de fútbol y rugby
#Crear una instancia de la pequeña red neuronal convolucional para la clasificación de fútbol y rugby de keras importar capas de keras importar modelos # Usar Sequential model = models.Sequential() # La primera combinación Conv2D + MaxPooling2D model.add(layers.Conv2D(32 , ( 3, 3), activación='relu',input_shape=(150, 150, 3))) model.add(layers.MaxPooling2D((2, 2))) # La segunda combinación de Conv2D + MaxPooling2D model.add (layers. Conv2D(64, (3, 3), activación="relu")) model.add(layers.MaxPooling2D((2, 2))) # La tercera combinación de Conv2D + MaxPooling2D model.add(layers.Conv2D (128, ( 3, 3), activación="relu")) model.add(layers.MaxPooling2D((2, 2))) # La cuarta combinación de Conv2D + MaxPooling2D model.add(layers.Conv2D(128, ( 3, 3), activación="relu")) model.add(layers.MaxPooling2D((2, 2))) # Multidimensional a unidimensional: 7*7*128=6272 model.add(layers.Flatten()) # Número de parámetros: 6272*512+ 512=3211776 modelo.añadir(capas.Densa(512, activación='relu')) # Número de parámetros: 512*1+1=513 modelo.añadir(capas.Densa(1, activación='sigmoide'))
4. Vea cómo cambia la dimensión del mapa de características con cada capa
#Mira cómo cambia la dimensión del mapa de características con cada capa model.summary()
5. Compila el modelo
# Compile el
optimizador del modelo # RMSprop. Debido a que la última capa de la red es una sola unidad sigmoidea,
# Entonces use la entropía cruzada binaria como la función de pérdida
de keras import Optimizers
model.compile(loss='binary_crossentropy',
Optimizer=optimizers.RMSprop(lr=1e-4),
métricas=[ 'acc'])
6. La imagen se procesa antes de ingresar a la red neuronal y se establecen los datos de entrenamiento y verificación.
#La imagen se procesa antes de ingresar a la red neuronal, y los datos de entrenamiento y verificación se establecen
a partir de keras.preprocessing.image import ImageDataGenerator
#Normalización
train_datagen = ImageDataGenerator(rescale = 1./255)
test_datagen = ImageDataGenerator(rescale = 1./255 )
#Apunta a la ruta del directorio de imágenes del conjunto de entrenamiento
train_dir = 'C:/soccer and rugby/train'
# Ingresa el tamaño de la imagen de entrenamiento
train_generator = train_datagen.flow_from_directory(
train_dir,
target_size = (150,150),
batch_size = 20,
class_mode = 'binary')
#Apunte a la ruta del directorio de la imagen del conjunto de validación
validation_dir = 'C:/fútbol y rugby/validación'
validation_generator = test_datagen.flow_from_directory(
validation_dir,
target_size = (150,150),
batch_size = 20,
class_mode = 'binary')
#El generador no se detendrá, generará estos lotes cíclicamente, por lo que generaremos lotes una vez
para data_batch,labels_batch en train_generator:
print('Lote de datos de imagen:',data_batch. forma)
print('Lote de etiquetas binarias:', lote_etiquetas.forma)
break
7. Entrena al modelo durante 30 rondas.
#training model 30 rounds
history = model.fit(
train_generator,
steps_per_epoch = 100,
#training 30 veces
épocas = 30,
validacion_datos = validacion_generador,
validacion_pasos = 50
8. Guarda los datos generados durante el proceso de entrenamiento como un archivo h5
#Guarda los datos generados durante el proceso de entrenamiento como un archivo h5
de keras.models import load_model
model.save('C:/soccer and rugby/soccer and rugby_30epoch.h5')
#Cómo abrir el archivo .h5
de keras.models importar load_model
desde keras importar capas
desde keras importar modelos
model=load_model('C:/soccer and rugby/soccer and rugby_30epoch.h5')
9. Ver la pérdida y la precisión del conjunto de validación
#Ver la pérdida y la precisión del conjunto de validación
validation_loss, validation_accuracy = model.evaluate(validation_generator)
print(f"Validation Loss: {validation_loss:.4f}")
print(f"Validation Accuracy: {validation_accuracy:.4f}")
10. Dibuje la curva de pérdida y la curva de precisión durante el entrenamiento
#Dibuje la curva de pérdida y la curva de precisión durante el entrenamiento
import matplotlib.pyplot as plt
acc = history.history['acc']
loss =history.history['loss']
epochs = range(1,len(acc) + 1)
plt .plot(epochs,acc,'bo',label='Entrenamiento acc')
plt.plot(epochs,loss,'b',label='loss')
plt.title('Precisión de entrenamiento y validación')
plt. legend ()
#Dibuje la curva de pérdidas durante el entrenamiento
import matplotlib.pyplot as plt
loss =history.history['loss']
epochs = range(1,len(acc) + 1)
plt.plot(epochs,loss,'b ', label='loss')
plt.title('loss')
plt.legend()
#Dibuje la curva de precisión durante el entrenamiento
import matplotlib.pyplot as plt
acc = history.history['acc']
épocas = range(1,len(acc) + 1)
plt.plot(epochs,acc,'bo',label='Entrenamiento acc')
plt.title('precisión')
plt.leyenda()
11. Lea una muestra del conjunto de prueba y muéstrela
#Leer una muestra del conjunto de prueba img_path = "C:/soccer and rugby/train/soccer/soccer.1125.jpg" importar keras.utils como imagen importar numpy como np img = image.load_img(img_path, target_size=(150,150 )) img_tensor = image.img_to_array(img) img_tensor = np.expand_dims(img_tensor, axis=0) img_tensor /= 255 print(img_tensor.shape) #display sample import matplotlib.pyplot as plt plt.imshow(img_tensor[0]) plt.mostrar()
12. Establezca un modelo, la entrada es la imagen original y la salida es el mapa de características de la salida de activación de las primeras 8 capas del modelo original
#Cree un modelo, la entrada es la imagen original y la salida es el mapa de características de la salida de activación de las primeras 8 capas del modelo original de keras import models layer_outputs = [layer.output for layer in model.layers[: 8]] modelo_activación = modelos.Modelo( entradas=modelo.entrada, salidas=salidas_capa) #Obtenga el mapa de características de las activaciones de muestra modificadas = modelo_activación.predict(img_tensor)
13. El mapa de características del primer filtro que muestra la salida de activación de la primera capa
#Mostrar el mapa de funciones del primer filtro de la función de salida de activación de la primera capa import matplotlib.pyplot as plt first_layer_activation = activations[0] plt.matshow(first_layer_activation[0,:,:,1], cmap="viridis")
14. Mostrar todos los mapas de características de la salida de activación de las primeras 4 capas
#Mostrar todos los mapas de funciones de las primeras 4 capas de la salida de activación
#El nombre de la capa de almacenamiento
layer_names = []
for layer in model.layers[:4]:
layer_names.append(layer.name)
#Mostrar 16 mapas de funciones por fila
images_pre_row = 16
#Número de mapas de características mostrados en cada línea
# Realice un bucle 8 veces para mostrar todos los mapas de características de 8 capas
para nombre_capa, activación_capa en zip(nombres_capa, activaciones):
n_características = activación_capa.forma[-1]
#Guardar la cantidad de mapas de características de la capa actual
size = layer_activation.shape[1]
#Guardar el ancho y el alto del mapa de características de la capa actual
n_col = n_features // images_pre_row
#Calcular cuántas filas muestra la capa actual #Generar
la matriz que muestra la imagen
display_grid = np.zeros((size*n_col, images_pre_row*size) )
#Recorra y escriba los datos de cada imagen especial en la matriz de la imagen mostrada
for col in range(n_col):
for row in range(images_pre_row):
#Guarde la matriz del mapa de funciones (tamaño, tamaño, 1)
channel_image = layer_activation[0,:,:,col*images_pre_row+row]
#Para que la visualización de la imagen sea más vívida, realice un procesamiento de funciones
channel_image -= channel_image .mean( )
channel_image /= channel_image.std()
channel_image *= 64
channel_image += 128
#Modificar el valor de los elementos en la matriz del mapa de características que no están en 0-255 a 0-255
channel_image = np.clip(channel_image, 0, 255).astype ("uint8")
#La matriz del mapa de características se completa en la matriz de la imagen de visualización
display_grid[col*size:(col+1)*size, row*size:(row+1)*size ] = channel_image
scale = 1./ size
#Establece el ancho y el alto de la imagen que se muestra en esta capa
plt.figure(figsize=(scale*display_grid.shape[1],scale*display_grid.shape[0]))
plt. título (nombre_capa)
plt.grid(Falso)
#mostrar imagen
plt.imshow(display_grid, aspect="auto", cmap="viridis")
15. Lee la imagen de muestra y cambia su tamaño
#Leer muestra de imagen, cambiar su tamaño
# Método 1
importar keras.utils como imagen
importar numpy como np
img_path = "C:/soccer and rugby/test/soccer.2.jpg"
img = image.load_img(img_path, target_size= ( 150,150))
img_tensor = image.img_to_array(img)
#Convertir a una matriz
img_tensor = np.expand_dims(img_tensor, axis=0)
img_tensor /= 255.
print(img_tensor.shape)
print(img_tensor[0][0])
plt .imshow(img_tensor[0])
plt.show()
#Método 2
import matplotlib.pyplot as plt
from PIL import Image
import os.path
#Reduce la imagen al tamaño de (150, 150)
def convertjpg(jpgfile,outdir, ancho = 150, alto = 150):
img = Image.open (archivo jpg)
intente:
new_img=img.resize((ancho,alto),Imagen.BILINEAR)
new_img.save(os.path.join(outdir,os.path.basename(new_file)))
excepto Excepción como e:
print(e)
jpgfile=" C:/soccer and rugby/test/soccer.2.jpg"
new_file="C:/soccer and rugby/soccer.3.jpg"
# Cambia el tamaño de la imagen a (150,150), guarda el nombre del archivo
convertjpg(jpgfile,r "C:/soccer and rugby")
img_scale = plt.imread('C:/soccer and rugby/soccer.3.jpg')
#Muestra que la imagen después de cambiar el tamaño de la imagen ha cambiado a (150,150) tamaño
plt. imshow(img_escala)
16. Importar modelo de prueba de imagen
#importación del modelo soccer y rugby_30epoch.h5
de keras.models import load_model
model = load_model('C:/soccer and rugby/soccer and rugby_30epoch.h5')
#model.summary()
img_scale = plt.imread('C:/soccer y rugby/soccer.3.jpg')
img_scale = img_scale.reshape(1,150,150,3).astype('float32')
img_scale = img_scale/255
#Normalizar entre 0-1
#Obtener información
de la imagen result = model.predict(img_scale)
#print(resultado)
img_scale = plt.imread('C:/fútbol y rugby/soccer.3.jpg')
#display picture
plt.imshow(img_scale)
if result>0.5:
print('La imagen es La probabilidad de fútbol is: ',resultado)
else:
print('La probabilidad de que la imagen sea fútbol:',1-resultado)
17. Lea el archivo de imagen personalizado, guárdelo después de cambiar el tamaño
#Lea el archivo de imagen personalizado, guárdelo después de cambiar el tamaño
import matplotlib.pyplot as plt
from PIL import Image
import os.path
#Reduce la imagen al tamaño de (150, 150)
def convertjpg(jpgfile,outdir,width=150 ,alto =150):
img=Imagen.abrir(archivo jpg)
pruebe:
new_img=img.resize((ancho,alto),Imagen.BILINEAR)
new_img.save(os.path.join(outdir,os.path.basename( jpgfile) ))
excepto Excepción como e:
print(e)
#Lee la imagen original
jpgfile = 'C:/soccer and rugby/sample/rugby.1.jpg'
#Cambia el tamaño de la imagen a (150,150)
convertjpg(jpgfile," C:/ A")
img_scale = plt.imread('C:/A/rugby.1.jpg')
#Mostrar que la imagen después de cambiar el tamaño de la imagen ha cambiado a tamaño (150,150)
plt.imshow(img_scale)
18. Importe el modelo y pruebe las imágenes guardadas arriba
#Importa el modelo soccer y rugby_30epoch.h5
desde keras.models import load_model
model = load_model('C:/soccer and rugby/soccer and rugby_30epoch.h5')
#Normaliza entre 0-1
img_scale = img_scale.reshape(1,150,150 ,3). astype('float32')
img_scale = img_scale/255
#Obtener información de la imagen
result = model.predict(img_scale)
#print(result)
if result>0.5:
print('La probabilidad de que la imagen sea una pelota de fútbol es:', resultado)
else:
print('La probabilidad de que la imagen sea un balón de fútbol es:',1-resultado)
todos los códigos
1 # Comprueba cuántas imágenes se incluyen en cada grupo (entrenamiento/validación/prueba)
2 import os
3 train_path="C:/soccer and rugby/train/"
4 print('Número de imágenes del set de entrenamiento de fútbol:', len(os.listdir(train_path+"soccer")))
5 print('Número de imágenes del set de entrenamiento de fútbol:', len(os.listdir(train_path+"rugby")))
6 print('---- --- ----------------------------')
7 valid_path="C:/fútbol y rugby/validación/"
8 print( 'Número de imágenes de validación para fútbol:', len(os.listdir(ruta_válida+"fútbol")))
9 print('Número de imágenes de validación para fútbol:', len(os.listdir(ruta_válida+"rugby")))
10 print(' ----------------------------------')
11 test_path="C:/fútbol y rugby /prueba/"
12 print('Número de imágenes en el conjunto de prueba:', len(os.listdir(test_path)))
13
14 #Crea una instancia de la pequeña red neuronal convolucional para la clasificación de fútbol y rugby
15 desde las capas de importación de keras
16 from keras import models
17
18 # Use Sequential
19 model = models.Sequential()
20
21 # La primera combinación Conv2D + MaxPooling2D
22 model.add(layers.Conv2D(32, (3, 3), activación='relu' , input_shape=(150, 150, 3)))
23 model.add(layers.MaxPooling2D((2, 2)))
24
25 # La segunda combinación Conv2D + MaxPooling2D
26 model.add(layers.Conv2D(64, ( 3, 3), activación="relu"))
27 model.add(layers.MaxPooling2D((2, 2)))
28
29 # La tercera combinación Conv2D + MaxPooling2D
30 model.add(layers.Conv2D(128, ( 3, 3 ), activación="relu"))
31 model.add(layers.MaxPooling2D((2, 2)))
32
33 # La cuarta combinación Conv2D + MaxPooling2D
34 modelo.añadir(capas.Conv2D(128, (3, 3), activación="relu"))
35 modelo.añadir(capas.MaxPooling2D((2, 2)))
36
37 # Multidimensional a unidimensional : 7 *7*128=6272
38 modelo.añadir(capas.Flatten())
39
40 # Número de parámetros: 6272*512+512=3211776
41 modelo.añadir(capas.Densa(512, activación='relu') )
42
43 # Número de parámetros: 512*1+1=513
44 modelo.add(capas.Dense(1, activación='sigmoide'))
45
46 #Mira cómo cambia la dimensión del mapa de características con cada capa
47 model.summary()
48
49 # Compila el modelo
50 # Optimizador RMSprop. Debido a que la última capa de la red es una sola unidad sigmoidea,
51 # Entonces use la entropía cruzada binaria como función de pérdida
52 de keras import Optimizers
53
54 model.compile(loss='binary_crossentropy',
55optimizer=optimizers.RMSprop(lr=1e-4),
56 metrics=['acc'])
57
58 #La imagen se procesa antes de ingresar a la red neuronal, y los datos de entrenamiento y verificación se establecen
59 desde keras.preprocessing. image import ImageDataGenerator
60
61 #Normalización
62 train_datagen = ImageDataGenerator(rescale = 1./255)
63 test_datagen = ImageDataGenerator(rescale = 1./255)
64
65 #Apunta a la ruta del directorio de imágenes del conjunto de entrenamiento
66 train_dir = 'C:/soccer and rugby/ train'
67
68 # Tamaño de imagen de entrenamiento de entrada
69 train_generator = train_datagen.flow_from_directory(
70 train_dir,
71 target_size = (150,150),
72 batch_size = 20,
73 class_mode = 'binary')
74
75 #Apunta a la ruta del directorio de imágenes del conjunto de validación
76 validation_dir = 'C:/fútbol y rugby/validación'
77
78 validation_generator = test_datagen.flow_from_directory(
79 validation_dir,
80 target_size = (150,150),
81 batch_size = 20,
82 class_mode = ' binary' )
83
84 #El generador no se detendrá, generará estos lotes cíclicamente, por lo que generaremos un lote
85 para data_batch,labels_batch en train_generator:
86 print('Lote de datos de imagen:',data_batch.shape)
87 print ('Lotes de etiquetas binarias:', etiquetas_lote.forma)
88 descanso
89
90 #entrenamiento modelo 30 rondas
91 historial = modelo.ajuste(
92 tren_generador,
93 pasos_por_época = 100,
94 #entrenamiento 30 veces
95 épocas = 30,
96 datos_validación = generador_validación,
97 pasos_validación = 50)
98
99 #Guardar los datos generados durante el proceso de entrenamiento como un archivo h5
100 de keras.models import load_model
101 model.save('C:/fútbol y rugby/ soccer y rugby_30epoch.h5')
102
103 #Cómo abrir el archivo .h5
104 desde keras.models importar load_model
105 desde keras importar capas
106 desde keras importar modelos
107
108 model=load_model('C:/soccer and rugby/soccer and rugby_30epoch .h5' )
109
110 #Ver la pérdida y precisión del conjunto de validación
111 validation_loss, validation_accuracy = model.evaluate(validation_generator)
112 print(f"Pérdida de validación: {validation_loss:.4f}")
113 print(f"Validation Accuracy: {validation_accuracy:.4f}")
114
115 #Dibuje la curva de pérdida y la curva de precisión durante el entrenamiento
116 import matplotlib.pyplot como plt
117
118 acc = history.history['acc']
119 loss =history.history['loss']
120
121 epochs = range(1,len(acc) + 1)
122
123 plt.plot(epochs,acc, ' bo',label='Entrenamiento acc')
124 plt.plot(epochs,loss,'b',label='loss')
125 plt.title('Precisión de entrenamiento y validación')
126 plt.legend()
127
128 # Dibujar la curva de pérdidas durante el entrenamiento
129 import matplotlib.pyplot as plt
130
131 loss =history.historia['pérdida']
132 épocas = rango(1,len(acc) + 1)
133 plt.plot(épocas,pérdida,'b',etiqueta='pérdida')
134 plt.title('pérdida')
135 plt.leyenda()
136
137 #Dibuje la curva de precisión durante el entrenamiento
138 import matplotlib.pyplot as plt
139 acc = history.history['acc']
140 epochs = range(1,len(acc) + 1)
141
142 plt.plot(epochs,acc,' bo',label='Entrenamiento acc')
143 plt.title(' precision')
144 plt.legend()
145
146 #Leer una muestra del conjunto de prueba
147 img_path = "C:/soccer and rugby/train/soccer/ soccer.1125.jpg"
148
149 importar keras.utils como imagen
150 importar numpy como np
151
152 img = image.load_img(img_path, target_size=(150,150))
153 img_tensor = image.img_to_array(img)
154 img_tensor = np.expand_dims(img_tensor, axis=0)
155 img_tensor /= 255
156 print(img_tensor.shape)
157
158 #display sample
159 import matplotlib.pyplot as plt
160 plt.imshow (img_tensor[0])
161 plt.show()
162
163 #Construye un modelo, la entrada es la imagen original y la salida es el mapa de características de la salida de activación de las primeras 8 capas del modelo original
164 de keras import modelos
165
166 layer_outputs = [capa.salida para capa en modelo.capas[:8]]
167 modelo_activación = modelos.Modelo(entradas=modelo.entrada, salidas=salidas_capa)
168
169 #Obtener el mapa de características de la muestra modificada
170 activaciones = modelo_activación.predict(img_tensor)
171
172 #display El mapa de características del primer filtro de la salida de activación de la primera capa
173 importar matplotlib.pyplot como plt
174 activación_primera_capa = activaciones[0]
175 plt.matshow(activación_primera_capa[0,:,:,1], cmap="viridis")
176
177 #Mostrar todos los mapas de características de la salida de activación de la primera 4 capas
178 #El nombre de la capa de almacenamiento
179 layer_names = []
180 para capa en model.layers[:4]:
181 layer_names.append(layer.name)
182 # Cada fila muestra 16 mapas de características
183 images_pre_row = 16
184 # Cada fila muestra Número de mapas de características
185 # Ciclo 8 veces para mostrar todos los mapas de características de 8 capas
186 para nombre_capa, activación_capa en zip(nombres_capa, activaciones):
187 n_características = activación_capa.forma[-1]
188 #Guardar el número de características mapas de la capa actual
189 size = layer_activation.shape[1]
190 #Guardar el ancho y alto de la capa actual mapa de características
191 n_col = n_features // images_pre_row
192 #Calcula cuántas filas se muestran en la capa actual
193 #Genera la matriz de la imagen de visualización
194 display_grid = np.zeros((size*n_col, images_pre_row*size))
195 #Recorre y escribe los datos de cada imagen especial para la matriz de la imagen de visualización Medio
196 for col in range(n_col):
197 for row in range(images_pre_row):
198 #Guardar la matriz del mapa de características (tamaño, tamaño,1)
199 channel_image = layer_activation[0,:, :,col*images_pre_row+ row]
200 #Para que la visualización de la imagen sea más vívida, procese algunas características
201 channel_image -= channel_image.mean()
202 channel_image /= channel_image.std()
203 channel_image *= 64
204 channel_image += 128
205 #La matriz del mapa de características Modifica el valor de los elementos que no están en 0-255 a 0-255
206 channel_image = np.clip(channel_image, 0, 255).astype("uint8")
207 #La matriz del mapa de características es relleno en la matriz de la imagen de visualización
208 display_grid[col*size:(col+1)*size, row*size:(row+1)*size] = channel_image
209 scale = 1./size
210 #Establecer el ancho y el alto de la imagen mostrada en esta capa
211 plt.figure (figsize=(scale*display_grid.shape[1],scale*display_grid.shape[0]))
212 plt.title(layer_name)
213 plt.grid(False)
214 #mostrar imagen
215 plt.imshow( display_grid, aspect= "auto", cmap="viridis")
216
217 #Leer muestras de imágenes y cambiar su tamaño
218 #Método 1
219 importar keras.utils como imagen
220 importar numpy como np
221
222 img_path = "C:/fútbol y rugby/test /soccer.2.jpg"
223
224 img = image.load_img(img_path, target_size=(150,150))
225 img_tensor = image.img_to_array(img)
226 #Convert to a array
227 img_tensor = np.expand_dims(img_tensor, axis=0)
228 img_tensor /= 255.
229 print(img_tensor.shape)
230 print(img_tensor[0][0])
231 plt.imshow(img_tensor[0])
232 plt. show()
233
234 #方法2
235 importar matplotlib.pyplot como plt
236 desde PIL importar imagen
237 importar os.path
238
239 #将图片缩小到（150，150）的大小
240 def convertjpg(jpgfile,outdir,width=1 50 ,alto=150):
241 img=Imagen.abrir(archivo jpg)
242 intente:
243 new_img=img.resize((ancho,alto),Imagen.BILINEAR)
244 new_img.save(os.path.join(outdir,os. ruta.nombrebase(nuevo_archivo)))
245 excepto Excepción como e:
246 print(e)
247
248 jpgfile="C:/soccer and rugby/test/soccer.2.jpg"
249 new_file="C:/soccer and rugby/soccer.3.jpg"
250 # Cambia el tamaño de la imagen a (150,150), guarda el nombre de archivo
251 convertjpg(jpgfile,r"C:/soccer and rugby")
252 img_scale = plt.imread('C:/soccer and rugby/soccer.3.jpg')
253
254 #Mostrar que la imagen después de cambiar la imagen de hecho, el tamaño ha cambiado a (150,150) tamaño
255 plt.imshow(img_scale)
256
257 #import model soccer and rugby_30epoch.h5
258
259 from keras.models import load_model
260 model = load_model('C:/soccer and rugby/soccer and rugby_30epoch .h 5')
261 #model.summary()
262 img_scale = plt.imread('C:/fútbol y rugby/soccer.3.jpg')
263 img_scale = img_scale.reshape(1,150,150,3).astype('float32')
264 img_scale = img_scale/255
265 #normalizado entre 0 y 1
266
267 #tomar información de la imagen
268 resultado = model.predict(img_scale)
269
270 #print(resultado)
271 img_scale = plt.imread('C:/ fútbol y rugby /fútbol.3.jpg')
272
273 #Mostrar imagen
274 plt.imshow(img_scale)
275
276 if resultado>0.5:
277 print('La probabilidad de que la imagen sea fútbol es:', resultado)
278 else:
279 print( 'La probabilidad de que la imagen sea un balón de fútbol es:', 1 resultado)
280
281 #Lea el archivo de imagen personalizado, guárdelo después de cambiar el tamaño
282
283 import matplotlib.pyplot as plt
284 from PIL import Image
285 import os.path
286
287 #Reduce la imagen al tamaño de (150, 150)
288 def convertjpg(jpgfile,outdir,width=150,height=150):
289 img=Image.open(archivo jpg)
290 intente:
291 new_img=img.resize((ancho,alto),Imagen.BILINEAR)
292 new_img.save(os.path.join(outdir,os.path.basename(archivo jpg) ))
293 excepto Excepción como e:
294 print(e)
295
296 #Leer la imagen original
297 jpgfile = 'C:/soccer and rugby/sample/rugby.1.jpg'
298 #Cambiar el tamaño de la imagen a (150,150)
299 convertjpg (jpgfile,"C:/A")
300
301 img_scale = plt.imread('C:/A/rugby.1.jpg')
302 #Mostrar que la imagen después de cambiar el tamaño de la imagen ha cambiado a (150,150) tamaño
303 plt. imshow(img_scale)
304
305 #import model soccer and rugby_30epoch.h5
306
307 from keras.models import load_model
308 modelo = load_model('C:/soccer y rugby/soccer y rugby_30epoch.h5')
309
310 #normalizado entre 0-1
311 img_scale = img_scale.reshape(1,150,150,3).astype('float32')
312 img_scale = img_scale/255
313
314 #Obtener información de la imagen
315 result = model.predict(img_scale)
316 #print(result)
317 if result>0.5:
318 print('La probabilidad de que la imagen sea un balón de fútbol es:', resultado)
319 else:
320 print('La probabilidad de que la imagen sea un balón de fútbol es:',1-resultado)
Cuatro Resumen
El contenido principal del diseño de este programa es el aprendizaje automático: identificación del fútbol y el rugby. A través del diseño de este curso, tengo una mejor comprensión del aprendizaje automático, pero en el proceso de escritura y ejecución del código, a menudo encuentro errores, a través de correcciones una y otra vez. , la escritura de código también es más rápida. Personalmente, siento que en el proceso de aprendizaje de Python, la práctica es especialmente importante. Solo a través de la operación personal puedo encontrar las deficiencias en mi proceso de aprendizaje. Esto es muy útil para aprender Python. En este diseño de programa, el modelo de entrenamiento logró el efecto esperado, pero encontré que no tenía muy clara la idea completa del diseño del programa al principio, por lo que dediqué mucho tiempo a corregirlo. A través de este estudio, También aprenderé sobre el diseño del programa. La idea se ha mejorado aún más.