Anaconda es una distribución de código abierto de Python, que se utiliza para administrar paquetes relacionados con Python , usar anaconda puede cambiar fácilmente a diferentes entornos de Python y usar diferentes marcos de aprendizaje profundo para desarrollar proyectos, ¡lo cual es muy eficiente!

Para conocer los pasos específicos de descarga e instalación, consulte el artículo de este tipo grande

El tutorial de instalación y uso de Anaconda más completo de la historia %2522scm% 2522%253A %252220140713.130102334..%2522%257D&request_id=168594896716800180669116&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-2 -1 03889237-null-null.142^v88^control_2,239 ^v2^insertar_chatgpt&utm_term =Anaconda%E5%AE%89%E8%A3%85&spm=1018.2226.3001.4187

2. Crea un entorno virtual

Paso 1: abra la ventana de comandos de Anaconda, Anaconda Prompt

Anaconda se adjuntará después de que la instalación sea exitosa, en la barra de inicio

Paso 2: use el comando para crear una versión específica del entorno de python (aquí hay un ejemplo del nombre del entorno del comando py36)

conda create -n py36 python=3.6

3. Cambiar de entorno

El entorno predeterminado es base. Necesitamos crear una versión específica del entorno para que la usemos. Puede entenderse como el entorno específico que debe crearse para desarrollar un proyecto, de modo que los entornos entre diferentes proyectos estén aislados entre sí. otro _ Utilice el comando activar + nombre del entorno para cambiar el entorno.

activate py36

Después de cambiar al entorno py36, ingrese el comando conda info y aparecerá la siguiente información, lo que indica que el entorno de superficie se creó correctamente.

4. Descarga el kit de herramientas necesario para el proyecto

Después de cambiar con éxito a py36 (el entorno creado por usted mismo) , ejecute los siguientes comandos en Anaconda Prompt para descargar los kits de herramientas necesarios. Nota: Dado que la fuente de descarga predeterminada está en el extranjero, la velocidad de descarga será muy lenta. Podemos usar algunos espejos domésticos. para descargar, muy rápido. Simplemente agregue -i mirror address después de cada uno de los siguientes comandos.

Estoy usando la fuente espejo de la Universidad de Tsinghua: -i https://pypi.tuna.tsinghua.edu.cn/simple

pip install scipy -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install matplolib -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install scipy -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install keras==2.1.0 -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install tensorflow==1.14.0 -i https://pypi.tuna.tsinghua.edu.cn/simple

5. Establecer el entorno de Pycharm como el entorno creado

Haga clic en Agregar intérprete en la esquina inferior derecha de Pycharm

Como se muestra en la figura a continuación, seleccione conda.exe en la carpeta Scripts en el directorio de instalación de Anaconda

(Algunos también aparecerán en el directorio raíz. También puede elegir conda.exe en el directorio raíz. Habrá diferencias según las diferentes versiones de Pycharm)

Después de que Pycharm cambia el intérprete, hasta ahora, la preparación del entorno se completa

3. Operación y prueba del proyecto de reconocimiento de imágenes digitales manuscritas basado en Keras

1. Código central

tren_cnn.py

#步骤01 入所需要的模块
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D
import numpy as np
np.random.seed(10)

#步骤02 下载mnist数据集、读取数据集
(x_Train, y_Train) , (x_Test, y_Test) = mnist.load_data()

#步骤03 将图像特征值转化为6000,28,28,1的4维矩阵
x_Train4D = x_Train.reshape(x_Train.shape[0], 28, 28,1).astype('float32')
x_Test4D = x_Test.reshape(x_Test.shape[0], 28, 28, 1).astype('float32')

#步骤04 进行标准化
#将像素范围设置在【0,1】
x_Train4D_normalize = x_Train4D / 255
x_Test4D_normalize = x_Test4D / 255

#步骤05 label进行一位有效编码转换
#将标签转成读热码
y_TrainHot = np_utils.to_categorical(y_Train)
y_TestHot = np_utils.to_categorical(y_Test)

#=>建立模型
#步骤01 定义模型
model = Sequential()

#步骤02 建立卷积层1
model.add(Conv2D(filters=16, # filter = 16 建立16个滤镜
# kernel_size = (5,5) 每一个滤镜是5 × 5的大小
kernel_size=(5,5), 
    # padding = 'same' 设置卷积运算产生的图像大小不变
padding='same', 
#输入的图像形状为28*28,1代表单色灰度，3代表RGB
input_shape= (28, 28, 1),
# activation设置激活函数为relu建立池化层1
activation='relu'))

