Carregando
0x60Lição 7 de 18

Redes neurais: fundamentos

Monte um neurônio artificial com soma ponderada e ativação; depois, combine neurônios em camadas.

22 min Questionário com 6 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Calcular a saída de um neurônio a partir das entradas, pesos e viés
  • Explicar por que as funções de ativação precisam ser não lineares
  • Descrever como as camadas transformam neurônios simples em uma rede profunda

Seu cérebro tem cerca de 86 bilhões de neurônios. Cada um recebe sinais de outros e dispara quando o sinal combinado é forte o bastante. As redes neurais artificiais usam essa ideia de forma matemática e bem simplificada.

Um neurônio artificial faz duas coisas:

  1. Calcula a soma ponderada das entradas mais um viés: z=w1x1+w2x2+⋯+wnxn+bz = w_1 x_1 + w_2 x_2 + \dots + w_n x_n + b — mais um produto escalar.
  2. Passa o resultado por uma função de ativação, que define a intensidade do disparo: a=f(z)a = f(z).

Os pesos indicam quanto cada entrada importa e se ela aumenta ou diminui o resultado; o viés desloca o ponto em que o neurônio dispara.

x₁w₁x₂w₂x₃w₃Σ + bativaçãoy
Um neurônio artificial: multiplique cada entrada por um peso, some um viés e aplique uma função de ativação.

Uma ativação popular é a sigmoide, que comprime qualquer número para o intervalo entre 0 e 1. Assim, a saída pode ser interpretada como uma probabilidade:

σ(z)=11+e−z\sigma(z) = \frac{1}{1 + e^{-z}}

Um valor de zz muito positivo resulta em quase 1; um valor muito negativo, em quase 0; e z=0z = 0 resulta exatamente em 0,5.

Experimente

Até 15 XP

Ajuste um neurônio

Este neurônio tem duas entradas e ativação sigmoide. Uma saída acima de 0,5 significa “azul”; abaixo, “laranja”. A linha marca o ponto em que a saída é exatamente 0,5. Ajuste os controles de peso e viés até classificar todos os pontos (sem círculos vermelhos). Depois tente quebrar o resultado: o que acontece quando w₁ fica negativo?

z=1.0x1+1.0x2+0.0z = 1.0x_1 + 1.0x_2 + 0.0y=sigmoid(z)y = \text{sigmoid}(z)
Acurácia: 38% (3/8 classificados corretamente — pontos circulados em vermelho estão incorretos)
neuron.py
1import math
2
3def neuron(inputs, weights, bias):
4    z = sum(x * w for x, w in zip(inputs, weights)) + bias
5    return 1 / (1 + math.exp(-z))
6
7# Devo sair? entradas: sol (0 ou 1), temperatura em °C / 10, chuva (0 ou 1)
8weights = [2.0, 0.5, -4.0]
9bias = -1.5
10print(f"{neuron([1, 2.4, 0], weights, bias):.3f}")   # sol, 24 °C, sem chuva
11print(f"{neuron([0, 1.0, 1], weights, bias):.3f}")   # nublado, 10 °C, com chuva
Saída
0.846
0.007

De um neurônio a uma rede

Um único neurônio só consegue traçar uma fronteira reta. Alguns problemas exigem mais. O exemplo clássico é o XOR: a saída é 1 quando exatamente uma das duas entradas é 1. Nenhuma reta única separa esses casos.

A solução é conectar neurônios em camadas: a camada de entrada recebe as características, uma ou mais camadas ocultas calculam características intermediárias e a camada de saída produz a resposta. Cada neurônio de uma camada envia seu resultado a todos os neurônios da próxima.

Camada de entradaCamada ocultaCamada ocultaCamada de saída
Uma rede neural profunda é formada por neurônios como o anterior, organizados em camadas conectadas.
xor_network.py
1def step(z):
2    return 1 if z > 0 else 0
3
4def xor_network(x1, x2):
5    either = step(x1 + x2 - 0.5)       # neurônio oculto 1: OU
6    both = step(x1 + x2 - 1.5)         # neurônio oculto 2: E
7    return step(either - both - 0.5)   # saída: OU, mas não E
8
9for x1 in (0, 1):
10    for x2 in (0, 1):
11        print(x1, x2, "->", xor_network(x1, x2))
Saída
0 0 -> 0
0 1 -> 1
1 0 -> 1
1 1 -> 0

Aprendizado profundo significa simplesmente usar redes com muitas camadas ocultas — de algumas até centenas. Cada camada combina o que veio antes: as primeiras aprendem padrões simples e as seguintes os juntam em padrões complexos. Neste exemplo, escolhemos os pesos do XOR manualmente; redes reais podem ter milhões ou bilhões de pesos, impossíveis de ajustar à mão. A próxima lição mostra como aprendê-los.

Principais conclusões

  • Um neurônio calcula z=w⋅x+bz = w \cdot x + b e depois aplica uma ativação a=f(z)a = f(z).

  • A sigmoide σ(z)=1/(1+e−z)\sigma(z) = 1 / (1 + e^{-z}) comprime a saída entre 0 e 1; a ReLU calcula max⁡(0,z)\max(0, z).

  • Camadas podem aprender fronteiras que um neurônio sozinho não consegue, como XOR — desde que usem ativações não lineares.

  • Aprendizado profundo significa muitas camadas ocultas, cada uma aproveitando a anterior.

Quiz da aula

6 perguntas · aprovação com 5 acertos · até 50 XP

Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.

Pratique: escreva código em Python

Escreva código Python no editor e execute os testes com exemplos. O Python roda localmente no navegador usando WebAssembly.

Exercício 1

Execute um neurônio

+25 XP

Linha 1: as entradas. Linha 2: os pesos. Linha 3: o viés. Linha 4: a ativação, sigmoid ou relu. Imprima z = Z e saída = A, ambos com 3 casas decimais.

  • Sigmoide
  • ReLU com entrada negativa
  • ReLU com entrada positiva
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Exercício 2

Execute uma rede de duas camadas

+25 XP

A primeira linha contém duas entradas. A rede tem dois neurônios ocultos com ReLU e um neurônio de saída sem ativação:

  • oculto 1: pesos (1, 1), viés 0
  • oculto 2: pesos (1, −1), viés −1
  • saída: pesos (2, −3) aplicados aos dois valores ocultos, viés 1

Imprima camada oculta: H1 H2 e saída: Y, formatando cada número com :g.

  • Entradas pequenas
  • O segundo neurônio é ativado
  • Entradas negativas
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Dúvidas sobre esta lição

Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.

Carregando publicações…