Experiência de Inteligência Artificial 4

O quarto experimento

1. Finalidade experimental

Entenda os princípios básicos do aprendizado profundo. Capacidade de usar ferramentas de código aberto de aprendizagem profunda. Aprenda a usar algoritmos de aprendizado profundo para resolver problemas do mundo real.

2. Princípios experimentais

1. Visão geral do aprendizado profundo

O aprendizado profundo se origina de redes neurais artificiais. Sua essência é construir uma rede neural artificial com múltiplas camadas ocultas. Ele usa convolução, pooling, retropropagação de erros e outros meios para realizar o aprendizado de recursos e melhorar a precisão da classificação ou previsão. O aprendizado profundo alcança melhor desempenho de previsão e classificação aumentando a profundidade da rede, reduzindo o número de recursos que precisam ser ajustados em cada camada e extraindo informações de baixo para cima, camada por camada. Enfatize a profundidade da estrutura do modelo, geralmente com mais de 5 camadas ocultas.

Neurônio é a unidade básica no modelo de aprendizado profundo. Ele pondera e acumula as informações de entrada dos neurônios diretos adjacentes, adiciona um valor de desvio, realiza transformações não lineares no resultado e gera o resultado final. As funções de ativação de transformação não linear comumente usadas incluem Sigmoid, Tanh, ReLU e Softmax.

Insira a descrição da imagem aqui

Existem múltiplas camadas na rede neural de aprendizagem profunda, cada camada contém alguns neurônios, e as relações de conexão entre os neurônios em diferentes níveis constituem diferentes redes neurais. Cada neurônio em cada camada possui pesos e valores de polarização diferentes, que são os parâmetros da rede neural. Os parâmetros são ajustados por meio de treinamento, resultando em uma rede neural com alta classificação e precisão de previsão. Algoritmos de otimização de parâmetros envolvem descida de gradiente, retropropagação de erro, etc.

Gradiente descendente

O algoritmo de gradiente descendente é um método para minimizar a função de perda. Numa função multivariada, o gradiente é um vetor de derivadas parciais em relação a cada variável. A direção oposta do gradiente é a direção na qual o valor da função diminui mais rapidamente. O algoritmo de descida gradiente é usado para minimizar a função de perda e encontrar a direção na qual a função de perda diminui mais rapidamente para ajuste de parâmetro.

retropropagação de erro

A retropropagação de erro é o processo no qual o gradiente da função de perda em relação aos parâmetros flui para trás através da rede.

Insira a descrição da imagem aqui

Para reduzir a função de perda, encontre a derivada parcial da função de perda em relação ao parâmetro w1, selecione um incremento na direção oposta do gradiente da função de perda e ajuste o peso de w1 para garantir que o valor de a função de perda é reduzida. O parâmetro w1 não aparece diretamente na função de perda. A derivada parcial de w1 precisa ser obtida por meio de derivação em cadeia:
$\frac{dL}{dw1} = \frac{dL}{dO}\frac{dO}{dX}\frac{dX}{dw1}$
Em ordem, são a derivada parcial da função de perda para a saída (relacionada à definição da função de perda), a derivada parcial da função de ativação, e a última é a derivação da função de acumulação ponderada (w1* out1+w2*out2+w3* out3, o resultado da derivada é out1). A multiplicação cumulativa dos três é a derivada parcial da função de perda em relação a um determinado parâmetro. Cada neurônio atualiza seus parâmetros de acordo e, nesse processo, o erro também se propaga camada por camada, da extremidade de saída até a extremidade de entrada. E quando há vários caminhos para propagação de erros, os neurônios também receberão erros de múltiplas direções e ajustarão parâmetros quando os erros forem retropropagados.

Insira a descrição da imagem aqui

2. Rede Neural Convolucional CNN

Rede neural convolucional CNN é um tipo de rede neural artificial e é frequentemente usada para reconhecimento de imagens. Uma rede neural convolucional é um perceptron multicamadas que reconhece formas bidimensionais e é invariante à translação, dimensionamento, rotação ou outras formas de transformação.

A ideia central da rede neural convolucional é combinar as três estruturas de percepção local, compartilhamento de peso e redução da resolução para obter aprendizado de recursos para redução da dimensionalidade da imagem. As redes neurais convolucionais geralmente têm múltiplas convoluções e agrupam camadas ocultas para extração de recursos e redução de dimensionalidade.

