1. Introdução
Na aula de Redes Neurais, vimos que a rede aprende ajustando pesos e vieses até a perda diminuir. Só que, antes de apertar o botão de treinar, alguém tem que decidir várias coisas: quantos neurônios usar, quantas camadas, o tamanho do passo do gradiente descendente, por quantas épocas treinar… A rede não escolhe isso sozinha. Quem escolhe somos nós.
Por isso, separamos dois tipos de valores:
| Tipo | Quem define | Exemplos |
|---|---|---|
| Parâmetros | O treinamento, a partir dos dados | Pesos e vieses |
| Hiperparâmetros | Nós, antes de treinar | Taxa de aprendizado, número de neurônios e de camadas, número de épocas, função de ativação, tamanho do batch |
Infelizmente, não existe uma regra que diga quais hiperparâmetros usar em cada problema. O jeito é testar e comparar, e a intuição vem de ver muitos treinos acontecendo. Então, em vez de só descrever o efeito de cada um, fiz um simulador com uma rede neural de verdade, que treina aqui mesmo no navegador, para vocês mexerem à vontade.
2. O simulador
O problema é uma classificação com duas classes. Cada ponto tem duas coordenadas, x₁ e x₂, e é azul ou laranja. A rede recebe as coordenadas e devolve a probabilidade de o ponto ser azul.
O fundo do quadro mostra o que a rede prevê em cada região. Quanto mais forte a cor, mais confiante ela está, e a linha onde as duas cores se encontram é a fronteira de decisão. Os pontos cheios são os de treino, que a rede usa para ajustar os pesos. Os vazados são de teste. A rede nunca os vê durante o treino, e eles servem para descobrir se ela aprendeu o padrão ou só decorou os exemplos. Ao lado, o diagrama mostra os pesos (quanto mais grossa a linha, maior o peso; azul é positivo, laranja é negativo), e embaixo fica a curva de perda.
Simulador de rede neural
A rede é treinada com gradiente descendente em mini-batches (10 exemplos, se você não mudar), e cada época passa uma vez pelos 240 pontos de treino. Os dados e os pesos iniciais vêm de uma semente fixa, então a mesma configuração sempre dá o mesmo resultado.
Comece pela configuração que já vem marcada e clique em Treinar. No início, a fronteira é praticamente aleatória e a perda fica perto de 0,69, que é o erro de quem chuta 50% para todo ponto. Depois de algumas dezenas de épocas, o círculo começa a aparecer e a perda cai.
Repare que qualquer mudança nos controles reinicia o treino. Fiz assim porque, para comparar duas escolhas de forma justa, cada uma tem que treinar a rede do zero.
Depois de ler as próximas seções, voltem aqui para resolver os desafios da seção 9. Todos eles usam este simulador.
3. Taxa de aprendizado
Na aula de Redes Neurais, a atualização de cada parâmetro θ era:
O gradiente aponta para onde a perda cresce, e a taxa de aprendizado η decide o tamanho do passo que damos no sentido contrário. Para enxergar só o efeito de η, vamos usar a perda mais simples que existe, L(w) = w², com um único peso. O mínimo fica em w = 0 e a derivada é 2w, então a atualização vira:
A cada passo, o peso é multiplicado por (1 − 2η). Começando em w = −2, arrastem o controle e vejam os 10 primeiros passos:
Gradiente descendente em L(w) = w²
Com η pequeno, o peso anda sempre na direção certa, mas devagar. Lá por 0,1 a 0,4, ele chega perto do mínimo em poucos passos. Entre 0,5 e 1, o passo fica grande o bastante para passar do mínimo, e o peso vai pulando de um lado para o outro enquanto se aproxima dele. Com η = 1 exato, ele fica pulando entre −2 e 2 para sempre. Acima de 1, cada passo o joga mais longe que o anterior, a perda cresce sem parar e dizemos que o treino diverge.
Esses limites de 0,5 e 1 só valem para essa parábola. Numa rede de verdade, a perda depende de centenas de pesos e tem um formato bem mais bagunçado, mas os mesmos comportamentos aparecem. Aqui estão três redes idênticas, com os mesmos dados e os mesmos pesos iniciais. A única diferença é η:
Mesma rede, três taxas de aprendizado
Círculo, uma camada oculta com 4 neurônios (tanh), 150 épocas. Na curva, valores acima de 1,5 aparecem presos no topo do gráfico.
Com η = 0,001, a rede quase não sai do lugar em 150 épocas. Com 0,3, ela acha o círculo rápido. Com 10, os passos são tão grandes que a perda fica pulando para valores altos e a rede nunca se acomoda.
Se quiserem ver os extremos no simulador principal:
4. Número de neurônios e de camadas
Numa rede com uma camada oculta e tanh, cada neurônio separa o plano em dois lados de uma reta. De um lado ele vale perto de −1, do outro perto de +1, e perto da reta a transição é suave. A saída da rede combina essas respostas. Com poucos neurônios, há poucas retas para combinar e a fronteira fica simples; com mais neurônios, ela pode ter formas bem mais complicadas. Essa flexibilidade se chama capacidade do modelo.
A espiral é um bom teste, já que as duas classes se enrolam uma na outra:
Espiral com 2, 4 e 8 neurônios na camada oculta
Uma camada oculta (tanh), η = 0,3, 250 épocas, mesmos dados para as três.
Com 2 neurônios, a perda trava e boa parte dos pontos continua errada, mesmo deixando a rede treinar bem mais. Quando o modelo é simples demais para o padrão dos dados, chamamos isso de underfitting. Com 8, a rede chega lá rápido.
O caso dos 4 neurônios é o mais curioso. Durante umas 80 épocas, a perda fica parada perto de 0,62 e parece que nada acontece; aí, entre a época 90 e a 120, ela despenca e a espiral aparece. Chamamos isso de platô. A rede está numa região quase plana da superfície de perda, onde o gradiente é tão pequeno que cada passo muda muito pouco os pesos, e vai se arrastando até achar uma direção em que a perda realmente desce. Por isso, perda parada nem sempre quer dizer que falta capacidade à rede. Às vezes ela só precisa de mais tempo, ou de outra taxa de aprendizado.
Outra forma de ganhar capacidade é empilhar camadas, porque a segunda camada pode combinar as divisões feitas pela primeira. Comparem na espiral:
Só que capacidade não vem de graça. No simulador, uma camada com 4 neurônios tem 17 parâmetros, e três camadas com 8 têm 177. Mais parâmetros significam mais conta para fazer e, como vamos ver agora, mais facilidade para a rede decorar os exemplos.
5. Número de épocas
Uma época é uma passada completa pelos dados de treino. Com poucas épocas, a rede para no meio do caminho. Com épocas demais, o problema é outro, e é aí que os pontos de teste fazem diferença.
A rede abaixo tem duas camadas com 8 neurônios e foi treinada por 800 épocas com só 60 pontos de treino. Os dados têm bastante ruído, então alguns pontos aparecem do lado errado do círculo. Arrastem o controle para andar pelo treino:
O mesmo treino, época por época
A perda no teste foi mínima na época — (ponto preto na curva). Depois disso, a perda no treino continua caindo, mas a perda no teste volta a subir.
Círculo com ruído, 60 pontos de treino, 400 de teste, duas camadas ocultas com 8 neurônios (tanh), η = 0,3.
No começo, as duas perdas caem juntas, porque a rede está aprendendo o formato geral do círculo. Em certo momento, a fronteira começa a se torcer para acertar cada ponto de treino, inclusive os que estão fora do lugar por causa do ruído. A perda no treino chega quase a zero, enquanto a rede passa a errar os pontos de teste com cada vez mais confiança. É o overfitting que apareceu no fim da aula de Redes Neurais.
Um jeito simples de evitar isso é acompanhar a perda em dados separados e parar quando ela para de melhorar, o chamado early stopping. Essa e outras técnicas estão na aula de Generalização e Regularização.
E o tamanho do batch?
Até aqui, a rede atualizou os pesos a cada grupo de 10 exemplos, o que dá 24 atualizações por época. Esse tamanho de grupo, o batch, também é um hiperparâmetro. Com batch 240, a rede olha todos os pontos e dá um único passo por época, então, com o mesmo η, ela aprende bem mais devagar por época. No círculo, com η = 0,3, ela ainda está em uns 83% de acurácia no teste depois de 300 épocas. No outro extremo, com batch 1, são 240 passos por época, só que cada um é calculado com um único ponto e a curva de perda fica bem mais tremida.
Na prática, o batch também depende do hardware. Uma GPU calcula os exemplos de um batch em paralelo, então batches maiores aproveitam melhor a máquina, e uma época com batch 1 acaba demorando muito mais no relógio, mesmo dando mais passos.
6. Testando com método
Mexer nos controles até “dar certo” funciona num simulador pequeno. Num problema real, em que um treino pode levar horas, alguns cuidados ajudam bastante.
O principal é mudar um hiperparâmetro por vez. Se você troca η e o número de neurônios juntos e o resultado melhora, não dá para saber qual das duas mudanças ajudou. Também é importante fixar a aleatoriedade. Os pesos iniciais e a ordem dos exemplos são sorteados e, sem uma semente fixa, parte da diferença entre dois treinos pode ser pura sorte. O simulador desta aula usa sempre a mesma semente justamente por isso.
Na hora de decidir qual configuração é melhor, olhem para a validação, não para o treino, já que uma perda de treino baixa não garante nada sobre dados novos. E, se não souberem por onde começar, comecem pela taxa de aprendizado, que costuma ser o hiperparâmetro de maior efeito. Por fim, anotem os testes numa tabela, o que ajuda a não repetir experimentos e a perceber tendências.
Quando há muitos hiperparâmetros, existem formas automáticas de fazer essa busca. A busca em grade (grid search) testa todas as combinações de uma lista de valores; a busca aleatória (random search) sorteia combinações e, com muitos hiperparâmetros, costuma achar boas configurações com menos treinos.
7. Além da acurácia
Até aqui, para dizer se uma configuração era melhor que outra, olhamos para a perda e para a acurácia, que é a fração de pontos que a rede acerta (a mesma usada no fim da aula de Regressão Logística). A acurácia é fácil de entender, mas pode enganar.
Pensem num exame que procura uma doença rara, que aparece em 1 de cada 100 pessoas. Um “modelo” que responde “saudável” para todo mundo acerta 99% das vezes e não serve para nada, porque não encontra nenhum doente. Quando uma classe é bem mais rara que a outra, só a acurácia não basta.
A matriz de confusão
Para olhar com mais cuidado, escolhemos uma das classes como a positiva, normalmente a que queremos encontrar (o doente, o e-mail de spam). Aqui, vai ser a azul. Cada previsão da rede cai em um destes quatro casos:
| A rede disse azul | A rede disse laranja | |
|---|---|---|
| Era azul | Verdadeiro positivo (VP) | Falso negativo (FN): o doente que o exame deixou passar |
| Era laranja | Falso positivo (FP): o alarme falso | Verdadeiro negativo (VN) |
Contando quantas previsões caem em cada caso, dá para calcular métricas que respondem perguntas diferentes:
| Métrica | Conta | Pergunta que responde |
|---|---|---|
| Acurácia | (VP + VN) / total | De todas as previsões, quantas estão certas? |
| Precisão | VP / (VP + FP) | Quando a rede diz “azul”, com que frequência ela acerta? |
| Recall (ou sensibilidade) | VP / (VP + FN) | De todos os azuis que existem, quantos a rede encontrou? |
Precisão e recall costumam puxar para lados opostos, e qual pesa mais depende do problema. Num exame de triagem, deixar um doente passar é pior que um alarme falso, então o recall importa mais. Num filtro de spam, mandar um e-mail importante para a lixeira é pior que deixar passar um spam, então a precisão importa mais.
O limiar de decisão
A rede não responde “azul” ou “laranja”: ela devolve uma probabilidade. Até agora, a regra foi dizer azul quando essa probabilidade passa de 0,5. Esse valor é o limiar de decisão, e ele pode ser mudado sem treinar a rede de novo. Baixar o limiar faz a rede dizer “azul” mais vezes, então ela encontra mais azuis (o recall sobe), mas também marca mais laranjas por engano (a precisão cai). Subir o limiar faz o contrário.
No interativo abaixo, a rede já foi treinada num problema em que as duas nuvens se misturam e só um quarto dos pontos é azul: no teste, são 40 azuis e 120 laranjas. Arrastem o limiar e acompanhem a matriz e as métricas.
Limiar de decisão, matriz de confusão e curva ROC
| Disse azul | Disse laranja | |
|---|---|---|
| Era azul | —VP | —FN |
| Era laranja | —FP | —VN |
Uma camada oculta com 4 neurônios (tanh), treinada por 150 épocas em 240 pontos (60 azuis e 180 laranjas). O quadro mostra só os pontos de teste; o fundo azul é a região em que a probabilidade de azul passa do limiar.
Com o limiar em 0,5, a acurácia é de 86%, mas a rede encontra só 68% dos azuis. Baixando para 0,2, o recall vai a 90%, enquanto a precisão cai de 75% para 64%. Reparem também que um modelo que respondesse “laranja” para todos os pontos já teria 75% de acurácia, só porque laranja é a maioria. Os 86% parecem bons, mas estão bem mais perto desse chute do que parece.
Curva ROC e AUC
Cada limiar dá dois números: o recall, que também é chamado de taxa de verdadeiros positivos, e a taxa de falsos positivos, FP / (FP + VN), que é a fração dos laranjas que a rede marcou como azul por engano. A curva ROC liga esses pares para todos os limiares possíveis. É ela que aparece no interativo, com o limiar atual marcado.
Um modelo perfeito passaria pelo canto superior esquerdo, encontrando todos os azuis sem nenhum alarme falso. Um modelo que chuta ao acaso fica em cima da diagonal tracejada. Quanto mais a curva se aproxima do canto, melhor.
A AUC (do inglês area under the curve, área sob a curva) resume a curva num número só, que não depende do limiar: 1 é um modelo perfeito e 0,5 é o mesmo que chutar. Ela tem uma interpretação simples: é a chance de, sorteando um ponto azul e um laranja, a rede dar uma probabilidade maior ao azul. Aqui, a AUC é 0,93.
8. No código
No simulador, cada hiperparâmetro é um controle. No código, ele é um argumento. Este exemplo usa o MLPClassifier do scikit-learn para treinar a mesma rede da seção 3 (uma camada com 4 neurônios e tanh) em dados parecidos com o círculo, testando quatro taxas de aprendizado:
from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
# Dados parecidos com o "Círculo" do simulador
X, y = make_circles(n_samples=360, noise=0.08, factor=0.5, random_state=0)
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=1/3, random_state=0)
for eta in [0.001, 0.03, 0.3, 3]:
rede = MLPClassifier(
hidden_layer_sizes=(4,), # 1 camada oculta com 4 neurônios
activation="tanh",
solver="sgd", # gradiente descendente
learning_rate_init=eta, # taxa de aprendizado
batch_size=10,
max_iter=300, # número máximo de épocas
momentum=0,
random_state=1, # semente fixa
)
rede.fit(X_treino, y_treino)
print(f"η = {eta:<6} épocas = {rede.n_iter_:<4} "
f"perda = {rede.loss_:.3f} acurácia no teste = {rede.score(X_teste, y_teste):.0%}")
Rodando, a saída é:
η = 0.001 épocas = 300 perda = 0.669 acurácia no teste = 67%
η = 0.03 épocas = 300 perda = 0.138 acurácia no teste = 99%
η = 0.3 épocas = 300 perda = 0.016 acurácia no teste = 100%
η = 3 épocas = 41 perda = 0.023 acurácia no teste = 98%
O padrão é o mesmo do simulador. Com 0,001 a rede quase não aprende, enquanto 0,03 e 0,3 funcionam bem. Duas coisas aqui são novidade.
Primeiro, o momentum=0. Por padrão, o scikit-learn usa uma versão do gradiente descendente com momento, em que cada passo também carrega parte da direção dos passos anteriores. Desliguei para ficar igual ao simulador, mas vale testar sem essa linha e ver como os resultados mudam.
Segundo, com η = 3 o treino parou sozinho na época 41. O scikit-learn interrompe o treino quando a perda de treino passa 10 épocas sem melhorar pelo menos 0,0001 (os argumentos n_iter_no_change e tol). Com uma taxa grande, a perda chega rápido num valor baixo e fica oscilando em volta dele, então a regra é acionada. Ela olha só para a perda de treino. O early stopping da seção 5, que olha para a validação, é outra opção, ativada com early_stopping=True. Quando a rede chega às 300 épocas sem acionar essa regra, como acontece com 0,001, o scikit-learn mostra um aviso (ConvergenceWarning) dizendo que o treino não convergiu.
Para testar os outros hiperparâmetros, é só trocar o laço: percorrer hidden_layer_sizes=(2,), (4,), (8, 8), ou valores diferentes de max_iter e batch_size.
As métricas da seção 7 já vêm prontas no módulo sklearn.metrics. Logo depois do laço, a variável rede guarda a última rede treinada (η = 3), e dá para avaliá-la assim:
from sklearn.metrics import confusion_matrix, precision_score, recall_score, roc_auc_score
y_prev = rede.predict(X_teste) # classe prevista (limiar 0,5)
prob = rede.predict_proba(X_teste)[:, 1] # probabilidade da classe 1
print(confusion_matrix(y_teste, y_prev))
print(f"precisão = {precision_score(y_teste, y_prev):.2f} "
f"recall = {recall_score(y_teste, y_prev):.2f} "
f"AUC = {roc_auc_score(y_teste, prob):.3f}")
[[52 2]
[ 0 66]]
precisão = 0.97 recall = 1.00 AUC = 0.999
Aqui a classe positiva (1) é o miolo do círculo. Cuidado com a ordem da matriz no scikit-learn: as linhas são a classe real e as colunas a prevista, mas a classe 0 vem primeiro. Então o 66 é VP, o 52 é VN, e os 2 erros são falsos positivos: pontos do anel que a rede colocou no miolo. A AUC usa a probabilidade, e não a classe prevista, justamente porque não depende do limiar.
9. Desafios
Todos podem ser resolvidos no simulador da seção 2. Tentem antes de abrir a resposta!
Desafio 1: um único neurônio
Escolha Duas nuvens, uma camada oculta e 1 neurônio. A rede consegue separar as classes? E no Círculo, com a mesma rede?
Ver resposta
Nas duas nuvens, sim. As classes podem ser separadas por uma reta, e um neurônio dá conta disso. No círculo, não, porque nenhuma reta separa o miolo do anel em volta. Por mais que a rede treine, a acurácia fica baixa. É a mesma limitação do Perceptron que vimos na aula de Redes Neurais.
Desafio 2: a menor rede para a espiral
Na Espiral, com η = 0,3 e 300 épocas, qual é a rede com menos parâmetros que chega a pelo menos 95% de acurácia no teste?
Ver resposta
Uma camada com 4 neurônios (17 parâmetros). Com 2 neurônios, a acurácia no teste fica em torno de 60%. Com 3, chega perto de 90%, mas não passa da meta. Mais camadas também resolvem, só que com muito mais parâmetros do que o necessário.
Desafio 3: onde o treino quebra?
No Círculo, com uma camada de 4 neurônios, vá aumentando η a partir de 0,03. Em que ponto a perda deixa de cair de forma suave? E quando o simulador avisa que ela explodiu?
Ver resposta
De 0,03 a 0,3, a perda cai de forma suave, e cada aumento deixa o treino mais rápido. Com 1 e com 3, a rede ainda acerta o círculo, mas a curva começa a dar pequenos saltos para cima, sinal de que alguns passos estão passando do mínimo. Com 10, a perda dispara logo na primeira época e aparece o aviso. Esses valores mudam de problema para problema, por isso a taxa precisa ser testada em cada caso.
Desafio 4: 100% no treino
No interativo da seção 5, a acurácia no treino chega a 100%, mas a do teste não acompanha. Por que acertar todos os pontos de treino não é uma boa notícia aqui?
Ver resposta
Por causa do ruído, alguns pontos de treino estão com a cor “errada” para a região onde aparecem. Para acertá-los, a rede cria desvios na fronteira que não fazem parte do padrão real. Nos pontos de teste, esses desvios só atrapalham, e a rede ainda erra com mais confiança, o que faz a perda no teste subir.
Desafio 5: trocando a ativação
Use o XOR com uma camada de 4 neurônios e η = 0,03. Treine com tanh, depois com ReLU e depois com sigmoid. O que muda na fronteira e na velocidade do treino?
Ver resposta
Com ReLU, a fronteira é feita de trechos retos, já que cada neurônio vale zero de um lado de uma reta e cresce linearmente do outro. Nesse caso, ela também foi a mais rápida. Com tanh, a fronteira fica mais suave. Já com sigmoid, a rede quase não sai do lugar em 300 épocas. Isso acontece porque a derivada da sigmoid é no máximo 0,25, então os gradientes que chegam à camada oculta ficam pequenos e, com η = 0,03, os passos ficam minúsculos. Experimentem subir η para 0,3 e ver a diferença.
10. Questões
Para fechar, algumas questões no formato de prova. Clique numa alternativa para ver se acertou.
1. Uma rede está sendo treinada e a curva de perda no treino fica assim: cai nas primeiras épocas, depois começa a dar saltos cada vez maiores e termina muito acima do valor inicial. Qual é a causa mais provável?
Saltos crescentes na perda de treino indicam que os passos estão passando cada vez mais longe do mínimo, como na parábola da seção 3 com η > 1. Poucos neurônios causam uma perda que trava num valor alto, mas não que cresce. O tamanho do teste não interfere no treino.
2. Uma rede com uma camada oculta de 1 neurônio é treinada num conjunto em que os pontos de uma classe formam um anel em volta dos da outra. Depois de 300 épocas, a perda parou de cair e a acurácia no treino está em 64%. Qual a melhor próxima tentativa?
Um único neurônio só consegue separar as classes por uma reta, e nenhuma reta separa um anel do miolo. É underfitting. A rede não tem capacidade para o padrão, então treinar mais ou mudar η não resolve. E, como a acurácia baixa é no próprio treino, dá para descartar overfitting.
3. Durante um treino, a perda no treino diminui o tempo todo. A perda na validação diminui até a época 100 e, a partir daí, aumenta. Qual afirmação está correta?
É o overfitting da seção 5. A rede continua melhorando nos exemplos que conhece, mas piora nos que não conhece. Parar quando a validação deixa de melhorar é o early stopping.
4. Uma rede recebe 2 entradas, tem uma camada oculta com 3 neurônios e uma saída com 1 neurônio. Cada neurônio tem um viés. Quantos parâmetros a rede tem?
Da entrada para a camada oculta são 2 × 3 = 6 pesos, mais 3 vieses. Da camada oculta para a saída são 3 pesos, mais 1 viés. Total: 6 + 3 + 3 + 1 = 13. Dá para conferir no simulador, com uma camada e 3 neurônios.
5. Um modelo faz a triagem de uma doença rara. Num conjunto de 1000 pessoas, 20 estão doentes. O modelo marca 50 pessoas como doentes, e 18 delas realmente estão. Qual é o recall do modelo e o que ele significa?
Recall = VP / (VP + FN) = 18 / 20 = 90%: dos doentes que existem, o modelo encontrou 18. A alternativa (A) é a precisão, 18 / 50 = 36%. A (C) é a acurácia: são 32 falsos positivos e 2 falsos negativos, então (1000 − 34) / 1000 = 96,6%. Ela é alta só porque quase todo mundo está saudável. Numa triagem, o recall alto é o mais importante, e os falsos positivos são esclarecidos por exames depois.
11. Para continuar
Se quiserem ir além, o TensorFlow Playground é um simulador parecido (em inglês) com mais opções, como regularização, tamanho do batch e entradas extras do tipo x₁² ou sen(x₁). Uma boa brincadeira é tentar resolver a espiral de lá com poucos neurônios usando essas entradas, e pensar em por que elas facilitam tanto.
