Aprenda Implementando o Gradiente Descendente em Python

O gradiente descendente segue uma ideia simples, porém poderosa: mover-se na direção da maior descida para minimizar uma função.

A regra matemática é:

theta = theta - alpha * gradient(theta)

Onde:

theta é o parâmetro que está sendo otimizado;
alpha é a taxa de aprendizado (tamanho do passo);
gradient(theta) é o gradiente da função em theta.

1. Definir a Função e Sua Derivada

Começamos com uma função quadrática simples:

def f(theta):
    return theta**2  # Function we want to minimize

Sua derivada (gradiente) é:

def gradient(theta):
    return 2 * theta  # Derivative: f'(theta) = 2*theta

f(theta): esta é a nossa função, e queremos encontrar o valor de theta que a minimiza;
gradient(theta): indica a inclinação em qualquer ponto theta, utilizada para determinar a direção da atualização.

2. Inicializar os Parâmetros do Gradiente Descendente

alpha = 0.3  # Learning rate
theta = 3.0  # Initial starting point
tolerance = 1e-5  # Convergence threshold
max_iterations = 20  # Maximum number of updates

alpha (taxa de aprendizado): controla o tamanho de cada passo;
theta (palpite inicial): ponto de partida para a descida;
tolerance: quando as atualizações se tornam muito pequenas, o processo é interrompido;
max_iterations: garante que não haja um loop infinito.

3. Executar o Gradiente Descendente

for i in range(max_iterations):
    grad = gradient(theta)  # Compute gradient
    new_theta = theta - alpha * grad  # Update rule
    if abs(new_theta - theta) < tolerance:
        print("Converged!")
        break
    theta = new_theta

Calcular o gradiente em theta;
Atualizar theta usando a fórmula do gradiente descendente;
Parar quando as atualizações forem muito pequenas (convergência);
Exibir cada etapa para monitorar o progresso.

4. Visualização do Gradiente Descendente


              123456789101112131415161718192021222324252627282930313233343536373839
            
import matplotlib.pyplot as plt
import numpy as np

def f(theta):
    return theta**2  # Function we want to minimize

def gradient(theta):
    return 2 * theta  # Derivative: f'(theta) = 2*theta

alpha = 0.3           # Learning rate
theta = 3.0           # Initial starting point
tolerance = 1e-5      # Convergence threshold
max_iterations = 20   # Maximum number of updates

theta_values = [theta]          # Track parameter values
output_values = [f(theta)]      # Track function values

for i in range(max_iterations):
    grad = gradient(theta)                # Compute gradient
    new_theta = theta - alpha * grad      # Update rule
    if abs(new_theta - theta) < tolerance:
        break
    theta = new_theta
    theta_values.append(theta)
    output_values.append(f(theta))

# Prepare data for plotting the full function curve
theta_range = np.linspace(-4, 4, 100)
output_range = f(theta_range)

# Plot
plt.plot(theta_range, output_range, label="f(θ) = θ²", color='black')
plt.scatter(theta_values, output_values, color='red', label="Gradient Descent Steps")
plt.title("Gradient Descent Visualization")
plt.xlabel("θ")
plt.ylabel("f(θ)")
plt.legend()
plt.grid(True)
plt.show()

Este gráfico mostra:

A curva da função $f(θ) = θ^2$ ;
Pontos vermelhos representando cada etapa do gradiente descendente até a convergência.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 10

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Awesome!

Completion rate improved to 1.96

Deslize para mostrar o menu