🙄 👼🏻 🌧️ Reduza o tamanho do modelo ML sem registro e SMS 🤱🏾 👵🏼 💂🏼

Qualquer pessoa que encontre aprendizado de máquina entende que isso requer um poder de computação sério. Neste artigo, tentaremos aplicar o algoritmo desenvolvido no MIT para comprimir uma rede neural, o que reduzirá a dimensão dos pesos do modelo treinado e levará ao aprendizado mais rápido e ao lançamento mais rápido do modelo.

As redes neurais provaram ser uma excelente ferramenta para resolver uma grande variedade de tarefas, mas, infelizmente, seu uso requer um poder computacional significativo, que ainda pode não estar em uma pequena empresa. Existem muitos tipos de compressão de redes neurais que podem ser divididas em hardware, de baixo nível e matemáticas, mas este artigo discutirá o método desenvolvido no MIT em 2019 e trabalhando diretamente com a própria rede neural.

Este método é chamado de "Hipótese do Bilhete Vencedor". Em termos gerais, soa assim: Qualquer rede neural totalmente conectada com pesos inicializados aleatoriamente contém uma sub-rede com os mesmos pesos, e essa sub-rede treinada separadamente pode ser igual em precisão à rede original.

Prova formal e artigo completo podem ser encontrados aqui . Estamos interessados na possibilidade de aplicação prática. Em resumo, o algoritmo é o seguinte:

Criamos um modelo, inicializamos aleatoriamente seus parâmetros
Aprendendo uma rede de iterações j
Cortamos os parâmetros de rede que possuem o menor valor (a tarefa mais simples é definir algum valor limite)
Redefinimos os parâmetros restantes para seus valores iniciais, obtemos a sub-rede que precisamos.

Em teoria, esse algoritmo precisa ser repetido o enésimo número de etapas, mas, por exemplo, realizaremos apenas uma iteração. Crie uma rede totalmente conectada simples usando o tensorflow e o Keras:

import tensorflow as tf
from tensorflow import keras

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(300, activation='relu'),
    keras.layers.Dense(150, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='SGD',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

Obteremos a seguinte arquitetura de rede:

E a treinaremos no conjunto de dados de moda MNIST de 60.000 imagens. Sua precisão nos dados de verificação será igual a 0,8594. Aplicamos aos parâmetros da iteração da rede 1 deste algoritmo. No código, fica assim:

#  
threshold = 0.001

#       np.array
weights = model.weights
weights = np.asarray(weights)

#    
first_h_layer_weights = weights[1]
second_h_layer_weights = weights[3]

def delete_from_layers(one_d_array, threshold):
    index = []
    for i in range(one_d_array.shape[0]):
        #   ,       
        if abs(one_d_array[i]) <= threshold:
            index.append(i)
    #    ,   
    new_layer = np.delete(one_d_array, index)
    return new_layer

new_layer_weights = delete_from_layers(second_h_layer_weights, threshold)

Assim, depois de executar esse código, nos livraremos de pesos praticamente não utilizados. Duas coisas são dignas de nota: neste exemplo, o limite foi escolhido empiricamente e esse algoritmo não pode ser aplicado aos pesos das camadas de entrada e saída.

Após receber novos pesos, é necessário redefinir o modelo original, removendo o excesso. Como resultado, obtemos:

Você pode notar que o número total de parâmetros diminuiu quase duas vezes, o que significa que, ao treinar a primeira rede, mais da metade dos parâmetros era simplesmente desnecessário. Ao mesmo tempo, a precisão da sub-rede é de 0,8554, um pouco mais baixa que a rede principal. Obviamente, este exemplo é indicativo, geralmente a rede pode ser reduzida em 10-20% do número inicial de parâmetros. Aqui, mesmo sem aplicar esse algoritmo, fica claro que a arquitetura original foi escolhida muito complicada.

Em conclusão, podemos dizer que esta técnica não está bem desenvolvida no momento e, em tarefas reais, uma tentativa de otimizar os pesos do modelo dessa maneira pode apenas prolongar o processo de aprendizado, mas o próprio algoritmo tem muito potencial.

Reduza o tamanho do modelo ML sem registro e SMS

More articles: