Tensorflow⑤——Cree un marco de red neuronal con keras

tf.keras es un marco altamente encapsulado introducido por tensorflow2, que se puede usar para construir rápidamente modelos de redes neuronales. Keras nació para admitir experimentos rápidos y puede convertir ideas en resultados rápidamente. Es el marco de aprendizaje profundo más fácil de usar. Proporciona una API coherente y concisa, que puede reducir en gran medida la carga de trabajo de las aplicaciones generales y mejorar la encapsulación y la reutilización del código.

Documentación oficial de Keras:
https://tensorflow.google.cn/api_docs/python/tf

Seis métodos para construir una red neuronal

tf.keras construye seis métodos de red neuronal

tren de importación ,
modelo de prueba = tf.keras.models.Sequential / class MyModel(Model) model=MyModel
model.compile
model.fit
model.summary

El primer paso : importar módulos relacionados, como importar tensorflow como tf.
Paso 2 : especifique el conjunto de entrenamiento y el conjunto de prueba de la red de entrada, como especificar la entrada x_train y la etiqueta y_train del conjunto de entrenamiento, y la entrada x_test y la etiqueta y_test del conjunto de prueba.
Paso 3 : construya la estructura de la red capa por capa, model = tf.keras.models.Sequential(). O use el método de heredar
el cuarto paso : configure el método de entrenamiento en model.compile(), y seleccione el optimizador, la función de pérdida y el índice de evaluación final usados ​​durante el entrenamiento.
Paso 5 : Ejecute el proceso de entrenamiento en model.fit() e informe los valores de entrada y las etiquetas del conjunto de entrenamiento y el conjunto de prueba, el tamaño de cada lote (batchsize) y el número de iteraciones del conjunto de datos (época). ).
Paso 6 : Use model.summary() para imprimir la estructura de la red y contar la cantidad de parámetros.

Introducción al uso de funciones

tf.keras.models.Sequential()

La función secuencial es un contenedor que describe la estructura de red de la red neuronal, y la estructura de red desde la capa de entrada hasta la capa de salida se describe en los parámetros de entrada de la función secuencial.
como:

Enderezar capas : tf.keras.layers.Flatten()

• La capa de enderezamiento puede transformar el tamaño del tensor y enderezar las características de entrada en una matriz unidimensional, que es una capa sin parámetros de cálculo.

---

Capa completamente conectada :

tf.keras.layers.Dense( 神经元个数,
					   activation=”激活函数”,
                       kernel_regularizer=”正则化方式”)

en:

• activación (cadena dada) opcional relu, softmax, sigmoid, tanh, etc.
• kernel_regularizer 可选 tf.keras.regularizers.l1(), tf.keras.regularizers.l2()

Capa de convolución :

tf.keras.layers.Conv2D( filter = 卷积核个数,
						kernel_size = 卷积核尺寸,
 					    strides = 卷积步长,
                        padding = “valid” or “same”)

capa LSTM:

tf.keras.layers.LSTM() 

Comúnmente utilizado como:

model = tf.keras.models.Sequential([
	# tf.keras.layers.Dense(神经元个数, activation='激活函数', kernel_regularizer=正则化方式)
    tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2)
])

modelo.compilar

 model.compile( optimizer = 优化器, loss = 损失函数, metrics = [“准确率”])

La compilación se usa para configurar el método de entrenamiento de la red neuronal e informar al optimizador, la función de pérdida y el estándar de evaluación de precisión que se usa durante el entrenamiento.
Entre ellos :

• optimizador puede ser el nombre del optimizador dado en forma de cadena, o puede tener la forma de una función, y la tasa de aprendizaje, el impulso y los hiperparámetros se pueden establecer mediante la forma de función.
  Las opciones incluyen:

   ‘Sgd’or tf.keras.optimizers.SGD( lr=学习率,
      						  decay=学习率衰减率,
							  momentum=动量参数)
							  
   ‘Adagrad’or tf.keras.optimizers.Adagrad(lr=学习率,
							  			   decay=学习率衰减率)
							  			   
   ‘Adadelta’or tf.keras.optimizers.Adadelta(lr=学习率,
											 decay=学习率衰减率)
											 
   ‘Adam’or tf.keras.optimizers.Adam (lr=学习率,
									  decay=学习率衰减率)

