La versión histórica de TensorFlow y la correspondiente versión de Python
Versión TensorFlow	Pitón	tiempo de liberación
tensorflow-2.4.0	3.6-3.8	diciembre 2020
tensorflow-2.3.0	3.5-3.8	julio 2020
tensorflow-2.2.0	3.5-3.8	mayo 2020
tensorflow-2.1.0	3.5-3.7	enero 2020
tensorflow-2.0.0	3.5-3.7	octubre 2019
tensorflow-1.15.0	3.5-3.7	octubre 2019
tensorflow-1.14.0	3.5-3.7	junio 2019
tensorflow-1.13.0	3.5-3.7	febrero 2019
tensorflow-1.12.0	3.5-3.6	noviembre 2018
tensorflow-1.11.0	3.5-3.6	septiembre 2018
tensorflow-1.10.0	3.5-3.6	agosto 2018
tensorflow-1.9.0	3.5-3.6	julio 2018
tensorflow-1.8.0	3.5-3.6	abril 2018
tensorflow-1.7.0	3.5-3.6	marzo 2018
tensorflow-1.6.0	3.5-3.6	marzo 2018
tensorflow-1.5.0	3.5-3.6	enero 2018
tensorflow-1.4.0	3.5-3.6	noviembre 2017
tensorflow-1.3.0	3.5-3.6	agosto 2017
tensorflow-1.2.0	3.5-3.6	junio 2017
tensorflow-1.1.0	3.5	abril 2017
tensorflow-1.0.0	3.5	febrero 2017

(2) Consulta de versión de Python

Los siguientes métodos se pueden utilizar cuando se configura la variable de entorno de python:

win+R o busque cmd en el cuadro de búsqueda para abrir la terminal de Windows e ingrese python --version en la terminal

Si el entorno de python no está configurado, use el terminal de solicitud de anaconda para consultar el número de versión y las operaciones posteriores.

(3) Busque el cuadro de versión de arriba para descargar el TensorFlow correspondiente

En el momento de la instalación, no pensé que el problema de la versión afectaría el uso posterior de TensorFlow, así que elegí una versión al azar. Por supuesto, puede elegir la misma versión si lo desea. El método de seguimiento será ser igual que el mio.

Aquí descargamos el archivo de imagen de TensorFlow de Tsinghua Park, seguido del número de versión

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple tensorflow==1.14

Aviso:

①El comando aquí se ejecuta directamente en la terminal de Windows cuando se ejecuta, siempre que haya un entorno de Python

②Si la descarga encuentra un informe de error en un entorno que no sea, copie la URL después de la descarga, vaya directamente a la URL para descargar el archivo de instalación y luego cambie a la ruta de descarga, el sufijo del archivo descargado con pip insatll es archivo .whl

(4) La instalación es exitosa

Cuando la instalación ocurre de la siguiente manera, la instalación es exitosa

(5) TensorFlow verificado con éxito

Importe la biblioteca TensorFlow para hacer un cálculo simple

import tensorflow as tf
sess = tf.Session()
a = tf.constant(10)
b = tf.constant(12)
sess.run(a+b)

Se obtienen los siguientes resultados para comprobar que la instalación es exitosa

Nota:

Los siguientes errores pueden ocurrir durante la fase de verificación

El primero es el error de jupyter y el segundo es el mensaje de error de anaconda.

Esto se debe a que el nivel de versión de protobuf de algunas máquinas no coincide con TensorFlow. Solo necesita reinstalar de acuerdo con el número de versión de protobuf >= más adelante.

El comando es el siguiente:

pip install protobuf==3.19.0

2. Introducción del proyecto

(1) Descripción del proyecto

La tecnología de reconocimiento de imágenes es una base importante de la visión por computadora de inteligencia artificial. El uso de algoritmos de aprendizaje automático/aprendizaje profundo puede identificar de manera eficiente y precisa las características principales de las imágenes, a fin de clasificar y reconocer imágenes con diferentes contenidos de imágenes.

Hay un conjunto de datos clásico en el campo de la investigación de reconocimiento de imágenes: Cat_vs_Dogs (conjunto de datos de reconocimiento de perros y gatos), muchas investigaciones de algoritmos de visión artificial utilizan este conjunto de datos para verificar su efecto. En el archivo adjunto, se recopilan 1500 fotos de gatos y 1500 fotos de perros y se colocan en la siguiente estructura de directorio, respectivamente:

gatos_vs_perros：

tren:

gatos: [cat.0.jpg, cat.1.jpg, cat.2.jpg ....]

perros: [perro.0.jpg, perro.1.jpg, perro.2.jpg...]