convolução

A convolução varre a imagem da esquerda para a direita e de cima para baixo por meio de uma janela deslizante ponderada (chamada de kernel de convolução). Executa um produto de matriz interna do valor da janela e da parte coberta da imagem. O resultado final calculado é chamado de mapa de características. O mapa de recursos reflete a semelhança entre cada parte do tamanho do kernel de convolução e o kernel de convolução. A convolução leva em consideração que o recurso representa apenas uma pequena parte da imagem ao extrair recursos, e o mesmo recurso pode aparecer em locais diferentes em imagens diferentes. O valor do kernel de convolução é obtido treinando o modelo.

Agrupamento

O objetivo do pooling é reduzir a dimensão dos recursos agregando estatísticas sobre recursos em diferentes locais. Existem muitos métodos de agregação, incluindo pooling médio e pooling máximo.

Insira a descrição da imagem aqui

Camada totalmente conectada

A rede neural convolucional usa conexões locais entre as camadas superior e inferior para construir a rede, simulando o fenômeno de que as células nervosas respondem apenas a áreas locais. Mas após convolução e pooling, o resultado final geralmente é obtido através de uma camada totalmente conectada. A rede neural totalmente conectada significa que para a camada n e a camada n-1, qualquer nó na camada n-1 está conectado a todos os nós da enésima camada.

Insira a descrição da imagem aqui

rede neural convolucional

Ao combinar camadas convolucionais, camadas de pool e redes totalmente conectadas, você pode obter uma rede neural convolucional completa. Normalmente, existem muitas camadas de convolução e agrupamento para extrair recursos de níveis baixos a altos e, finalmente, classificar por meio de uma rede neural totalmente conectada.

Insira a descrição da imagem aqui

3. Rede Neural Recorrente RNN

Redes neurais recorrentes são comumente usadas no processamento de linguagem natural. A característica do processamento da linguagem é que existe associação contextual, portanto a rede neural deve estabelecer uma relação temporal. Na rede neural RNN, cada neurônio recebe a entrada atual e a saída anterior e trabalha em conjunto para calcular o resultado da saída. Redes neurais recorrentes são geralmente usadas para extrair recursos e, finalmente, a saída desejada é alcançada por meio de camadas totalmente conectadas.

Insira a descrição da imagem aqui

3. Conteúdo experimental

Keras é uma estrutura de aprendizado profundo que encapsula muitos módulos de redes neurais de alto nível, incluindo camadas totalmente conectadas, camadas convolucionais, etc. O conteúdo deste experimento é todo implementado com base em Keras.

1.Keras constrói CNN/RNN

Construir CNN

Keras fornece algumas interfaces simples para construir rapidamente redes neurais convolucionais. Proceda da seguinte forma:

Instanciar um objeto Sequencial (modelo)
Adicione camadas ao modelo uma por uma. Para CNN, adicione camadas convolucionais, camadas de pooling, camadas totalmente conectadas, etc.
Compile o modelo, especifique a função de perda, método de atualização de parâmetros, etc.
Use a função fit para passar o conjunto de treinamento para treinamento e defina o número de iterações de treinamento e o número de lotes.
Use o modelo treinado para fazer previsões

Um exemplo de criação de um modelo é o seguinte:

    model = keras.Sequential()
    model.add(Conv2D(32, kernel_size=3, activation='relu', input_shape=[IMAGE_HEIGHT, IMAGE_WIDTH, 3]))
    model.add(MaxPooling2D(pool_size=2))
    model.add(Conv2D(32, kernel_size=3, activation='relu'))
    model.add(MaxPooling2D(pool_size=2))
    model.add(Flatten())
    model.add(Dense(96, activation='relu'))
    model.add(Dense(2, activation='softmax'))

Este modelo contém duas camadas convolucionais. Cada camada convolucional é seguida por uma camada de pooling e depois conectada a uma camada de achatamento. A função da camada de achatamento é converter a entrada multidimensional em uma dimensão e é usada a partir da camada convolucional para a camada completa.A transição da camada de conexão finalmente conecta as duas camadas totalmente conectadas e produz o resultado.