#步骤03 建立池化层1
model.add(MaxPooling2D(pool_size=(2,2)))#缩减采样，输出16个14*14图像

#步骤04建立卷积层2
model.add(Conv2D(filters=36,#建立36个滤镜
kernel_size=(5,5),#每一个滤镜是5 × 5的大小
padding='same',#Convolution完成后的图像大小不变
activation='relu'#输出36个14*14的图像
))

#步骤05 建立池化层2，加入Dropout避免Overfitting
model.add(MaxPooling2D(pool_size=(2,2)))#图像大小变为7*7
# 加入DropOut(0.25)，每次训练时，会在神经网络中随机放弃25%的神经元，避免过拟合建立神经网络（平坦层，隐藏层，输出层)建立平坦层
model.add(Dropout(0.25))

#步骤06 建立平坦层
model.add(Flatten())#长度是36*7*7个神经元

#步骤07 建立隐藏层
model.add(Dense(128, activation='relu'))
# 把DropOut加入模型中，DropOut(0.5)在每次迭代时候会随机放弃50%的神经元，避免过拟合
model.add(Dropout(0.5))
# 建立输出层，一共10个单元，对应0-9一共10个数字。使用softmax进行激活
model.add(Dense(10, activation='softmax'))
# 查看模型摘要
print(model.summary())

#=>进行训练
#步骤01 定义训练方式
# 定义训练方式compile
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

#步骤02 开始训练
train_history = model.fit(x = x_Train4D_normalize, y = y_TrainHot,
validation_split=0.2,
#将80%作为训练数据，20%作为测试数据
epochs=10,#执行10个训练周期
batch_size=300,#每一批300项数据
verbose=2#参数为2表示显示训练过程
)

tren_cnn_modelo.py

from keras.datasets import mnist
from keras.utils import np_utils
import numpy as np
np.random.seed(10)

(x_Train, y_Train) , (x_Test, y_Test) = mnist.load_data()

x_Train4D = x_Train.reshape(x_Train.shape[0], 28, 28,1).astype('float32')
x_Test4D = x_Test.reshape(x_Test.shape[0], 28, 28, 1).astype('float32')

x_Train4D_normalize = x_Train4D / 255
x_Test4D_normalize = x_Test4D / 255
y_TrainHot = np_utils.to_categorical(y_Train)
y_TestHot = np_utils.to_categorical(y_Test)

from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D

model = Sequential()
model.add(Conv2D(filters=16, kernel_size=(5,5), padding='same', input_shape = (28, 28, 1), activation='relu'))
# 参数说明
# filter = 16 建立16个滤镜
# kernel_size = (5,5) 每一个滤镜是5 × 5的大小
# padding = 'same' 设置卷积运算产生的图像大小不变
# input_shape = (28, 28, 1) 第一二维代表输入图像的形状是28 × 28，第三维因为是单色灰度图像，所以最后维数值是1
# activation设置激活函数为relu建立池化层1
model.add(MaxPooling2D(pool_size=(2,2)))
# 输入参数为pool_size=(2,2),执行第一次缩减采样，将16个28 ×28的图像缩小为16个14 × 14的图像建立卷积层2，将16个图像转化为36个图像，不改变图像大小，仍为14 × 14
model.add(Conv2D(filters=36, kernel_size=(5,5), padding='same', activation='relu'))
# 加入池化层2，并加入DropOut避免过拟合
model.add(MaxPooling2D(pool_size=(2,2)))
# 执行第二次缩减采样，将14 × 14图像转换为7 × 7图像
model.add(Dropout(0.25))
# 加入DropOut(0.25)，每次训练时，会在神经网络中随机放弃25%的神经元，避免过拟合建立神经网络（平坦层，隐藏层，输出层)建立平坦层
model.add(Flatten())
# 将之前步骤建立的池化层2，一共有36个7 × 7的图像转化为一维向量，长度是36 × 7 × 7 = 1764， 也就是1764个float数，对应1764个神经元建立隐藏层，一共128个神经元
model.add(Dense(128, activation='relu'))
# 把DropOut加入模型中，DropOut(0.5)在每次迭代时候会随机放弃50%的神经元，避免过拟合
model.add(Dropout(0.5))
# 建立输出层，一共10个单元，对应0-9一共10个数字。使用softmax进行激活
model.add(Dense(10, activation='softmax'))
# 查看模型摘要
print(model.summary())
# # 进行训练
# 定义训练方式