validación:

gatos: [cat.2000.jpg, cat.2001.jpg, cat.2002.jpg ....]

perros: [perro.2000.jpg, perro.2001.jpg, perro.2002.jpg ...]

Nota: el tren se utiliza como conjunto de entrenamiento, con 1000 fotos de perros y gatos; la validación se usa como conjunto de verificación, con 500 fotos de perros y gatos. Ejemplos de imágenes son los siguientes:

(2) Propósito del proyecto

El propósito del proyecto es principalmente realizar el establecimiento de un modelo para el reconocimiento de patrones de perros y gatos, y luego verificar la precisión del modelo de reconocimiento de patrones a través del conjunto de verificación. Este artículo describe principalmente el proceso de construcción del modelo de proyecto, ya que el diseño del modelo, el ajuste de parámetros y el análisis de resultados del modelo se explicarán en artículos posteriores.

3. Proceso de implementación

(1) Importación de biblioteca

from tensorflow.keras.preprocessing.image import ImageDataGenerator, load_img, img_to_array, array_to_img
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.layers import Activation, Dropout, Flatten, Dense
from tensorflow.keras import backend as K
from tensorflow.keras.callbacks import TensorBoard
from tensorflow.keras.applications import VGG16,InceptionV3,ResNet50,MobileNet
import numpy as np
import matplotlib.pyplot as plt
import glob, os, random

El papel del módulo os

Puede manejar archivos y directorios, lo que necesitamos hacer manualmente todos los días. Este módulo es especialmente importante si desea que su programa sea independiente de la plataforma.

El papel del módulo global

Se utiliza principalmente para encontrar directorios y archivos que cumplen reglas específicas y devolver los resultados buscados a una lista.

(2) Gráficos de coincidencia

path = 'data'
os.path.join(path, '*/*/*.*')
# 使用 glob 模块批量匹配图像, * 代表匹配所有东西
img_list = glob.glob(os.path.join(path, '*/*/*.*'))
print('>>>图像数量：', len(img_list))
print(img_list[:5])

for i, img_path in enumerate(img_list[:6]):
    img_plot = load_img(img_path)  # 加载图像
    arr = img_to_array(img_plot)  # 将图像转换成数组
    print(arr.shape)  # 图像形状
    plt.subplot(2, 3, i + 1)
    plt.imshow(img_plot)

os.path.join(ruta,nombre): unir directorio con nombre de archivo o directorio.

glob.glob(): Devuelve las rutas de todos los archivos que coinciden con los criterios coincidentes.

Nota: aquí es necesario que el archivo ipynb y el archivo de datos estén en el mismo directorio, como se muestra en la figura a continuación.

(3) Defina la imagen y confirme la ruta del conjunto de prueba y el conjunto de verificación

# 统一定义图像像素的宽度和高度
img_width, img_height = 100, 100
# 定义训练集、验证集的图形路径（文件夹路径即可）
train_data_dir = 'data/train/'
validation_data_dir = 'data/validation/'

Nota: lo que se puede depurar aquí es la definición uniforme del ancho y el alto de los píxeles de la imagen. Puede depurar los datos usted mismo sin leer el artículo de análisis de seguimiento. No explicaré demasiado aquí.

(4) Configuración de parámetros de entrenamiento del modelo

# 模型训练的参数设置
nb_train_samples = 30
nb_validation_samples = 10
epochs = 20  # 迭代次数
batch_size = 32  # 每个批量观测数

Nota: La configuración de los parámetros de entrenamiento del modelo afecta los resultados del entrenamiento del modelo. El número de iteraciones y el número de observaciones por lote afectan los resultados del modelo. Los primeros dos parámetros son los parámetros de models.fit_generator() más tarde, que es generalmente una función de generador La función principal es usar el generador para enviar datos al modelo en lotes, lo que puede ahorrar efectivamente un solo consumo de memoria.

(5) Definición de dimensiones y generador de imágenes.

# 图像输入维度设置
if K.image_data_format() == 'channels_first':
    input_shape = (3, img_width, img_height)
else:
    input_shape = (img_width, img_height, 3)

# 定义图像生成器
train_datagen = ImageDataGenerator(rescale=1. / 255,  # 重缩放因子
                                   shear_range=0.2,  # 剪切强度（以弧度逆时针方向剪切角度）
                                   zoom_range=0.2,  # 随机缩放范围
                                   horizontal_flip=True,  # 随机水平翻转
                                   rotation_range=360  # 360度范围内随机旋转
                                   )