O resultado deste modelo é um vetor de dois bits. Este modelo é usado para problemas de classificação. Como existem duas categorias de imagens, existem dois valores no final. Esses dois valores são a probabilidade de a imagem pertencer a uma das categorias. Aquela com maior probabilidade é selecionado como o resultado da classificação. A saída alvo durante o treinamento também deve ser convertida para este formato, chamado codificação onehot , onde o valor categórico é mapeado para um valor inteiro, o valor inteiro é representado como um vetor binário e então treinado.

Insira a descrição da imagem aqui

Construir RNN

Semelhante à construção da CNN, o processo de construção da RNN em Keras também é muito simples:

model = Sequential()
# 对输入的影评进行word embedding，一般对于自然语言处理问题需要进行word embedding
model.add(Embedding(1000, 64))
# 构建一层有40个神经元的RNN层
model.add(SimpleRNN(40))
# 将RNN层的输出接到只有一个神经元全连接层
model.add(Dense(1, activation='sigmoid'))

Existe uma camada de incorporação. Esta camada implementa o mapeamento do espaço semântico para o espaço vetorial, converte cada palavra em um vetor de dimensões fixas e converte duas palavras com semântica próxima em vetores. A similaridade dos dois vetores O grau também é alto .

2. Reconhecimento facial baseado em Keras

O conjunto de dados usado no experimento consiste em várias imagens em tons de cinza com resolução de 284 * 286 e é rotulado como BioID_xxxx.pgm. A plataforma os converte para o formato JPG e xxxx é o índice. Existem 16 tipos de caracteres, representados pelas letras AV. Cada personagem tem de 20 a 50 amostras.

Ler dados

Para construir um modelo de classificação de imagens, as informações da imagem devem ser divididas em duas partes, uma é a informação do pixel da própria imagem e a outra é a informação da categoria da imagem. As informações da imagem lidas usando OpenCv são lidas na ordem BGR e precisam ser convertidas para RGB, e a imagem deve ser cortada em um tamanho uniforme.

Carregando imagens:

def load_pictures():
    pics = []
    labels = []
    for key, v in map_characters.items():
        pictures = [k for k in glob.glob(imgsPath + "/" + v + "/*")]
        for pic in pictures:
            img = cv2.imread(pic)
            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
            img = cv2.resize(img, (img_width, img_height))
            pics.append(img)
            labels.append(key)
    return np.array(pics), np.array(labels)

Entre eles, map_characters armazena o mapeamento de categorias de caracteres para valores numéricos, e AV é mapeado para 0-15 como a informação do rótulo de categoria da imagem. Essas informações também precisam ser convertidas em codificação OneHot, que é concluída ao dividir o conjunto de treinamento e o conjunto de validação.

Divida o conjunto de treinamento e o conjunto de teste e a proporção do conjunto de teste será 0,15.

def get_dataset():
    X, Y = load_pictures()
    Y = keras.utils.to_categorical(Y, num_classes)	#转为OneHot编码
    X_train, X_test = train_test_split(X, test_size=0.15)
    y_train, y_test = train_test_split(Y, test_size=0.15)
    return X_train, X_test, y_train, y_test

Modelo de construção

O modelo CNN construído no experimento possui 6 camadas convolucionais com função de ativação ReLU e uma camada oculta totalmente conectada. Após cada duas camadas convolucionais, há uma camada de pooling para reduzir parâmetros e uma camada de Dropout para evitar overfitting. , descarte parte do saída da camada de pooling. A camada de saída final mostra a probabilidade de a imagem pertencer a cada categoria.

