Construindo um Cérebro em 10 Minutos. Texto 2
Texto 2 — Introdução à redes neurais e aprendizado profundo
Esta atividade foi criada pelo Instituto de Deep Learning da Nvidia. Realizei a tradução e a incluí no blog como uma excelente oportunidade de aprendizado e aquisição de conhecimento no campo do aprendizado profundo.
Muitas décadas atrás, redes neurais artificiais foram desenvolvidas para imitar as capacidades de aprendizagem de humanos e animais. Abaixo está um trecho de A Máquina que Mudou o Mundo, um documentário de 1992 sobre Inteligência Artificial.
from IPython.display import YouTubeVideo
YouTubeVideo('cNxadbrN_aI')Desde então, os computadores e as bibliotecas de aprendizado de máquina evoluíram a ponto de podermos replicar muitos dias de experimentação em apenas alguns minutos. Neste caderno, veremos como as redes neurais artificiais melhoraram ao longo dos anos e a inspiração biológica por trás delas.
Para demonstrar, usaremos o TensorFlow, uma biblioteca de aprendizado de máquina de código aberto popular na indústria. Versões recentes do TensorFlow detectam automaticamente se há uma GPU disponível para computação.
import tensorflow as tf
tf.config.list_physical_devices('GPU')As GPUs foram originalmente projetadas para a quantidade significativa de matemática matricial usada na renderização de gráficos de computador. As redes neurais também exigem uma quantidade significativa de multiplicação de matrizes, tornando as GPUs uma boa opção para construí-las.
Dados
Falando em gráficos, vamos enfrentar um desafio que parecia quase impossível décadas atrás: classificação de imagens com visão computacional. Especificamente, tentaremos classificar peças de vestuário do conjunto de dados Fashion MNIST. Alguns exemplos são mostrados abaixo:
As redes neurais tentam copiar a técnica de aprendizagem humana, Tentativa e Erro. Para fazer isso, criaremos algo como um conjunto de flashcards digitais. Nossos cérebros artificiais tentarão adivinhar que tipo de roupa estamos mostrando com um flashcard, então daremos a resposta, ajudando o computador a aprender com seus acertos e erros.
Assim como os alunos são questionados para testar sua compreensão, reservaremos uma parte de nossos dados para testar nossas redes neurais e garantir que eles entendam os conceitos que estamos tentando ensinar-lhes, em vez de memorizarem as respostas de seus estudos. questões. Para curiosidades, a memorização pode ser uma estratégia aceitável, mas para habilidades, como somar dois números, a memorização não levará nossos modelos muito longe.
Os dados do estudo costumam ser chamados de conjunto de dados de treinamento e os dados do questionário costumam ser chamados de conjunto de dados de validação. Como o Fashion MNIST é um conjunto de dados popular, ele já está incluído na biblioteca TensorFlow. Vamos carregá-lo em nosso ambiente de codificação e dar uma olhada nele.
fashion_mnist = tf.keras.datasets.fashion_mnist
(train_images, train_labels), (valid_images, valid_labels) = fashion_mnist.load_data()Vamos começar com nossos train_images e train_labels. train_images são como a pergunta em nossos flashcards e train_labels são como a resposta. Em geral, os cientistas de dados costumam se referir a esta resposta como rótulo.
Podemos plotar uma dessas imagens para ver como ela é. Para fazer isso, usaremos Matplotlib.
import matplotlib.pyplot as plt
# The question number to study with. Feel free to change up to 59999.
data_idx = 42
plt.figure()
plt.imshow(train_images[data_idx], cmap='gray')
plt.colorbar()
plt.grid(False)
plt.show()O resultado da plotagem segue abaixo:
Como você classificaria isso? Para facilitar, aqui estão as dez categorias que poderia ser:
Tem uma resposta? Execute a seguinte célula de código para ver se você estava correto:
train_labels[data_idx]A resposta é número 9 Ankle boot.
Como você fez? Bom trabalho se você acertou!
Nossos dados de validação têm uma estrutura semelhante de perguntas e respostas:
import matplotlib.pyplot as plt
# The question number to quiz with. Feel free to change up to 9999.
data_idx = 6174
plt.figure()
plt.imshow(valid_images[data_idx], cmap='gray')
plt.colorbar()
plt.grid(False)
plt.show()
valid_labels[data_idx]A resposta é número 7 Sneaker.
Construindo um Neurônio
Os neurônios são os blocos de construção fundamentais de uma rede neural. Assim como os neurônios biológicos enviam um impulso elétrico sob estímulos específicos, as redes neurais artificiais resultam de forma semelhante em uma saída numérica com uma determinada entrada numérica.
Podemos dividir a construção de um neurônio em 3 etapas:
- Definindo a arquitetura
- Iniciando treinamento
- Avaliando o modelo
Definindo a arquitetura
Neurônios biológicos transmitem informações com um mecanismo semelhante ao Código Morse. Eles recebem sinais elétricos através das dendrites, e sob as condições certas, enviam um impulso elétrico pelo axônio e para fora através dos terminais.
Teoriza-se que a sequência e o tempo desses impulsos desempenham uma grande parte de como as informações viajam pelo cérebro. A maioria das redes neurais artificiais ainda não conseguiu capturar esse aspecto do tempo dos neurônios biológicos, e, em vez disso, emulam o fenômeno com fórmulas matemáticas mais simples.
A Matemática
Computadores são construídos com 0s e 1s discretos enquanto seres humanos e animais são construídos em blocos mais contínuos. Por causa disso, alguns dos primeiros neurônios tentaram imitar neurônios biológicos com uma função de regressão linear: y = mx + b. O x é como a informação que entra através das dendrites e o y é como a saída através dos terminais. À medida que o computador adivinha cada vez mais respostas para as perguntas que apresentamos, ele atualizará suas variáveis (m e b) para melhor ajustar a linha aos dados que viu.
Neurônios são frequentemente expostos a dados multivariados. Vamos construir um neurônio que leva cada valor de pixel (que está entre 0 e 255), e atribui-lhe um peso, que é equivalente ao nosso m. Cientistas de dados frequentemente expressam esse peso como w. Por exemplo, o primeiro pixel terá um peso de w0, o segundo terá um peso de w1, e assim por diante. Nossa equação completa se torna y = w0x0 + w1x1 + w2x2 + … + b.
Cada imagem tem 28 pixels por 28 pixels, então teremos um total de 784 pesos. Um valor de pixel de 0 seria preto e um valor de pixel de 255 seria branco. Vamos olhar para os valores de pixels brutos da imagem anterior que plotamos. Cada número abaixo será atribuído um peso.
# 28 lists with 28 values each
valid_images[data_idx]Mais uma coisa para pensar: a saída de y = mx + b é um número, mas aqui, estamos tentando classificar diferentes artigos de vestuário. Como podemos converter números em categorias?
Aqui está uma abordagem simples: podemos fazer dez neurônios, um para cada artigo de vestuário. Se o neurônio atribuído a “Calças” (etiqueta #1), tiver a maior saída comparada aos outros neurônios, o modelo vai adivinhar “Calças” para a imagem de entrada dada.
Keras, uma framework de aprendizado profundo que foi integrada ao TensorFlow, torna tal modelo fácil de construir. Usaremos a API Sequencial, que nos permite empilhar camadas, a lista de operações que estaremos aplicando aos nossos dados conforme são alimentados pela rede.
No modelo abaixo, temos duas camadas:
- Flatten — Converte dados multidimensionais em dados unidimensionais (ex: uma lista de listas em uma única lista).
- Dense — Uma “linha” de neurônios. Cada neurônio tem um peso (
w) para cada entrada. No exemplo abaixo, usamos o número10para colocar dez neurônios.
Também definiremos um input_shape que são as dimensões dos nossos dados. Neste caso, nossos 28x28 pixels para cada imagem.
number_of_classes = train_labels.max() + 1
number_of_classesmodel = tf.keras.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(number_of_classes)
])Verificando o modelo
Para garantir que nosso modelo tenha a estrutura que esperamos, podemos chamar o método summary.
model.summary()
Podemos ver que nosso total de parâmetros é 7850. Vamos ver se isso faz sentido. Para cada pixel, deve haver um peso para cada uma das nossas dez classes.
image_height = 28
image_width = 28
number_of_weights = image_height * image_width * number_of_classes
number_of_weightsEntão, nossos pesos compõem 7.840 parâmetros. De onde vêm os outros dez? São os viéses de cada um dos 10 neurônios, o b em y = mx + b.
Existem algumas outras maneiras de verificar nosso modelo. Também podemos plotá-lo:
tf.keras.utils.plot_model(model, show_shapes=True)
Em artigos acadêmicos, os modelos são frequentemente representados como na imagem abaixo.
Na prática, as redes neurais modernas são tão grandes que é impraticável grafá-las desta maneira. O abaixo é uma fração de nosso modelo inteiro. Há 10 neurônios na parte inferior representando cada uma de nossas dez classes, e 28 nós de entrada na parte superior, representando uma fileira de nossos pixels. Na realidade, a camada superior é 28 vezes maior!
Cada círculo representa um neurônio ou uma entrada, e cada linha representa um peso. A imagem abaixo foi criada com uma ferramenta por Alex Lenail.
Iniciar Treinamento
Temos um modelo configurado, mas como ele aprende? Assim como os alunos são avaliados quando fazem um teste, precisamos dar ao modelo uma função para avaliar seu desempenho. Tal função é chamada de função de perda (loss).
Neste caso, vamos usar um tipo de função específico para classificação chamado SparseCategoricalCrossentropy:
- Sparse — para esta função, refere-se a como nosso rótulo é um índice inteiro para nossas categorias
- Categorical — esta função foi feita para classificação
- Cross-entropy — quanto mais confiante nosso modelo estiver quando fizer um palpite incorreto, pior será sua pontuação. Se um modelo estiver 100% confiante quando estiver errado, ele terá uma pontuação de menos infinito!
from_logits- a saída linear será transformada em uma probabilidade que pode ser interpretada como a confiança do modelo de que uma categoria particular é a correta para a entrada dada.
Este tipo de função de perda funciona bem para o nosso caso porque ela avalia cada um dos neurônios simultaneamente. Se todos os nossos neurônios derem um sinal forte de que são o rótulo correto, precisamos de uma maneira de dizer a eles que não podem todos estar certos.
Para nós, humanos, podemos adicionar métricas adicionais para monitorar o quão bem nosso modelo está aprendendo. Por exemplo, talvez a perda esteja baixa, mas e se a acurácia não for alta?
model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])Avaliando o modelo
Agora, o momento da verdade! O método fit abaixo ajudará tanto no estudo quanto na avaliação do nosso modelo.
Uma época é uma revisão completa do conjunto de dados de treinamento. Assim como os estudantes podem precisar revisar um flashcard várias vezes antes que o conceito "faça clique", o mesmo acontece com nossos modelos.
Após cada época, o modelo é testado com os dados de validação. Vamos observá-lo trabalhar duro e melhorar:
history = model.fit(
train_images,
train_labels,
epochs=5,
verbose=True,
validation_data=(valid_images, valid_labels)
)
Como o modelo se saiu? B-? Para dar-lhe crédito, ele só tinha 10 neurônios para trabalhar. Nós, humanos, temos bilhões!
A precisão deve estar em torno de 80%, embora haja alguma variação aleatória com base em como os flashcards são embaralhados e o valor aleatório dos pesos que foram iniciados.
Previsão
Hora de graduar nosso modelo e deixá-lo entrar no mundo real. Podemos usar o método predict para ver a saída do nosso modelo em um conjunto de imagens, independentemente de estarem ou não nos conjuntos de dados originais.
Por favor, note, Keras espera um lote, ou múltiplos pontos de dados, ao fazer uma previsão. Para fazer uma previsão em um único ponto de dados, ele deve ser convertido em um lote de um ponto de dados.
Abaixo estão as previsões para os primeiros dez itens em nosso conjunto de dados de treinamento.
model.predict(train_images[0:10])
Esses são resultados brutos e precisam de algum formato para serem interpretados pelo humano médio, então, abaixo, exibimos uma imagem a ser classificada bem como graficamos os resultados de cada um dos nossos neurônios de saída. Quanto maior o valor, mais confiante o neurônio está de que corresponde ao rótulo correto (e quanto mais negativo for, mais confiante ele está de que não é o rótulo correto).
Altere o data_idx abaixo para ver como o modelo prevê contra várias imagens. O que você acha que ele fez? Para as previsões que ele errou, você também teria ficado confuso?
Aqui está a tabela novamente para referência:
data_idx = 8675 # The question number to study with. Feel free to change up to 59999.
plt.figure()
plt.imshow(train_images[data_idx], cmap='gray')
plt.colorbar()
plt.grid(False)
plt.show()
x_values = range(number_of_classes)
plt.figure()
plt.bar(x_values, model.predict(train_images[data_idx:data_idx+1]).flatten())
plt.xticks(range(10))
plt.show()
print("correct answer:", train_labels[data_idx])
Conclusão
Parabéns por completar o caderno! Embora este modelo faça significativamente melhor do que adivinhação aleatória, ainda tem um caminho a percorrer antes de poder superar humanos no reconhecimento de vestuário.
Eliéser Ribeiro Linkedin
Curso de Introdução à redes neurais e aprendizado profundo
Texto 1 — Analisando o contexto e fazendo uma analogia para entender IA, aprendizado de máquina, redes neurais e aprendizado profundo. Link.
Texto 2 — Construindo um cérebro em 10 minutos
Mais textos do autor no Medium:
.Inteligência Artificial além da IA gerativa: Compreendendo abordagens e aplicações inovadoras. Clique aqui.
.Estratégia para as empresas se prepararem para a era da INTELIGÊNCIA ARTIFICIAL. Clique aqui
· CRIATIVIDADE: A grande fronteira que separa os humanos da inteligência artificial. Clique aqui.
. Desvendando a IA generativa. Clique aqui.
. Qual o mecanismo de funcionamento do ChatGPT? Clique aqui
. Desvendado o algoritmo de navegação Clique aqui
· 6 coisas que não te falam sobre startups que fracassaram Clique aqui
· Salvando o futuro Clique aqui
