Gradient descent em machine learning: um mergulho profundo

O gradient descent é um dos algoritmos mais importantes de toda a área de machine learning e do deep learning. É um algoritmo de otimização extremamente poderoso que pode treinar modelos de regressão linear, regressão logística e redes neurais. Se você está entrando em machine learning, é fundamental compreender o algoritmo de gradient descent a fundo.

O que é gradient descent?

Data science é sobre descobrir padrões e comportamentos complexos na análise de grandes volumes de dados. Esses padrões, isto é, motivos recorrentes, são o que procuramos. Com machine learning, a ideia é treinar algoritmos para detectar esses padrões a fim de executar melhor uma tarefa específica. Em outras palavras, é ensinar um software a realizar uma tarefa ou fazer previsões de forma autônoma. Para isso, o cientista de dados seleciona e treina algoritmos que farão a análise dos dados. O objetivo, claro, é melhorar suas previsões ao longo do tempo.

Consequentemente, o machine learning se baseia amplamente no treinamento de algoritmos. Quanto mais esses algoritmos são expostos a dados, mais aprendem a realizar uma tarefa sem instruções específicas; aprendem pela experiência. Usamos diferentes tipos de algoritmos em machine learning. Entre eles, o gradient descent é um dos mais úteis e populares.

O gradient descent é um algoritmo de otimização. Ele é usado para encontrar mais rapidamente o valor mínimo de uma função. A definição é simples: é um algoritmo para encontrar o mínimo de uma função convexa. Para isso, ele altera iterativamente os parâmetros da função em questão. É um algoritmo usado, por exemplo, em regressão linear.

Uma função convexa se parece com um vale, com um mínimo global no centro. Já uma função não convexa tem vários mínimos locais, e o algoritmo de gradient descent pode não ser adequado, pois corre o risco de ficar preso no primeiro mínimo encontrado.

O gradient descent também é chamado de “algoritmo da descida mais íngreme”. Ele é muito importante em machine learning, onde é usado para minimizar uma função de custo. Essa função ajuda a determinar o melhor modelo de previsão em uma análise de dados. Quanto mais o custo é minimizado, mais a máquina consegue fazer boas previsões.

Existem três tipos bem conhecidos de descida. Vamos olhar de perto cada um deles:

Batch gradient descent

Também conhecido como vanilla gradient descent, o batch gradient descent calcula os erros para cada exemplo no conjunto de treinamento, mas só faz a atualização depois que todos os exemplos foram avaliados. É como um ciclo completo de treinamento — alguns também chamam de época (epoch).

O batch descent tem várias vantagens. Em especial, sua eficiência computacional é prática, pois tende a produzir uma convergência estável e um gradiente de erro estável. Dito isso, também há desvantagens. Às vezes, a estabilidade do gradiente pode levar a um estado de convergência desfavorável. Além disso, ele exige que todo o conjunto de dados de treinamento caiba no algoritmo e na memória.

Stochastic gradient descent

O stochastic gradient descent (SGD) faz atualizações de parâmetros para cada exemplo de treino individualmente. Isso permite dar atenção a cada exemplo, ajudando a reduzir erros. Dependendo do problema, isso pode tornar o SGD mais rápido que o batch gradient descent. Suas atualizações frequentes oferecem um retrato detalhado das melhorias.

Por outro lado, essas atualizações são mais custosas computacionalmente, especialmente em comparação com a abordagem em lotes. Além disso, a alta frequência de atualizações pode gerar gradientes ruidosos e impedir a redução consistente do erro. Em vez disso, a taxa de erro pode oscilar, o que é problemático no longo prazo.

Mini-batch gradient descent

Pesquisadores usam o mini-batch gradient descent como ponto de partida. Por quê? Porque ele combina os conceitos do SGD e do batch descent. Divide o conjunto de treinamento em lotes (batches) e faz uma atualização por lote, criando um equilíbrio entre a eficiência do BGD e a robustez do SGD.

Tamanhos comuns de mini-batch variam de 50 a 256, mas, como em muitos métodos de machine learning, não há regras rígidas — depende da aplicação. É a opção básica mais usada para treinar redes neurais. Também é um tipo popular de descida no universo do deep learning.

Por que o gradient descent é tão importante em machine learning?

Em machine learning, usamos o algoritmo de gradient descent em problemas de aprendizado supervisionado para minimizar a função de custo, que muitas vezes é convexa (por exemplo, o erro quadrático médio).