def create_model_six_conv(input_shape):
    # ********** Begin *********#
    model = Sequential()
    model.add(Conv2D(32, (3, 3), activation='relu', input_shape=input_shape))
    #特征提取
    model.add(Conv2D(32, (3, 3), activation='relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.2))
    #特征提取
    model.add(Conv2D(64, (3, 3),  activation='relu'))
    model.add(Conv2D(64, (3, 3), activation='relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.2))
    #特征提取
    model.add(Conv2D(128, (3, 3), activation='relu'))
    model.add(Conv2D(128, (3, 3), activation='relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.2))
    #经过扁平层和全连接层，最终在输出层输出结果
    model.add(Flatten())						#扁平层进行降维
    model.add(Dense(1024, activation='relu'))
    model.add(Dropout(0.5))
    model.add(Dense(num_classes, activation='softmax'))
    return model;

Treinamento de modelo

Alguns parâmetros precisam ser definidos antes de iniciar o treinamento do modelo. Inclui principalmente as seguintes partes:

Otimizador: O modelo é treinado usando o algoritmo estocástico de descida de gradiente. Os parâmetros relevantes do otimizador são:
- Taxa de aprendizagem lr: parâmetro para ajustar parâmetros no método de descida gradiente
- Decaimento: um número de ponto flutuante maior ou igual a 0, o valor de decaimento da taxa de aprendizagem após cada atualização
- nesterov: valor booleano que determina se deve usar o momento Nesterov (métodos de momento podem acelerar o aprendizado (acelerar a descida do gradiente), especialmente ao lidar com alta curvatura, gradientes pequenos, mas consistentes ou gradientes ruidosos. Algoritmos de momento acumulam gradientes anteriores Uma média móvel que decai exponencialmente e continua a se mover nessa direção). Durante o teste, constatou-se que, se não for utilizado, um modelo com precisão suficientemente alta não poderá ser obtido dentro do tempo limitado de treinamento.
- momentum: um número de ponto flutuante que é grande ou igual a 0, parâmetro momentum
perda: função de perda. Para problemas de classificação, você pode usar a função de perda de entropia cruzada (categorical_crossentropy)
métricas: indicadores de desempenho, usando precisão
batch_size: o número de dados de amostra usados em um treinamento
épocas: rodadas de treinamento

Durante o processo de treinamento, a taxa de aprendizado de ajuste de peso pode ser atenuada à medida que aumenta o número de ciclos de treinamento. A taxa de aprendizagem pode ser reduzida imediatamente após manter uma taxa de aprendizagem constante por um período de tempo, usando um método do módulo de retornos de chamada LearningRateScheduler $^{[1]}$ Implementação:

def lr_schedule(epoch):
    initial_lrate = 0.01
	drop = 0.5
	epochs_drop = 10.0
	lrate = initial_lrate * math.pow(drop, math.floor((1+epoch)/epochs_drop))
	return lrate

Além disso, para garantir que o treinamento de longo prazo possa ser salvo no meio do teste, os pontos de salvamento do módulo de retorno de chamada são usados para armazenar os pesos do modelo e salvar o melhor modelo.

lr = 0.01
sgd = SGD(lr=lr, decay=0.0 , momentum=0.9 , nesterov= True)
model.compile(loss= 'categorical_crossentropy' ,
         optimizer= sgd,
         metrics=['accuracy'] )

def lr_schedule(epoch):
    lr = 0.01
	drop = 0.5
	epochs_drop = 10.0
	lrate = lr * math.pow(drop, math.floor((1+epoch)/epochs_drop))
	return lrate

batch_size = 32
epochs = 20

filepath = "model.h5"

history = model.fit(X_train, y_train,  
    batch_size=batch_size,  
    epochs=epochs,  
    validation_data=(X_test, y_test),  
    shuffle=True,  						#打乱数据集
    verbose = 0,  
    callbacks=[LearningRateScheduler(lr_schedule),  
        ModelCheckpoint(filepath, save_best_only=True)])

Validação e avaliação

Depois de treinar o modelo, você pode testá-lo. A leitura dos dados de teste é semelhante à leitura dos dados durante o treinamento. Ele contém as informações do pixel e o rótulo da imagem, e o rótulo é convertido em codificação onehot.

imgsPath = "/opt/test/"
def load_test_set(path):
    pics, labels = [], []
    map_characters = {
    
    0: 'A', 1: 'C', 2: 'D',
        3: 'F', 4: 'G', 5: 'H', 6: 'I',
        7: 'J', 8: 'K', 9: 'L', 10:'M',
        11:'P', 12:'R', 13:'S', 14:'T', 15:'V'}
    num_classes = len(map_characters)
    img_width = 42
    img_height = 42
    map_characters = {
    
    v:k for k,v in map_characters.items()}
    for pic in glob.glob(path+'*.*'): 
        name = "".join(os.path.basename(pic).split('_')[0]) 
        if name in map_characters:  
            img = cv2.imread(pic)  
            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  
            img = cv2.resize(img, (img_height,img_width)).astype('float32') / 255.  
            pics.append(img)  
            labels.append(map_characters[name])
    X_test = np.array(pics)  
    y_test = np.array(labels)  
    y_test = keras.utils.to_categorical(y_test, num_classes) # one-hot编码  
    return X_test, y_test

Depois de carregar os dados de teste, carregue o modelo treinado, use o modelo para classificar os dados de teste e compare os resultados da classificação com as categorias corretas para calcular a precisão do teste do modelo.

def acc():  
    model = load_model("model.h5")
    # 预测与对比  
    y_pred = model.predict_classes(X_valtest)  
    acc = np.sum(y_pred==np.argmax(y_valtest, axis=1))/np.size(y_pred)  
    return(acc)

Insira a descrição da imagem aqui

3. Questões para reflexão - O impacto das configurações dos parâmetros do algoritmo de aprendizagem profunda no desempenho do algoritmo

Os hiperparâmetros no aprendizado profundo são a chave para controlar a estrutura do modelo, a eficiência do treinamento e o efeito do treinamento. Os hiperparâmetros comuns e seu impacto no treinamento do modelo são os seguintes:

Taxa de aprendizagem: determina quanto os pesos dos parâmetros são atualizados no algoritmo de otimização. A taxa de aprendizagem pode ser constante, diminuindo gradualmente, baseada no impulso, etc. $^{[2]}$ . O valor da taxa de aprendizagem deve ser definido dentro de uma faixa apropriada. Se for muito pequeno, reduzirá a velocidade de convergência e aumentará o tempo de treinamento. Se for muito grande, poderá fazer com que os parâmetros oscilem em ambos os lados do solução ótima. A taxa de aprendizagem pode ser ajustada dinamicamente, geralmente é maior no início e diminui à medida que o número de iterações aumenta para melhorar a estabilidade.
Número de iterações (Época): O número de vezes de treinamento. Se o número de vezes for muito pequeno, o efeito do treinamento pode não ser bom o suficiente. Se o número de vezes for muito grande, pode levar a um overfitting.
O número de amostras selecionadas para um treinamento (tamanho do lote): afeta o tempo de treinamento. Se for muito pequeno, pode haver oscilação do gradiente. Se for muito grande, o gradiente será preciso e a convergência será rápida, mas não cair facilmente no ótimo local.
Otimizador: os mais comuns incluem SGD (descida gradiente estocástica), Adagrad (descida gradiente adaptativa), parâmetros diferentes têm taxas de aprendizagem diferentes $^{[3]}$ ) etc.
Função de ativação: Para aumentar a não linearidade do modelo de rede neural, uma função de ativação apropriada deve ser selecionada de acordo com o problema específico.
Função de perda: afeta a velocidade de convergência e o desempenho geral do modelo. As funções de perda comumente usadas em modelos de regressão incluem função de perda quadrática média MSE, perda suave L1 Huber, erro médio absoluto MAE e função de perda de entropia cruzada comumente usada em problemas de classificação.

Referências

[1] Documentação da EQUIPE K. Keras: LearningRateScheduler[EB/OL]//keras.io. https://keras.io/api/callbacks/learning_rate_scheduler/.

[2] Hiperparâmetros em aprendizagem profunda e seu impacto no treinamento do modelo_O impacto dos hiperparâmetros do modelo rnn_weixin_41783077's blog-CSDN blog [EB/OL]//blog.csdn.net. [2023-05-28] . https://blog.csdn .net/weixin_41783077/article/details/104022476.

[3] Ajuste de hiperparâmetros em aprendizagem profunda (taxa de aprendizagem, épocas, tamanho do lote...) [EB/OL]//coluna Zhihu. [2023-05-28]. https://zhuanlan.zhihu.com/ p /433836153.ng_rate_scheduler
/.

[3] Ajuste de hiperparâmetros em aprendizagem profunda (taxa de aprendizagem, épocas, tamanho do lote...) [EB/OL]//coluna Zhihu. [2023-05-28]. https://zhuanlan.zhihu.com/ p /433836153.