Escriba aquí el título del directorio
1. Keras
Keras es una biblioteca de aprendizaje profundo potente y fácil de usar que proporciona API de red neuronal de alto orden basada en Theano y TensorFlow paradesarrollaryEvaluar modelos de aprendizaje profundo.
Aquí hay un ejemplo:
# 使用 Keras 建立一个简单的神经网络模型，并对数据进行训练和预测
# 导入所需的库，包括 numpy（用于生成随机数据），以及 Keras 中的相关模块
>>> import numpy as np
>>> from keras.models import Sequential
>>> from keras.layers import Dense
# 生成了一个 data 数组，形状为 (1000, 100)，其中包含随机生成的数据
>>> data = np.random.random((1000,100))
# 生成一个 labels 数组，形状为 (1000, 1)，其中包含随机生成的二分类标签
>>> labels = np.random.randint(2,size=(1000,1))
# 创建一个序贯模型 model，它是 Keras 中的一种常见模型类型
>>> model = Sequential()
# 使用 add 方法向模型添加两个全连接层
>>> model.add(Dense(32,activation='relu',input_dim=100))
# 第一层具有 32 个神经元，激活函数为 ReLU，并且输入维度为 100
>>> model.add(Dense(1, activation='sigmoid'))
# 第二层是输出层，具有一个神经元和 sigmoid 激活函数，用于二分类问题
>>> model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics=['accuracy'])
# 通过调用 compile 方法，配置模型的优化器为 'rmsprop'，损失函数为 'binary_crossentropy'，并指定了评估指标为准确率
>>> model.fit(data,labels,epochs=10,batch_size=32)
# 使用 fit 方法将数据和标签作为输入，对模型进行训练
>>> predictions = model.predict(data)
# 使用 predict 方法对训练数据进行预测，并将预测结果保存在 predictions 变量中
2. Datos
Para guardar datos como una matriz NumPy o una lista de matrices , use el módulo train_test_split de sklearn.cross_validation.DividirDivida los datos en conjunto de entrenamiento y conjunto de prueba .
2.1 Conjunto de datos de Keras
Utilice Keras para importar algunos conjuntos de datos comunes y dividirlos en conjuntos de entrenamiento y prueba .
>>> from keras.datasets import boston_housing,
mnist, cifar10, imdb >>> (x_train,y_train),(x_test,y_test) = mnist.load_data()
>>> (x_train2,y_train2),(x_test2,y_test2) = boston_housing.load_data()
>>> (x_train3,y_train3),(x_test3,y_test3) = cifar10.load_data()
>>> (x_train4,y_train4),(x_test4,y_test4) = imdb.load_data(num_words=20000)
>>> num_classes = 10
2.2 Otros
Utilice NumPy y la biblioteca urllib para cargar datos desde una URL y dividirlos en vectores de características X y vectores de etiquetas y .
>>> from urllib.request import urlopen
>>> data = np.loadtxt(urlopen("http://archive.ics.uci.edu/ ml/machine-learning-databases/pima-indians-diabetes/
pima-indians-diabetes.data"),delimiter=",")
>>> X = data[:,0:8]
>>> y = data [:,8]
3. Arquitectura modelo
3.1 Modelo secuencial
Utilice la biblioteca Keras para importar el modelo secuencial . Luego, se crearon tres objetos modelo, denominados modelo , modelo2 y modelo3 .
El modelo secuencial es un modelo apilado simple en Keras que permite agregar capas al modelo en orden..
Al crear estos tres objetos de modelo secuencial , podemosAgregue gradualmente capas a cada modelo y cree diferentes tipos de modelos de redes neuronales.。
>>> from keras.models import Sequential
>>> model = Sequential()
>>> model2 = Sequential()
>>> model3 = Sequential()
3.2 Perceptrón multicapa (MLP)
3.2.1 Clasificación binaria
Utilice la biblioteca Keras para importar las capas densas y agregue estas capas al modelo secuencial una por una mediante el método model.add(). Estas tres capas densas constituyen un modelo de red neuronal de tres capas .
La primera capa es una capa completamente conectada con 12 neuronas y acepta un vector de características de entrada de dimensión 8. Los parámetros de peso de esta capa están distribuidos uniformemente,La función de activación es la función ReLU.(activación='relu'）。
La segunda capa es una capa completamente conectada con 8 neuronas . Esta capa no necesita establecer las dimensiones de entrada porqueUtilice automáticamente la salida de la capa anterior como entrada. Los parámetros de peso de esta capa también se distribuyen uniformemente,La función de activación también es una función ReLU.。
La última capa es una capa completamente conectada con 1 neurona , que representa la capa de salida . Los parámetros de peso de esta capa todavía están distribuidos uniformemente,La función de activación es la función sigmoidea.(activación = 'sigmoide'), utilizado para asignar la salida al rango de 0 a 1 , indicando la probabilidad representada por cada valor de salida en el problema de clasificación binaria.
>>> from keras.layers import Dense
>>> model.add(Dense(12, input_dim = 8, kernel_initializer='uniform', activation='relu'))
>>> model.add(Dense(8,kernel_initializer='uniform',activation='relu'))
>>> model.add(Dense(1,kernel_initializer='uniform',activation='sigmoid'))
Al agregar una capa, puede configurar diferentes métodos de inicialización (como kernel_initializer), funciones de activación (como activación), parámetros de sesgo (como sesgo_initializer) y otros parámetros necesarios .La selección y configuración de estos parámetros debe basarse en problemas específicos y requisitos del modelo.。
3.2.2 Clasificación multinivel
>>> from keras.layers import Dropout
>>> model.add(Dense(512,activation='relu',input_shape=(784,)))
>>> model.add(Dropout(0.2))
>>> model.add(Dense(512,activation='relu'))
>>> model.add(Dropout(0.2))
>>> model.add(Dense(10,activation='softmax'))
3.2.3 Devolución
Aquí importamos la capa Dropout de la biblioteca Keras y agregamos capas adicionales al modelo Sequential existente .
>>> model.add(Dense(64,activation='relu',input_dim=train_data.shape[1]))
>>> model.add(Dense(1))
aprobarAgregar una capa de abandono al modelo, lo que puede mejorar aún más la capacidad de generalización del modelo y reducir el riesgo de sobreajuste . La elección de la tasa de descarte a menudo requiere experimentación y ajustes de nuestra parte para poder lograrMejores capacidades de rendimiento y generalización.。
3.3 Red neuronal convolucional (CNN)
Importé algunas capas nuevas de la biblioteca de Keras y agregué estas capas en otro modelo de modelo secuencial2 . Este modelo se utiliza principalmente para procesar datos de imágenes .
>>> from keras.layers import Activation,Conv2D,MaxPooling2D,Flatten
>>> model2.add(Conv2D(32,(3,3),padding='same',input_shape=x_train.shape[1:]))
>>> model2.add(Activation('relu'))
>>> model2.add(Conv2D(32,(3,3)))
>>> model2.add(Activation('relu'))
>>> model2.add(MaxPooling2D(pool_size=(2,2)))
>>> model2.add(Dropout(0.25))
>>> model2.add(Conv2D(64,(3,3), padding='same'))
>>> model2.add(Activation('relu'))
>>> model2.add(Conv2D(64,(3, 3)))
>>> model2.add(Activation('relu'))
>>> model2.add(MaxPooling2D(pool_size=(2,2)))
>>> model2.add(Dropout(0.25))
>>> model2.add(Flatten())
>>> model2.add(Dense(512))
>>> model2.add(Activation('relu'))
>>> model2.add(Dropout(0.5))
>>> model2.add(Dense(num_classes))
>>> model2.add(Activation('softmax'))
Mediante la combinación de estas capas, se puede construir un modelo de red neuronal convolucional (CNN) para procesar datos de imágenes y realizar las tareas de clasificación correspondientes .
3.4 Red neuronal recurrente (RNN)
Importé algunas capas nuevas de la biblioteca de Keras y agregué estas capas en otro modelo de modelo secuencial3. Este modelo se utiliza principalmente para procesar datos de texto .
>>> from keras.klayers import Embedding,LSTM
>>> model3.add(Embedding(20000,128))
>>> model3.add(LSTM(128,dropout=0.2,recurrent_dropout=0.2))
>>> model3.add(Dense(1,activation='sigmoid'))
Al combinar estas capas, se puede construir un modelo para procesar datos de texto . aquíEl modelo utiliza una capa de incrustación para mapear secuencias de números enteros en representaciones vectoriales densas.y usar la capa LSTM para modelar la secuencia de texto , y finalmentePredicción de clasificación binaria a través de la capa de salida.。
4. Preprocesamiento
4.1 Relleno de secuencia
Importamos el módulo de preprocesamiento en la biblioteca Keras y usamos su submódulo de secuencia para procesar datos de secuencia .
>>> from keras.preprocessing import sequence
>>> x_train4 = sequence.pad_sequences(x_train4,maxlen=80)
>>> x_test4 = sequence.pad_sequences(x_test4,maxlen=80)
Aquí completamos la secuencia de muestra de entrenamiento en x_train4 y la secuencia de muestra de prueba en x_test4, y establecemos sus longitudes en 80. Esto se hace paraAsegúrese de que las longitudes de las secuencias sean consistentes, para facilitar el posterior procesamiento y cálculo en el modelo . El método de llenado puede ser agregar símbolos específicos o relleno de ceros al principio o al final de la secuencia .
4.2 Codificación one-hot
aquíImporté el módulo de utilidades en la biblioteca de Keras.y utilice la función to_categorical para realizar una conversión de codificación one-hot .
>>> from keras.utils import to_categorical
>>> Y_train = to_categorical(y_train, num_classes)
>>> Y_test = to_categorical(y_test, num_classes)
>>> Y_train3 = to_categorical(y_train3, num_classes)
>>> Y_test3 = to_categorical(y_test3, num_classes)
Al ejecutar estos códigos, convertimos las etiquetas de categorías originales mediante codificación one-hot a un formato adecuado para su uso en el modelo de clasificación . una codificación en caliente Representa la etiqueta de cada categoría como un vector, la longitud del vector es igual al número de categorías, de las cuales solo un elemento es 1 (lo que indica que la muestra pertenece a esta categoría) y los otros elementos son 0. Este método de codificación puede manejar mejor la información de categorías al entrenar modelos de clasificación.
4.3 Conjuntos de entrenamiento y prueba
Importe el módulo model_selection en la biblioteca scikit-learn y use la función train_test_split para dividir el conjunto de datos .
>>> from sklearn.model_selection import train_test_split
>>> X_train5,X_test5,y_train5,y_test5 = train_test_split(X, y,test_size=0.33, random_state=42)
Al ejecutar estos códigos, dividimos los conjuntos de datos X e y en conjuntos de entrenamiento y conjuntos de prueba , dondeLa proporción del conjunto de entrenamiento es el 67% del conjunto de datos total y la proporción del conjunto de prueba es el 33% del conjunto de datos total.. Los datos divididos se pueden utilizar paraFormación y evaluación de modelos., para verificar el rendimiento del modelo en datos invisibles . Al mismo tiempo, también se utilizan semillas aleatorias para garantizar la repetibilidad de los resultados de la partición .
4.4 Estandarización/Normalización
Importe el módulo de preprocesamiento en la biblioteca scikit-learn y use la clase StandardScaler en él para la estandarización de funciones .
>>> from sklearn.preprocessing import StandardScaler
>>> scaler = StandardScaler().fit(x_train2)
>>> standardized_X = scaler.transform(x_train2)
>>> standardized_X_test = scaler.transform(x_test2)
Al ejecutar estos códigos, los datos del conjunto de entrenamiento x_train2 se estandarizan y el resultado se asigna a estandarizado_X . Al mismo tiempo, se realiza el mismo proceso de estandarización en los datos del conjunto de prueba x_test2 y el resultado se asigna a standardized_X_test .Los datos estandarizados pueden ayudar a mejorar el rendimiento de los modelos de aprendizaje automático, especialmente para aquellos modelos que se ven muy afectados por diferentes escalas de características, como los algoritmos que utilizan distancia euclidiana.
5. Revisa el modelo
>>> model.output_shape # 模型输出形状
>>> model.summary() # 模型摘要展示
>>> model.get_config() # 模型配置
>>> model.get_weights() # 列出模型的所有权重张量
Al ejecutar estos códigos, podemos ver fácilmente la forma de salida del modelo, la información resumida, la configuración y todos los tensores de peso .
6. Compilar modelo
6.1 Perceptrón multicapa: clasificación binaria
aquíEl método model.compile se utiliza para configurar los parámetros de entrenamiento del modelo..
Además, se utiliza el optimizador Adam , que es un algoritmo optimizador de uso común para ajustar de forma adaptativa la tasa de aprendizaje para mejorar el rendimiento del modelo .
También utilizamos una función de pérdida de entropía cruzada binaria , que es adecuada para tareas de clasificación binaria , como juzgar la salida en dos categorías.
>>> model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
Hemos configurado aquí el optimizador del modelo, la función de pérdida y los indicadores de evaluación para prepararnos para el entrenamiento del modelo.
6.2 Perceptrón multicapa: clasificación multinivel
El método model.compile también se usa aquí para configurar los parámetros de entrenamiento del modelo , pero usandooptimizador RMSprop.
Al mismo tiempo, también se utiliza la función de pérdida de entropía cruzada categórica , que es adecuada paraMúltiples tareas de clasificación, como problemas que requieren que la entrada se divida en varias categorías.
>>> model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
6.3 Perceptrón multicapa: regresión
El método model.compile se utiliza para configurar los parámetros de entrenamiento del modelo .
>>> model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
Aquí, el error cuadrático medio ( MSE ) se utiliza como función de pérdida .Adecuado para problemas de regresión, donde el valor objetivo es un valor numérico continuo.
Se utiliza el error absoluto medio (MAE)Como métrica de evaluación del modelo.，Se utiliza para medir la diferencia absoluta promedio entre las predicciones del modelo y los valores reales durante el entrenamiento.。
6.4 Red neuronal recurrente
El método model3.compile se utiliza para configurar los parámetros de entrenamiento del modelo .
>>> model3.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
7. Entrenamiento modelo
>>> model3.fit(x_train4, y_train4, batch_size=32, epochs=15, verbose=1, validation_data = (x_test4,y_test4))
aquí empezamosProceso de formación modelo. El modelo se entrena utilizando el conjunto de entrenamiento para múltiples épocas y se evalúa utilizando el conjunto de validación después de cada época . Se generará información como el valor de pérdida y la tasa de precisión durante el proceso de capacitación . Una vez completada la capacitación, tendrá un modelo entrenado que puede usarse para predicciones y otras tareas.
8. Evaluar el rendimiento del modelo.
El método model3.evaluate se utiliza para evaluar el modelo en el conjunto de prueba .
>>> score = model3.evaluate(x_test, y_test, batch_size=32)
Se calculan el valor de pérdida y la precisión del modelo ( u otras métricas de evaluación especificadas ) en el conjunto de prueba . La variable de puntuación devuelta contiene los resultados de la evaluación, aquíLos resultados se pueden utilizar según sea necesario para análisis posteriores, comparando el rendimiento de diferentes modelos u otras operaciones.。
9. Pronóstico
Los métodos model3.predict y model3.predict_classes se utilizan para predecir el modelo. Devuelven los resultados previstos y las categorías previstas de los datos de entrada respectivamente .
>>> model3.predict(x_test4, batch_size=32)
>>> model3.predict_classes(x_test4,batch_size=32)
10. Guardar/cargar modelo
Guarde y cargue modelos de Keras :
>>> from keras.models import load_model
>>> model3.save('model_file.h5')
>>> my_model = load_model('my_model.h5')
Los modelos ya entrenados se pueden guardar en archivos y cargar más tarde cuando sea necesario sin tener que volver a entrenar el modelo. Esto lo haraEvite la duplicación de modelos de capacitación e intercambio.
11. Ajuste del modelo
11.1 Optimización de parámetros
Compile el modelo usando el optimizador RMSprop :
>>> from keras.optimizers import RMSprop
>>> opt = RMSprop(lr=0.0001, decay=1e-6)
>>> model2.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
A través de este proceso de compilación, el modelo se configura con funciones de pérdida, optimizadores e indicadores de evaluación, y puede realizar tareas como entrenamiento, evaluación y predicción .
11.2 Método de parada anticipada
Utilice la función de devolución de llamada EarlyStopping paraImplementar paradas tempranas durante el entrenamiento.。
>>> from keras.callbacks import EarlyStopping
>>> early_stopping_monitor = EarlyStopping(patience=2)
>>> model3.fit(x_train4, y_train4, batch_size=32, epochs=15, validation_data=(x_test4,y_test4), callbacks=[early_stopping_monitor])
Al utilizar la función de devolución de llamada EarlyStopping, el proceso de capacitación se detendrá antes de tiempo cuando el rendimiento en el conjunto de validación ya no mejore , para evitar el sobreajuste y ahorrar tiempo de capacitación.