• loss puede ser el nombre de la función de pérdida dado como una cadena o como una función.
  Las opciones incluyen:

   ‘mse’or tf.keras.losses.MeanSquaredError()
   ‘sparse_categorical_crossentropy or tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)
   # 损失函数常需要经过 softmax 等函数将输出转化为概率分布的形式。
   # from_logits 则用来标注该损失函数是否需要转换为概率的形式，取 False 时表示已经转化为概率分布，取 True 时表示没有转化为概率分布，直接输出。

• Las métricas marcan los indicadores de evaluación de la red.
  Las opciones incluyen:

‘accuracy’：y_和 y 都是数值，如 y_=[1] y=[1]。

‘categorical_accuracy’：y_和 y 都是以独热码和概率分布表示。
	如 y_=[0, 1, 0], y=[0.256, 0.695, 0.048]
	
‘sparse_categorical_accuracy’：y_是以数值形式给出，y 是以独热码形式给出。
	如 y_=[1],y=[0.256, 0.695, 0.048]。

model.fit: utilizado para realizar el proceso de entrenamiento

model.fit(训练集的输入特征， 训练集的标签， batch_size, epochs,
 		  validation_data = (测试集的输入特征，测试集的标签)，
 		  validataion_split = 从测试集划分多少比例给训练集，
 		  validation_freq = 测试的 epoch 间隔次数) 

Resumen Modelo()

La función de resumen se utiliza para imprimir la estructura de la red y las estadísticas de los parámetros.

ejemplo

• Tome el conjunto de datos del iris en sklearn como ejemplo, use la función secuencial para inicializar y use el método de 6 pasos para el reconocimiento de precisión

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
import numpy as np
from sklearn import datasets

x_train = datasets.load_iris().data
y_train = datasets.load_iris().target

np.random.seed(116)
np.random.shuffle(x_train)
np.random.seed(116)
np.random.shuffle(y_train)
tf.random.set_seed(116)

model = tf.keras.models.Sequential([
# tf.keras.layers.Dense( 神经元个数, activation='激活函数', kernel_regularizer=正则化方式 )
    tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
])

# Model.compile( optimizer = 优化器, loss = 损失函数, metrics = ['准确率'])
model.compile(
    # optimizer=tf.keras.optimizers.SGD(learning_rate=0.1),
    optimizer=tf.keras.optimizers.SGD(lr=0.1),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
    metrics=['sparse_categorical_accuracy']
)

# model.fit(训练集的输入特征， 训练集的标签， batch_size, epochs,
#  		    validation_data = (测试集的输入特征，测试集的标签)，
#  		    validataion_split = 从测试集划分多少比例给训练集，
#  		    validation_freq = 测试的 epoch 间隔次数)
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)

model.summary()

• Tome el conjunto de datos del iris en sklearn como ejemplo, use la función de clase para inicializar y use el método de 6 pasos para el reconocimiento de precisión

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
from tensorflow.keras.layers import Dense
from tensorflow.keras import Model
from sklearn import datasets
import numpy as np

x_train = datasets.load_iris().data
y_train = datasets.load_iris().target

np.random.seed(116)
np.random.shuffle(x_train)
np.random.seed(116)
np.random.shuffle(y_train)
tf.random.set_seed(116)

class IrisModel(Model):
    def __init__(self):
        super(IrisModel, self).__init__()
        self.d1 = Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())

    def call(self, x, training=None, mask=None):
    # def call(self, x):
        y = self.d1(x)
        return y

model = IrisModel()

model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
model.summary()