Entenda os Tipos de Aprendizado em Machine Learning de uma forma simples e objetiva
Trabalhar com aprendizado de máquina (o famoso Machine Learning) pode ser desafiador!
Isso depende bastante do problema que se deseja resolver. Para pessoas iniciantes, falar sobre aprendizado por reforço pode parecer muito complexo no início. Por isso, recomendo deixar esse assunto mais para frente em seu roadmap de estudos, principalmente porque é necessário ter um conhecimento sólido sobre redes neurais.
Ao considerar uma solução usando machine learning, é importante compreender qual algoritmo será necessário. Existem muitos algoritmos disponíveis, mas saber distingui-los é crucial para propor uma solução.
Vamos abordar Tipos de aprendizado em Machine Learning, e cada um tem sua funcionalidade.
Aprendizado Supervisionado
No aprendizado supervisionado, os algoritmos são treinados com dados rotulados, onde cada entrada está associada a uma saída desejada. Isso significa que o algoritmo aprende com exemplos conhecidos para fazer previsões ou classificações com base em novos dados. Aqui estão alguns algoritmos comuns desse tipo:
Regressão Linear: Ajuda a prever valores contínuos, como previsões de preço com base em características.
Regressão Logística: É usada para classificar dados em categorias, como identificar se um e-mail é spam ou não.
Esse tipo de aprendizado é o que mais utilizo no meu dia a dia, já que estou sempre tentando prever comportamentos para gerar inteligência nas áreas de negócios.
Imagine poder prever se um cliente irá cancelar um serviço. Toda essa inteligência pode mudar o ponteiro do faturamento da empresa e ainda possibilitar a criação de planos de ação para as equipes.
Exemplo usando Python de uma modelo supervisionado, nesse caso vou criar um algoritmo de regressão linear.
# Importando as bibliotecas necessárias import numpy as np import matplotlib.pyplot as plt from sklearn.linear_model import LinearRegression # Estilo do gráfico no Matplot plt.style.use('seaborn-darkgrid') # Dados de exemplo # Dados de entrada | # Dados de saída x = np.array([1, 2, 3, 4, 5]).reshape(-1, 1) y = np.array([2, 4, 5, 4, 5]) # Criando o modelo de Regressão Linear modelo = LinearRegression() # Treinando o modelo com os dados modelo.fit(x, y) # Fazendo previsões com o modelo treinado previsoes = modelo.predict(x) # Plotando os resultados plt.scatter(x, y, color='blue', label='Dados Reais') plt.plot(x, previsoes, color='red', label='Previsões') plt.xlabel('X') plt.ylabel('Y') plt.title('Regressão Linear Simples') plt.legend() plt.show()
Aprendizado Não Supervisionado
No aprendizado não supervisionado, os dados não têm rótulos prévios, permitindo que o algoritmo explore os padrões e estruturas presentes por conta própria. Ele busca entender a organização dos dados de forma independente, realizando tarefas como:
Agrupamento (Clustering): Agrupar dados similares com base em suas características, ajudando a identificar conjuntos distintos dentro dos dados.
Análise de Componentes Principais (PCA): Reduzir a complexidade dos dados mantendo as informações mais relevantes, facilitando a compreensão dos padrões subjacentes.
Esse tipo de aprendizado tem um potencial enorme para gerar clusters de clientes. Já o utilizei bastante em situações onde era necessário comparar grupos. Sabe aqueles grupos que você cria manualmente com base em similaridades? Podemos usar a clusterização para fazer isso de forma mais inteligente.
Exemplo usando Python de uma modelo não supervisionado, nesse caso vou criar um algoritmo de Clusterização com o K-means.
# Importando as bibliotecas necessárias from sklearn.cluster import KMeans # Gerando dados de exemplo aleatórios np.random.seed(42) # Criando 100 pontos aleatórios em um espaço bidimensional X = np.random.rand(100, 2) # Modelo K-means kmeans = KMeans(n_clusters=3) # Fitando o modelo kmeans.fit(X) # Obtendo os centróides dos clusters e os rótulos para cada ponto de dado centroides = kmeans.cluster_centers_ rotulos = kmeans.labels_ # Plotando os clusters e seus centróides plt.scatter( X[:, 0], X[:, 1], c=rotulos, cmap='viridis', label='Pontos de Dados') plt.scatter(centroides[:, 0], centroides[:, 1], marker='x', s=200, c='red', label='Centróides') plt.title('Clusterização K-means') plt.legend() plt.show()
Aprendizado por Reforço
No aprendizado por reforço, os agentes de Machine Learning interagem com um ambiente dinâmico, aprendendo a tomar decisões sequenciais para maximizar recompensas ao longo do tempo. Eles exploram esse ambiente, aprendendo por tentativa e erro, recebendo feedback na forma de recompensas ou penalidades. Alguns algoritmos notáveis nessa categoria são:
Q-Learning: Um método fundamental que visa otimizar ações em um ambiente baseado em recompensas, ajudando o agente a aprender as melhores escolhas ao longo do tempo..
Aprendizado Profundo por Reforço (Deep Reinforcement Learning): Utiliza redes neurais profundas para lidar com problemas complexos, permitindo aos agentes aprenderem a tomar decisões em ambientes desafiadores.
Esse tipo de aprendizado é um pouco mais complexo. Aplicá-lo no seu negócio provavelmente será em situações bem específicas e demandará bastante tempo e conhecimento. Um exemplo famoso são os veículos autônomos.
Exemplo simples de como você pode implementar um algoritmo de Aprendizado Profundo por Reforço usando a biblioteca TensorFlow em Python. Neste exemplo, usarei o ambiente CartPole do gym, uma biblioteca popular para experimentos de aprendizado por reforço.
import gym import numpy as np import tensorflow as tf import matplotlib.pyplot as plt # Criando o ambiente CartPole env = gym.make('CartPole-v1') state_size = env.observation_space.shape[0] action_size = env.action_space.n # Lista para armazenar as recompensas por episódio episode_rewards_list = [] # Hiperparâmetros learning_rate = 0.001 max_episodes = 5 max_steps = 500 gamma = 0.99 # Fator de desconto # Construindo a rede neural usando TensorFlow inputs = tf.keras.layers.Input(shape=(state_size,)) dense = tf.keras.layers.Dense(24, activation='relu')(inputs) outputs = tf.keras.layers.Dense(action_size, activation='linear')(dense) model = tf.keras.Model(inputs=inputs, outputs=outputs) optimizer = tf.keras.optimizers.Adam(learning_rate) # Função para escolher a ação def choose_action(state): return np.argmax(model.predict(np.array([state]))[0]) # Loop de treinamento for episode in range(max_episodes): state = env.reset() episode_rewards = [] for step in range(max_steps): action = choose_action(state) next_state, reward, done, _ = env.step(action) episode_rewards.append(reward) target = reward + gamma * np.max(model.predict(np.array([next_state]))[0]) target_vec = model.predict(np.array([state]))[0] target_vec[action] = target with tf.GradientTape() as tape: predicted = model(np.array([state]), training=True) loss = tf.reduce_mean(tf.square(target_vec - predicted)) grads = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(grads, model.trainable_variables)) if done: total_reward = sum(episode_rewards) episode_rewards_list.append(total_reward) # Atualizando a lista de recompensas por episódio print(f"Episódio: {episode + 1}, Recompensa Total: {total_reward}") break state = next_state # Plotando o gráfico de recompensas por episódio plt.plot(np.arange(len(episode_rewards_list)), episode_rewards_list) plt.xlabel('Episódio') plt.ylabel('Recompensa Total') plt.title('Evolução da Recompensa por Episódio') plt.show()
Escrito por Odemir Depieri Jr
Fundador Data Viking, Lead Analytics Itaú.
Comments