# 使用图像生成器，从train_data_dir目录中读取图片，生成训练集（X_train图片数据, y_train图片所在的目录名称）
train_generator = train_datagen.flow_from_directory(train_data_dir,  # 训练数据的文件夹路径
                                                    target_size=(img_width, img_height),  # 统一像素大小
                                                    batch_size=batch_size,  # 每一批次的观测数
                                                    class_mode='categorical'  # 指定分类模式，指定二分类
                                                    )


test_datagen = ImageDataGenerator(rescale=1. / 255,
                                  shear_range=0.2,  # 剪切强度（以弧度逆时针方向剪切角度）
                                  zoom_range=0.2,  # 随机缩放范围
                                  horizontal_flip=True)  # 随机水平翻转

validation_generator = test_datagen.flow_from_directory(validation_data_dir,  # 验证集文件夹路径
                                                        target_size=(img_width, img_height),
                                                        batch_size=batch_size,
                                                        class_mode='categorical'  # 二分类
                                                        )

Nota: k.image_data_format() en la configuración de dimensiones de la imagen devuelve el orden de las dimensiones de la imagen ("channels_first" o "channels_last"). Las propiedades de las imágenes en color generalmente incluyen: ancho, alto, canales.

(6) Configuración para cada nivel de red neuronal convolucional

model = Sequential()

# -----------------------------------------------------
# 输入层：第一层
# 添加第一个卷积层/最大池化层(必选)
model.add(Conv2D(filters=32,  # 32 个过滤器
                 kernel_size=(3, 3),  # 卷积核大小 3 x 3
                 input_shape=input_shape,  # 图像输入维度
                 activation='relu'))  # 'relu' 激活函数
model.add(MaxPooling2D(pool_size=(2, 2)))  # 池化核大小 2 x 2

# ----------------------------------------------------
# 隐藏层：介于第一层和最后一层之间
# 添加第二个卷积层/最大池化层(可选)
model.add(Conv2D(filters=32, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

# 添加第三个卷积层/最大池化层(可选)
model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

# 添加第三个卷积层/最大池化层(可选)
model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

# 由于卷积层是 2D 空间，训练时需要将数据展平为 1D 空间
model.add(Flatten())  # 添加展平层(必选)
model.add(Dense(units=64, activation='relu'))  # 添加全连接层(必选) 64 个神经元
model.add(Dropout(0.5))  # 添加丢弃层，防止过拟合

# ---------------------------------------------------
# 输出层：最后一层，神经元控制输出的维度，并指定分类激活函数
model.add(Dense(units=2, activation='sigmoid'))  # 指定分类激活函数

model.summary()

model.compile(loss='binary_crossentropy',  # 指定损失函数类型
              optimizer='rmsprop',  # 优化器
              metrics=['accuracy'])  # 评价指标

Una vez completada la operación, aparecerá el siguiente diagrama de proceso:

(7) Entrenamiento de inyección de resultado de devolución de llamada de función

# tensorboard回调函数
logs = os.path.join("logs")
if not os.path.exists(logs):
    os.mkdir(logs)
train_callbacks = [
    TensorBoard(
        log_dir=r'./logs',
        histogram_freq=1,
    )
]

tensorboard_dir = os.path.join(r'.\logs\plugins\profile')
history = model.fit_generator(train_generator,
                              steps_per_epoch=nb_train_samples,
                              epochs=epochs,
                              validation_data=validation_generator,
                              validation_steps=nb_validation_samples,
                              callbacks=train_callbacks
                              )

Los parámetros de models.fit_generator() son generalmente una función de generador, la función principal es usar el generador para enviar datos al modelo en lotes, lo que puede ahorrar efectivamente el consumo de una sola memoria.

Nota: El contenido del archivo logs\plugins\profile debe crearse manualmente. Este código de experimento no escribe código para crear un módulo. Después de crear registros, debe crear una carpeta de complementos en la carpeta de registros y una carpeta de perfil en la carpeta de complementos. . De lo contrario, se informará el siguiente error:

Después de ejecutar, aparecerá el siguiente diagrama de proceso

(8) Visualización de resultados de entrenamiento

#现在将训练后的结果可视化。
acc = history.history['acc']
val_acc = history.history['val_acc']

loss = history.history['loss']
val_loss = history.history['val_loss']

epochs_range = range(epochs)

plt.figure(figsize=(20, 10))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

Visualiza el gráfico de resultados después del entrenamiento:

Reconocimiento de imágenes de perros y gatos (algoritmo de red neuronal convolucional, instalación de TensorFlow)

1. Instalación de la biblioteca Tensorflow

(1) Versiones históricas de TensorFlow y versiones correspondientes de Python