CodeUtility
Tornando o seu trabalho de dev mais simples!
Conceitos de IA em Python

Propagação direta e funções de perda em Python

Uma rede neural é formada por camadas de neurônios. Na propagação direta, a entrada passa por cada camada para produzir uma previsão, e uma função de perda avalia o quanto essa previsão está longe da resposta certa.

O conceito em palavras simples

Uma rede neural é formada por camadas de neurônios. Na propagação direta, a entrada passa por cada camada para produzir uma previsão, e uma função de perda avalia o quanto essa previsão está longe da resposta certa.

Passe entradas camada por camada por uma pequena rede neural e meça o erro com o erro quadrático e a entropia cruzada.

Ideias principais

  • Uma camada densa liga cada entrada a cada neurônio da camada.
  • A saída de uma camada é a entrada da próxima.
  • A perda é um único número, e quanto menor, melhores as previsões.
  • Use o erro quadrático para números e a entropia cruzada para probabilidades e classes.

Quando usar?

  • Entender o que acontece dentro das redes neurais e das bibliotecas de IA.
  • Aprender a ideia antes de implementá-la nos desafios correspondentes.
  • Se preparar para cursos de aprendizado de máquina, entrevistas e projetos.

Veja na prática

Mude as entradas e o alvo. Acompanhe os valores pela camada oculta e veja como as duas perdas reagem à previsão.

Código de exemplo

Executar código →
main.py
import math

def dense(inputs, weights, biases, activation):
    # Each row of weights belongs to one neuron in the layer.
    return [activation(sum(x * w for x, w in zip(inputs, row)) + b) for row, b in zip(weights, biases)]

relu = lambda z: max(0.0, z)
sigmoid = lambda z: 1 / (1 + math.exp(-z))

x = [1.0, 2.0]
hidden = dense(x, [[0.5, -0.2], [0.3, 0.8]], [0.0, -0.5], relu)
output = dense(hidden, [[1.0, -1.0]], [0.2], sigmoid)
print("hidden layer:", [round(h, 3) for h in hidden])
print("prediction:", round(output[0], 3))

# A loss function measures how wrong the prediction is.
target = 1.0
mse = (output[0] - target) ** 2
bce = -(target * math.log(output[0]) + (1 - target) * math.log(1 - output[0]))
print("squared error:", round(mse, 3))
print("cross-entropy:", round(bce, 3))

Saída esperada

hidden layer: [0.1, 1.4]
prediction: 0.25
squared error: 0.563
cross-entropy: 1.387

Como funciona

dense() calcula uma camada, em que cada linha de pesos é um neurônio. A camada oculta usa ReLU e a de saída usa sigmoid para dar uma probabilidade. O erro quadrático e a entropia cruzada medem a distância entre a previsão 0.25 e o alvo 1.0; o treinamento tenta reduzi-los.

Altere os valores e execute o programa no compilador Python online CodeUtility sem instalar Python.

Exercícios práticos

Altere as entradas e teste casos de borda antes de usar conjuntos de dados maiores.

  1. Mude as entradas ou os pesos e preveja a saída antes de executar.
  2. Imprima os valores intermediários para acompanhar cada passo do cálculo.
  3. Resolva os desafios indicados abaixo para implementar a ideia você mesmo.
Executar no IDE Python →

Pratique com um desafio

Use o conteúdo desta lição para resolver um problema real. Cada desafio roda no navegador, com testes instantâneos e uma revisão por IA.

Todos os desafios