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

Suggested prompts:

Can you explain how the learning rate affects convergence?

What happens if we change the initial value of theta?

Can you summarize the main steps of the gradient descent algorithm?

Deslize para mostrar o menu