Com esse algoritmo, a máquina aprende encontrando o melhor modelo. Minimizar a função de custo significa encontrar os parâmetros a, b, c etc. que produzem os menores erros entre nosso modelo e os pontos y do conjunto de dados. Uma vez minimizada a função de custo, abre-se caminho para construir sistemas precisos de reconhecimento de voz, visão computacional e aplicações de previsão de preços no mercado financeiro.

Por isso o gradient descent é fundamental: é a base do aprendizado da máquina.

Para ilustrar seu funcionamento e utilidade, usamos a analogia da montanha. Imagine uma pessoa perdida nas montanhas. Para achar o caminho de volta, ela procura primeiro a direção de maior descida. Depois de seguir essa direção por certa distância, repete o processo até alcançar o vale (o ponto mais baixo). Em machine learning, o gradient descent consiste em repetir esse método em loop até encontrar um mínimo para a função de custo. Por isso ele é chamado de algoritmo iterativo e exige bastante computação.

Aqui vai uma estratégia em 2 passos para quando você estiver “perdido” na montanha:

• Da posição atual, olhe ao redor e identifique a direção em que a inclinação desce mais.
• Depois de encontrar a direção, siga por uma distância (digamos, 300 metros) e repita o passo 1.

Repetindo os passos 1 e 2 em loop, você tende a convergir para o mínimo do vale. Essa estratégia é o próprio algoritmo de gradient descent.

Passo 1: calcular a derivada da função de custo

Começamos de um ponto inicial aleatório e medimos o valor da inclinação nesse ponto. Em matemática, medimos a inclinação calculando a derivada da função.

Passo 2: atualizar os parâmetros do modelo

Em seguida, avançamos uma certa distância d na direção da descida — mas não 300 metros desta vez. Essa distância é chamada de “taxa de aprendizado”. O resultado é modificar o valor dos parâmetros do nosso modelo (nossas coordenadas no vale mudam conforme nos movemos).

Quais áreas usam gradient descent?

O algoritmo de gradient descent é amplamente usado em machine learning e deep learning. Este último pode ser visto como uma evolução do machine learning, capaz de detectar padrões mais sutis. São disciplinas que exigem uma base sólida em matemática e experiência com Python.

Essa linguagem oferece várias bibliotecas que facilitam a aplicação de machine learning. A disciplina é muito útil para analisar grandes volumes de dados com precisão e rapidez, permitindo análises preditivas com base em tendências e eventos passados.

Machine learning está intimamente ligado ao big data em termos de oportunidades. Ele ajuda a superar limites da inteligência humana na análise de grandes fluxos de dados. Com a imensa quantidade de dados disponível online, a inteligência artificial (IA) pode aprender sozinha, sem intervenção humana. O machine learning é usado, por exemplo, no universo de dispositivos conectados. Com ele, uma IA pode se adaptar aos hábitos dos moradores de uma casa conectada e executar tarefas levando esses hábitos em conta.

Por exemplo, a IA pode ajustar o aquecimento de um ambiente conforme o clima. Essa ciência também permitiu aspiradores-robô cada vez mais sofisticados. O gradient descent, por meio do machine learning, está no coração de grandes avanços em IA. Na prática, há inúmeras aplicações de gradient descent por engenheiros e especialistas em IA.

Ele é útil para buscadores como o Google e mecanismos de recomendação populares como YouTube, Netflix e Amazon. Com base nos dados coletados dos usuários, os algoritmos tentam entender os interesses do internauta. Isso permite oferecer resultados de busca e recomendações mais relevantes.

O machine learning permitiu que computadores entendessem e processassem a linguagem humana. Essa aplicação deu origem a assistentes digitais como Alexa, Google Assistant e Siri. Machine learning e aplicações de gradient descent também são muito úteis no desenvolvimento de jogos. Aqui, a ideia é fazer com que IAs executem com excelência tarefas antes humanas, liberando pessoas para atividades de maior valor. IA e machine learning ajudam empresas a antecipar necessidades dos clientes e tendências futuras.

Como implementar o gradient descent

O gradient descent é usado em regressão linear por conta da complexidade computacional. A fórmula geral é xt+1 = xt − η∆xt, com η representando a taxa de aprendizado e ∆xt a direção da descida. É um algoritmo aplicável a funções convexas. Sendo ƒ uma função convexa a ser minimizada, o objetivo é obter ƒ(xt+1) ≤ ƒ(xt) a cada iteração.

A ideia é usar o algoritmo para calcular gradualmente o mínimo de uma função matemática. Em certas equações, é a melhor maneira de resolvê-las. Ao falar de gradient descent, também precisamos entender a noção de função de custo. Em aprendizado supervisionado, essa função mede a margem de erro entre uma estimativa e o valor real. A fórmula para calcular o erro quadrático médio no caso de regressão linear é a seguinte:

