Algoritmos ML

Os algoritmos de Machine Learning (ML) podem ser divididos em três categorias principais: aprendizado supervisionado, aprendizado não supervisionado e aprendizado por reforço. Dentro dessas categorias, existem diversos algoritmos com aplicações específicas.

---

🔹 1. Aprendizado Supervisionado

Os modelos aprendem a partir de dados rotulados, onde cada entrada tem uma saída esperada. São usados para classificação e regressão.

1.1. Regressão Linear

• Objetivo: Modelar a relação entre variáveis independentes (X) e dependentes (Y) por meio de uma linha reta.

• Uso: Previsão de preços, demanda de mercado, análise de tendências.

• Exemplo no Python (Scikit-learn):

  from sklearn.linear_model import LinearRegression
  from sklearn.model_selection import train_test_split
  import numpy as np
  
  X = np.array([1, 2, 3, 4, 5]).reshape(-1, 1)
  y = np.array([2, 4, 6, 8, 10])
  
  model = LinearRegression()
  model.fit(X, y)
  print(model.predict([[6]]))  # Prevê valor para X=6

1.2. Regressão Logística

• Objetivo: Utilizada para classificação binária (exemplo: spam vs. não spam).

• Uso: Diagnóstico médico (doente ou saudável), detecção de fraudes.

• Exemplo no Python:

  from sklearn.linear_model import LogisticRegression
  
  X = [[1], [2], [3], [4], [5]]
  y = [0, 0, 1, 1, 1]  # Classes: 0 ou 1
  
  model = LogisticRegression()
  model.fit(X, y)
  print(model.predict([[2.5]]))  # Prevê se é 0 ou 1

1.3. Árvores de Decisão

• Objetivo: Criar um conjunto de regras de decisão para prever um resultado.

• Uso: Diagnóstico médico, análise de crédito.

• Exemplo no Python:

  from sklearn.tree import DecisionTreeClassifier
  
  X = [[0, 0], [1, 1]]
  y = [0, 1]
  
  model = DecisionTreeClassifier()
  model.fit(X, y)
  print(model.predict([[0.5, 0.5]]))

1.4. Random Forest (Floresta Aleatória)

• Objetivo: Usa múltiplas árvores de decisão para melhorar a precisão.

• Uso: Previsão do tempo, sistemas de recomendação.

• Exemplo no Python:

  from sklearn.ensemble import RandomForestClassifier
  
  X = [[0, 0], [1, 1], [1, 0], [0, 1]]
  y = [0, 1, 1, 0]
  
  model = RandomForestClassifier(n_estimators=10)
  model.fit(X, y)
  print(model.predict([[0.5, 0.5]]))

1.5. Support Vector Machine (SVM)

• Objetivo: Encontrar um hiperplano que melhor separe as classes.

• Uso: Reconhecimento facial, classificação de texto.

• Exemplo no Python:

  from sklearn.svm import SVC
  
  X = [[0, 0], [1, 1]]
  y = [0, 1]
  
  model = SVC()
  model.fit(X, y)
  print(model.predict([[0.5, 0.5]]))

---

🔹 2. Aprendizado Não Supervisionado

Slides da Aula

Os modelos aprendem sem rótulos, identificando padrões e agrupamentos nos dados.

2.1. K-Means

• Objetivo: Agrupar dados em K grupos.

• Exemplo de utilização: https://colab.research.google.com/drive/1dwjAE_iqvAtjWgidv86G5cPk99F7jIai?usp=sharing

• Uso: Segmentação de clientes, compressão de imagens.

• Exemplo no Python:

  from sklearn.cluster import KMeans
  import numpy as np
  
  X = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
  model = KMeans(n_clusters=2)
  model.fit(X)
  print(model.labels_)  # Exibe os grupos formados

2.2. DBSCAN

• Objetivo: Identificar clusters de diferentes densidades.

• Uso: Detecção de anomalias em redes, análise de comportamento de clientes.

• Exemplo no Python:

  from sklearn.cluster import DBSCAN
  
  X = [[1, 2], [2, 2], [2, 3], [8, 7], [8, 8], [25, 80]]
  model = DBSCAN(eps=3, min_samples=2)
  print(model.fit_predict(X))  # Grupos encontrados

2.3. PCA (Análise de Componentes Principais)

• Objetivo: Reduzir a dimensionalidade dos dados.

• Uso: Compressão de dados, redução de ruído em imagens.

• Exemplo no Python:

  from sklearn.decomposition import PCA
  import numpy as np
  
  X = np.array([[2.5, 2.4], [0.5, 0.7], [2.2, 2.9], [1.9, 2.2]])
  pca = PCA(n_components=1)
  X_reduced = pca.fit_transform(X)
  print(X_reduced)  # Dados reduzidos a uma dimensão

---

🔹 3. Aprendizado por Reforço

Slides da Aula

O modelo aprende por tentativa e erro, recebendo recompensas ou penalidades.

3.1. Q-Learning

• Objetivo: Agente aprende um ambiente tentando maximizar sua recompensa.

• Uso: Jogos, robótica, negociação de ações.

• Exemplo com OpenAI Gym e Q-Learning:

  import gym
  import numpy as np
  
  env = gym.make("Taxi-v3")
  state = env.reset()
  q_table = np.zeros([env.observation_space.n, env.action_space.n])
  
  alpha, gamma, epsilon = 0.1, 0.9, 0.1  # Taxa de aprendizado, desconto, exploração
  
  for episode in range(1000):
      state, done = env.reset(), False
      while not done:
          action = np.argmax(q_table[state]) if np.random.rand() > epsilon else env.action_space.sample()
          next_state, reward, done, _ = env.step(action)
          q_table[state, action] = q_table[state, action] + alpha * (reward + gamma * np.max(q_table[next_state]) - q_table[state, action])
          state = next_state

---

🔹 Conclusão

Cada algoritmo de Machine Learning tem seu propósito e aplicação específica. Dependendo do problema (classificação, regressão, clusterização, etc.), você pode escolher o algoritmo mais adequado e treiná-lo com Scikit-learn, TensorFlow, PyTorch, entre outras bibliotecas.

Referências

• Documentação Oficial do Scikit-learn

  • https://scikit-learn.org/stable/documentation.html

• Documentação do TensorFlow e Keras

  • https://www.tensorflow.org/

  • https://keras.io/

• Documentação do PyTorch

  • https://pytorch.org/

• Livro: "Pattern Recognition and Machine Learning" - Christopher M. Bishop

  • Referência acadêmica fundamental sobre os fundamentos de aprendizado de máquina.

• Livro: "Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow" - Aurélien Géron

  • Excelente guia prático para implementação de algoritmos de ML.

• Curso de Machine Learning de Andrew Ng (Stanford / Coursera)

  • https://www.coursera.org/learn/machine-learning