Escreva o título do diretório aqui
1. Queras
Keras é uma biblioteca de aprendizado profundo poderosa e fácil de usar que fornece API de rede neural de alta ordem baseada em Theano e TensorFlow paradesenvolvereAvalie modelos de aprendizagem profunda.
Aqui está um exemplo:
# 使用 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. Dados
Para salvar dados como um array NumPy ou array list , use o módulo train_test_split de sklearn.cross_validation.DividirDivida os dados em conjunto de treinamento e conjunto de teste .
2.1 Conjunto de dados Keras
Use Keras para importar alguns conjuntos de dados comuns e dividi-los em conjuntos de treinamento e teste .
>>> 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 Outros
Use NumPy e a biblioteca urllib para carregar dados de uma URL e dividi los em vetores de recursos X e vetores de rótulos 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. Arquitetura do modelo
3.1 Modelo sequencial
Use a biblioteca Keras para importar o modelo Sequencial . Em seguida, três objetos de modelo foram criados, denominados model , model2 e model3 .
O modelo Sequencial é um modelo empilhado simples em Keras que permite adicionar camadas ao modelo em ordem.
Ao criar esses três objetos de modelo sequencial , podemosAdicione gradualmente camadas a cada modelo e construa diferentes tipos de modelos de redes neurais。
>>> from keras.models import Sequential
>>> model = Sequential()
>>> model2 = Sequential()
>>> model3 = Sequential()
3.2 Perceptron Multicamadas (MLP)
3.2.1 Classificação binária
Use a biblioteca Keras para importar as camadas Densas e adicionar essas camadas ao modelo Sequencial uma por uma através do método model.add(). Essas três camadas densas constituem um modelo de rede neural de três camadas .
A primeira camada é uma camada totalmente conectada com 12 neurônios e aceita um vetor de recursos de entrada de dimensão 8. Os parâmetros de peso desta camada são distribuídos uniformemente,A função de ativação é a função ReLU（ativação='relu'）。
A segunda camada é uma camada totalmente conectada com 8 neurônios . Esta camada não precisa definir as dimensões de entrada porque issoUsar automaticamente a saída da camada anterior como entrada. Os parâmetros de peso desta camada também são distribuídos uniformemente,A função de ativação também é uma função ReLU。
A última camada é uma camada totalmente conectada com 1 neurônio , representando a camada de saída . Os parâmetros de peso desta camada ainda estão uniformemente distribuídos,A função de ativação é a função Sigmóide(activation='sigmoid'), usado para mapear a saída para o intervalo de 0 a 1 , indicando a probabilidade representada por cada valor de saída no problema de classificação binária.
>>> 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'))
Ao adicionar uma camada, você pode definir diferentes métodos de inicialização (como kernel_initializer), funções de ativação (como ativação), parâmetros de polarização (como bias_initializer) e outros parâmetros necessários .A seleção e configuração desses parâmetros precisam ser baseadas em problemas específicos e requisitos do modelo.。
3.2.2 Classificação multinível
>>> 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 Retorno
Aqui importamos a camada Dropout da biblioteca Keras e adicionamos camadas adicionais ao modelo Sequential existente .
>>> model.add(Dense(64,activation='relu',input_dim=train_data.shape[1]))
>>> model.add(Dense(1))
passarAdicione uma camada Dropout ao modelo, o que pode melhorar ainda mais a capacidade de generalização do modelo e reduzir o risco de overfitting . A escolha da taxa de devoluções exige muitas vezes experimentação e ajustamento da nossa parte, para que possamos alcançarMelhores capacidades de desempenho e generalização。
3.3 Rede Neural Convolucional (CNN)
Importei algumas novas camadas da biblioteca Keras e adicionei essas camadas em outro modelo Sequencial model2 . Este modelo é usado principalmente para processar dados de imagem .
>>> 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'))
Através da combinação dessas camadas, um modelo de rede neural convolucional (CNN) pode ser construído para processar dados de imagem e realizar tarefas de classificação correspondentes .
3.4 Rede Neural Recorrente (RNN)
Importei algumas novas camadas da biblioteca Keras e adicionei essas camadas em outro modelo Sequencial model3. Este modelo é usado principalmente para processar dados 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'))
Ao combinar essas camadas, um modelo pode ser construído para processar dados de texto . aquiO modelo usa uma camada de incorporação para mapear sequências de inteiros em representações vetoriais densase use a camada LSTM para modelar a sequência de texto e, finalmentePrevisão de classificação binária por meio da camada de saída。
4. Pré-processamento
4.1 Preenchimento de sequência
Importamos o módulo de pré-processamento na biblioteca Keras e usamos seu submódulo de sequência para processar dados de sequência .
>>> from keras.preprocessing import sequence
>>> x_train4 = sequence.pad_sequences(x_train4,maxlen=80)
>>> x_test4 = sequence.pad_sequences(x_test4,maxlen=80)
Aqui preenchemos a sequência da amostra de treinamento em x_train4 e a sequência da amostra de teste em x_test4 e definimos seus comprimentos como 80. Isto é feito paraCertifique-se de que os comprimentos da sequência sejam consistentes, para facilitar o processamento e cálculo subsequente no modelo . O método de preenchimento pode ser adicionar símbolos específicos ou preenchimento de zeros no início ou no final da sequência .
4.2 Codificação one-hot
aquiImportou o módulo utils na biblioteca Kerase use a função to_categorical para realizar a conversão de codificação 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)
Ao executar esses códigos, convertemos os rótulos de categoria originais por meio de codificação one-hot em um formato adequado para uso no modelo de classificação . uma codificação quente Represente o rótulo de cada categoria como um vetor, o comprimento do vetor é igual ao número de categorias, das quais apenas um elemento é 1 (indicando que a amostra pertence a esta categoria) e os demais elementos são 0. Este método de codificação pode lidar melhor com informações de categoria ao treinar modelos de classificação.
4.3 Conjuntos de treinamento e teste
Importe o módulo model_selection na biblioteca scikit-learn e use a função train_test_split para dividir o conjunto de dados .
>>> 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)
Ao executar esses códigos, dividimos os conjuntos de dados X e y em conjuntos de treinamento e conjuntos de teste , ondeA proporção do conjunto de treinamento é de 67% do conjunto total de dados e a proporção do conjunto de teste é de 33% do conjunto total de dados.. Os dados divididos podem ser usados paraTreinamento e avaliação de modelo, para verificar o desempenho do modelo em dados não vistos . Ao mesmo tempo, sementes aleatórias também são usadas para garantir a repetibilidade dos resultados do particionamento .
4.4 Padronização/Normalização
Importe o módulo de pré-processamento na biblioteca scikit-learn e use a classe StandardScaler nele para padronização de recursos .
>>> from sklearn.preprocessing import StandardScaler
>>> scaler = StandardScaler().fit(x_train2)
>>> standardized_X = scaler.transform(x_train2)
>>> standardized_X_test = scaler.transform(x_test2)
Ao executar esses códigos, os dados do conjunto de treinamento x_train2 são padronizados e o resultado é atribuído astandard_X . Ao mesmo tempo, o mesmo processo de padronização é executado nos dados do conjunto de teste x_test2 e o resultado é atribuído astandard_X_test .Dados padronizados podem ajudar a melhorar o desempenho dos modelos de aprendizado de máquina, especialmente para aqueles modelos que são muito afetados por diferentes escalas de recursos, como algoritmos que usam distância euclidiana.
5. Revise o modelo
>>> model.output_shape # 模型输出形状
>>> model.summary() # 模型摘要展示
>>> model.get_config() # 模型配置
>>> model.get_weights() # 列出模型的所有权重张量
Ao executar esses códigos, podemos visualizar facilmente o formato de saída do modelo, informações resumidas, configuração e todos os tensores de peso .
6. Modelo de compilação
6.1 Perceptron Multicamadas: Classificação Binária
aquiO método model.compile é usado para configurar os parâmetros de treinamento do modelo.
Além disso, é usado o otimizador Adam , que é um algoritmo otimizador comumente usado para ajustar adaptativamente a taxa de aprendizado para melhorar o desempenho do modelo .
Também usamos uma função binária de perda de entropia cruzada , que é adequada para tarefas de classificação binária , como julgar a saída em duas categorias.
>>> model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
Configuramos aqui o otimizador do modelo, a função de perda e os indicadores de avaliação para nos preparar para o treinamento do modelo.
6.2 Perceptron multicamadas: classificação multinível
O método model.compile também é usado aqui para configurar os parâmetros de treinamento do modelo , mas usandoOtimizador RMSprop. Ao mesmo tempo, a função de perda de entropia cruzada categórica
também é usada , que é adequada paraMúltiplas tarefas de classificação, como problemas que exigem que a entrada seja dividida em várias categorias.
>>> model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
6.3 Perceptron Multicamadas: Regressão
O método model.compile é usado para configurar os parâmetros de treinamento do modelo .
>>> model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
Aqui, o erro quadrático médio ( MSE ) é usado como a função de perda ,Adequado para problemas de regressão, onde o valor alvo é um valor numérico contínuo. Erro Médio Absoluto (MAE)
é usadoComo métrica de avaliação do modelo,Usado para medir a diferença média absoluta entre as previsões do modelo e os valores reais durante o treinamento.。
6.4 Rede Neural Recorrente
O método model3.compile é usado para configurar os parâmetros de treinamento do modelo .
>>> model3.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
7. Treinamento de modelo
>>> model3.fit(x_train4, y_train4, batch_size=32, epochs=15, verbose=1, validation_data = (x_test4,y_test4))
Aqui começamosProcesso de treinamento de modelo. O modelo é treinado usando o conjunto de treinamento para múltiplas épocas e avaliado usando o conjunto de validação após cada época . Informações como valor de perda e precisão durante o processo de treinamento serão geradas . Após a conclusão do treinamento, você terá um modelo treinado que pode ser usado para previsão e outras tarefas.
8. Avalie o desempenho do modelo
O método model3.evaluate é usado para avaliar o modelo no conjunto de teste .
>>> score = model3.evaluate(x_test, y_test, batch_size=32)
O valor de perda e a precisão do modelo ( ou outras métricas de avaliação especificadas ) no conjunto de teste são calculados . A variável de pontuação retornada contém os resultados da avaliação, aquiOs resultados podem ser usados conforme necessário para análises subsequentes, comparando o desempenho de diferentes modelos ou outras operações。
9. Previsão
Os métodos model3.predict e model3.predict_classes são usados para prever o modelo. Eles retornam os resultados previstos e as categorias previstas dos dados de entrada, respectivamente .
>>> model3.predict(x_test4, batch_size=32)
>>> model3.predict_classes(x_test4,batch_size=32)
10. Salvar/carregar modelo
Salve e carregue os modelos Keras :
>>> from keras.models import load_model
>>> model3.save('model_file.h5')
>>> my_model = load_model('my_model.h5')
Modelos já treinados podem ser salvos em arquivos e carregados posteriormente quando necessário, sem a necessidade de treinar novamente o modelo. Isso vai fazerEvite duplicação de modelos de treinamento e compartilhamento.
11. Ajuste fino do modelo
11.1 Otimização de parâmetros
Compile o modelo usando o otimizador RMSprop :
>>> from keras.optimizers import RMSprop
>>> opt = RMSprop(lr=0.0001, decay=1e-6)
>>> model2.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
Através deste processo de compilação, o modelo é configurado com funções de perda, otimizadores e indicadores de avaliação, podendo realizar tarefas como treinamento, avaliação e previsão .
11.2 Método de parada antecipada
Use a função de retorno de chamada EarlyStopping paraImplementar parada antecipada durante o treinamento。
>>> 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])
Ao usar a função de retorno de chamada EarlyStopping, o processo de treinamento será interrompido mais cedo quando o desempenho no conjunto de validação não melhorar mais , para evitar overfitting e economizar tempo de treinamento.