A aplicação do gradient descent também envolve a taxa de aprendizado. É um hiperparâmetro que controla o ajuste dos pesos da rede em relação ao gradiente da perda. Uma taxa de aprendizado adequada é essencial para chegar ao mínimo de forma mais rápida e eficiente — nem alta demais, nem baixa demais.

À medida que o valor vai diminuindo, indica que estamos descendo a encosta. Vários métodos de otimização usam o gradient descent, como RMSprop, Adam e SGD. Para evitar erros, é importante escolher os parâmetros com cuidado. Também é bom lembrar que o mínimo encontrado pode não ser o mínimo global.

A função principal de um gradiente é medir a mudança em cada peso em relação à mudança no erro. Pense nos gradientes como a inclinação de uma função. Quanto maior o gradiente, mais íngreme a inclinação — condição favorável, pois o modelo aprende rápido. Porém, se a inclinação se torna zero, o modelo para de aprender. Em termos matemáticos, um gradiente pode ser descrito como uma derivada finita em relação às suas entradas.

Na implementação, vamos escrever duas funções. A primeira será a função de custo, que recebe a saída real e a prevista e retorna a perda. A segunda será a própria função de gradient descent, que recebe a variável independente e a variável alvo (dependente) e encontra a melhor reta de ajuste usando o algoritmo de gradient descent.

As iterações, a taxa de aprendizado e o limiar de parada são parâmetros de ajuste do gradient descent e podem ser definidos pelo usuário. Na função principal, inicializaremos dados linearmente relacionados de forma aleatória e aplicaremos o algoritmo para encontrar a melhor reta. O peso e o viés ótimos encontrados com o gradient descent são então usados para traçar a reta de melhor ajuste na função principal.

# Importando bibliotecas
import numpy as np
import matplotlib.pyplot as plt

def mean_squared_error(y_true, y_predicted):
    # Calculando a perda (custo)
    cost = np.sum((y_true - y_predicted) ** 2) / len(y_true)
    return cost

# Função de gradient descent
# Aqui, iterações, taxa de aprendizado e limiar de parada são hiperparâmetros ajustáveis
def gradient_descent(x, y, iterations=1000, learning_rate=0.0001, stopping_threshold=1e-6):
    # Inicializando peso, viés
    current_weight = 0.1
    current_bias = 0.01
    n = float(len(x))

    costs = []
    weights = []
    previous_cost = None

    # Estimativa dos parâmetros ótimos
    for i in range(iterations):
        # Fazendo previsões
        y_predicted = (current_weight * x) + current_bias

        # Calculando o custo atual
        current_cost = mean_squared_error(y, y_predicted)

        # Se a variação no custo for menor ou igual ao limiar, paramos
        if previous_cost is not None and abs(previous_cost - current_cost) <= stopping_threshold:
            break

        previous_cost = current_cost

        costs.append(current_cost)
        weights.append(current_weight)

        # Calculando os gradientes
        weight_derivative = -(2 / n) * np.sum(x * (y - y_predicted))
        bias_derivative = -(2 / n) * np.sum(y - y_predicted)

        # Atualizando peso e viés
        current_weight = current_weight - (learning_rate * weight_derivative)
        current_bias = current_bias - (learning_rate * bias_derivative)

        # Imprimindo parâmetros a cada 1000 iterações
        if (i + 1) % 1000 == 0:
            print(f"Iteration {i+1}: Cost {current_cost}, Weight {current_weight}, Bias {current_bias}")

    # Visualizando pesos e custo ao longo das iterações
    plt.figure(figsize=(8, 6))
    plt.plot(weights, costs)
    plt.scatter(weights, costs, marker='o', color='red')
    plt.title("Cost vs Weights")
    plt.ylabel("Cost")
    plt.xlabel("Weights")
    plt.show()

    return current_weight, current_bias

