Conceitos de IA em Python

Neurônios e funções de ativação em Python

Um neurônio artificial é uma função minúscula. Ele multiplica cada entrada por um peso, soma um viés e passa o resultado por uma função de ativação que decide com que força ele "dispara".

O conceito em palavras simples

Um neurônio artificial é uma função minúscula. Ele multiplica cada entrada por um peso, soma um viés e passa o resultado por uma função de ativação que decide com que força ele "dispara".

Construa um neurônio artificial em Python puro: uma soma ponderada das entradas mais um viés, passada por sigmoid ou ReLU.

Ideias principais

Os pesos dizem o quanto cada entrada importa; o viés desloca o resultado para cima ou para baixo.
Sem ativação, empilhar neurônios ainda daria apenas um modelo linear (uma reta).
Sigmoid devolve um valor entre 0 e 1, por isso combina com probabilidades.
ReLU é rápida e é a escolha comum nas camadas ocultas das redes modernas.

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

Mova os controles para mudar as entradas, os pesos e o viés. Veja a soma ponderada z se mover pelas curvas sigmoid e ReLU.

Código de exemplo

Executar código →

main.py

import math

# A neuron multiplies each input by a weight, adds them up and adds a bias.
def dot(a, b):
    return sum(x * y for x, y in zip(a, b))

def sigmoid(z):
    return 1 / (1 + math.exp(-z))   # squashes any number into (0, 1)

def relu(z):
    return max(0.0, z)              # keeps positives, turns negatives into 0

inputs = [0.5, -1.0, 2.0]
weights = [0.8, 0.2, -0.5]
bias = 0.1

z = dot(inputs, weights) + bias      # weighted sum
print("weighted sum z =", round(z, 3))
print("sigmoid(z) =", round(sigmoid(z), 3))
print("relu(z) =", relu(z))

# The activation decides how strongly the neuron "fires".
for value in [-2, 0, 2]:
    print(f"z={value:>2}  sigmoid={sigmoid(value):.3f}  relu={relu(value)}")

Saída esperada

weighted sum z = -0.7
sigmoid(z) = 0.332
relu(z) = 0.0
z=-2  sigmoid=0.119  relu=0.0
z= 0  sigmoid=0.500  relu=0.0
z= 2  sigmoid=0.881  relu=2

Como funciona

dot() calcula a soma ponderada z. Sigmoid comprime z em um valor entre 0 e 1, enquanto ReLU mantém os valores positivos e transforma os negativos em 0. O laço mostra como cada ativação responde a uma entrada negativa, zero e positiva.

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.

Mude as entradas ou os pesos e preveja a saída antes de executar.
Imprima os valores intermediários para acompanhar cada passo do cálculo.
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