# # 加载之前训练的模型
try:
    # model.load_weights("SaveModel/minist_model.h5")
    model.load_weights("SaveModel/minist_model_graphic.h5")
    print("加载模型成功!继续训练模型")
except :
    print("加载模型失败!开始训练一个新模型")

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# 开始训练
train_history = model.fit(x = x_Train4D_normalize, y = y_TrainHot,
                          validation_split=0.2, epochs=10, batch_size=300, verbose=2)

# model.save_weights("SaveModel/minist_model.h5")
model.save("SaveModel/minist_model_graphic.h5")

print("Saved model to disk")

predecir_uno_img.py

import cv2
from keras.models import load_model

img = cv2.imread("./pic/6.jpg")
print(img.shape)
grey_img = img[:,:,0:1]
print(grey_img.shape)
shape_img= (grey_img.reshape(1, 28, 28, 1)).astype('float32')/255

# model = load_model('SaveModel/minist_model.h5')  #选取自己的.h模型名称
model = load_model('SaveModel/minist_model_graphic.h5')  #选取自己的.h模型名称
prediction = model.predict_classes(shape_img)
print('该手写数字图像为：'+'%d'%prediction[0])

2. Colección de imágenes manuscritas para reconocimiento.

3. Principios básicos del reconocimiento

El conjunto de datos utilizado es el conjunto de datos MNIST . Cada imagen de este conjunto de datos consta de 28x28 píxeles y cada píxel está representado por un valor de gris. El siguiente es un ejemplo del número 1. Nuestro propósito es hacer un modelo, ingresar estos 784 valores en el modelo y luego su resultado de salida es 1.

4. Ejecutar y probar

Lea primero el conjunto de datos

modelo de datos de entrenamiento

Reconocer imágenes de dígitos escritos a mano

4. Análisis y Resumen

Esta vez, basado en el caso clásico del reconocimiento de imágenes digitales manuscritas de Keras , inicialmente aprendí otra rama importante del aprendizaje automático: el contenido del aprendizaje profundo. El conjunto de datos utilizado es el conjunto de datos MNIST . Cada imagen de este conjunto de datos consta de 28x28 píxeles y cada píxel está representado por un valor de gris. El primero es usar la línea de comando pip para descargar el kit de herramientas que importará el programa. Al mismo tiempo, use el comando enable py36 para cambiar el entorno de python al entorno donde creamos e importamos el kit de herramientas relevante. El compilador usa pycharm para ejecutar el programa. En primer lugar, es necesario entrenar el conjunto de datos y luego usar el modelo entrenado para reconocer la imagen digital manuscrita 6.jpg, y la consola imprime los resultados del reconocimiento.

Después del estudio de este caso introductorio, tengo un gran interés en el campo del aprendizaje automático. En esencia, utiliza datos masivos como entrada para permitir que la computadora entrene y analice un modelo. Podemos considerarlo como una función, un " " Black box", y luego utilícelo para identificar los datos especificados y dar los resultados del análisis. Este proceso es análogo al proceso del cerebro humano que resume la experiencia pasada y predice el futuro para guiar las acciones. ¡Es muy sorprendente! !

artículo de referencia

Ejemplo de aprendizaje en profundidad: Keras realiza el reconocimiento de dígitos escritos a mano tributo.pc_search_result.none-task-blog-2~todos~sobaiduend~predeterminado -1-103811112-null-null.142^v88^control_2,239^v2 ^insert_chatgpt&utm_term=Keras%E6%89%8B%E5%86%99%E6%95%B0%E5%AD%97%E5%9B %BE%E5%83%8F%E8%AF%86%E5%88 %AB&spm=1018.2226.3001.4187 [Práctica de aprendizaje profundo - 1]: Reconocimiento de dígitos escritos a mano basado en Keras (código fuente abierto muy detallado)https://blog.csdn.net/qq_42856191/article/details/121420268?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522168594730916800222827149%2522%252C%2522scm% 2522%253A%252220140713.130102334..%2522%257D&request_id = 168594730916800222827149 Keras%E6%89%8B %E5%86%99%E6%95%B0%E5%AD%97%E5%9B%BE%E5%83%8F%E8%AF%86%E5%88%AB&spm=1018.2226.3001.4187

[Introducción al caso de aprendizaje profundo 1] Reconocimiento de imágenes digitales manuscritas basado en Keras

Directorio de artículos

1. Herramientas y entorno

2. Construcción de un entorno de aprendizaje profundo

1. Instalar Anaconda