def main():
    # Dados
    X = np.array([32.5, 53.4, 61.5, 47.4, 59.8,
                  55.1, 52.2, 39.2, 48.1, 52.5,
                  45.4, 54.3, 44.1, 58.1, 56.7,
                  48.9, 44.6, 60.2, 45.6, 38.8])
    Y = np.array([31.7, 68.7, 62.5, 71.5, 87.2,
                  78.2, 79.6, 59.1, 75.3, 71.3,
                  55.1, 82.4, 62.0, 75.3, 81.4,
                  60.7, 82.8, 97.3, 48.8, 56.8])

    # Estimando peso e viés com gradient descent
    estimated_weight, estimated_bias = gradient_descent(X, Y, iterations=2000)
    print(f"Estimated Weight: {estimated_weight}\nEstimated Bias: {estimated_bias}")

    # Fazendo previsões com os parâmetros estimados
    Y_pred = estimated_weight * X + estimated_bias

    # Plotando a linha de regressão
    plt.figure(figsize=(8, 6))
    plt.scatter(X, Y, marker='o', color='red')
    plt.plot([np.min(X), np.max(X)], [np.min(Y_pred), np.max(Y_pred)], color='blue')
    plt.xlabel("X")
    plt.ylabel("Y")
    plt.show()

if __name__ == "__main__":
    main()

A saída do código acima será assim:

Você pode testar e executar o código acima neste notebook.

Taxa de aprendizado: o papel do hiperparâmetro

Outro ponto importante é a taxa de aprendizado. Em machine learning, chamamos esse tipo de fator de hiperparâmetro, pois, embora não seja estritamente um parâmetro do modelo, ele impacta o desempenho final (assim como os parâmetros do modelo).

A taxa de aprendizado (muitas vezes indicada por α ou η) define a velocidade com que os coeficientes evoluem. Essa quantidade pode ser fixa ou variável. Um dos métodos mais populares atualmente é o Adam, cuja taxa de aprendizado se ajusta ao longo do tempo.

Existem muitos cenários a considerar ao usar gradient descent:

Taxa de aprendizado alta demais

Se a taxa de aprendizado for muito grande, os passos do gradient descent serão muito largos. A vantagem é descer rápido em direção ao mínimo da função de custo, mas você corre o risco de ultrapassar esse mínimo, oscilando ao redor dele indefinidamente. Na analogia do vale, é como se você se deslocasse vários quilômetros de cada vez, passando direto pelo abrigo sem perceber.

Taxa de aprendizado baixa demais

Para evitar o caso anterior, pode ser tentador escolher uma taxa de aprendizado muito baixa. Mas, se for baixa demais, você pode levar tempo demais para convergir ao mínimo da função de custo. É como decidir avançar milímetro a milímetro pela montanha até achar o ponto mais baixo do vale.

• Por que as taxas de aprendizado são tão importantes?

É essencial definir taxas de aprendizado adequadas para ajudar a descida a atingir mínimos locais. Portanto, não as defina nem muito altas nem muito baixas. Passos longos demais podem complicar a chegada ao mínimo. Com taxas menores, o gradient descent tende a alcançar seus mínimos locais, mas isso pode demorar.

• Como encontrar as melhores taxas de aprendizado

Infelizmente, não há fórmula mágica para encontrar a taxa ideal. Na maioria das vezes, é preciso testar vários valores até chegar ao melhor. Isso é chamado de ajuste de hiperparâmetros, e existem diferentes estratégias para fazer isso bem.

Uma ótima maneira de garantir o bom funcionamento da descida é acompanhar a função de custo durante a otimização. Coloque o número de iterações no eixo X e o valor da função de custo no eixo Y. Assim você verá o valor da função de custo após cada iteração do gradient descent e conseguirá avaliar se a taxa de aprendizado está adequada. Você também pode testar valores diferentes e plotá-los juntos.

Se o gradient descent estiver funcionando bem, a função de custo diminuirá a cada iteração. A convergência acontece quando ela deixa de reduzir e se mantém estável. O número de iterações necessário para convergir varia bastante: às vezes 50, outras vezes milhões. É difícil estimar de antemão.

Alguns algoritmos conseguem indicar automaticamente quando houve convergência. Ainda assim, é recomendável definir um limiar de convergência com antecedência — algo que também não é trivial. Por isso gráficos simples são excelentes para verificar a convergência.

Conclusão

Enquanto cientistas usam o gradient descent para encontrar os valores dos parâmetros de uma função e minimizar seus custos, programadores o utilizam como algoritmo de otimização no treinamento de modelos de machine learning. O gradient descent ajusta iterativamente seus parâmetros para minimizar uma função específica, assumindo funções convexas.

O gradient descent é provavelmente a estratégia de otimização mais reconhecida em deep learning e machine learning. Cientistas de dados o utilizam sempre que há oportunidade de combiná-lo com modelos de aprendizado. Entender o algoritmo é relativamente simples, e implementá-lo é ainda mais. Para se aprofundar em deep learning, confira nosso catálogo completo de cursos de machine learning.