🧠 ClassicMLAlgorithms: Implementações Didáticas do Zero

Status: Concluído ✅
Objetivo: Educacional (From Scratch)
Biblioteca Base: NumPy
Total de Algoritmos: 9 (7 Supervisionados + 2 Não Supervisionados)

O ClassicMLAlgorithms é uma coleção de implementações puras e didáticas dos algoritmos fundamentais de Machine Learning, construídos do zero utilizando apenas NumPy para operações vetoriais.

O foco não é substituir bibliotecas otimizadas como Scikit-Learn, mas fornecer uma compreensão profunda da matemática, otimização (Gradient Descent) e lógica algorítmica por trás dessas ferramentas essenciais, desmistificando a "caixa preta" do Machine Learning.

---

🗂️ Estrutura do Projeto

classic-ml-algorithms/
│
├── Supervised_Learning/
│   ├── Linear_Regression/
│   │   ├── 01-linear-regression.ipynb
│   │   ├── 02-linear-regression.ipynb
│   │   ├── 03-linear-regression.ipynb
│   │   └── 04-linear-regression.ipynb
│   │   └── linear_regression.py
│   ├── Logistic_Regression/
│   │   ├── logistic_regression.py
│   │   └── 01-logistic-regression.ipynb
│   ├── KNN/
│   │   ├── knn.py
│   │   ├── 01-knn.py
│   │   ├── 02-knn.py
│   │   ├── 03-knn.py
│   │   ├── 04-knn.py
│   │   └── classificacao_leucemias.ipynb
│   ├── Decision_Tree/
│   │   ├── decision_tree.py
│   │   ├── 01-decision_tree.ipynb
│   │   ├── 02-decision_tree.ipynb
│   │   ├── 03-decision_tree.ipynb
│   │   └── 04-decision_tree.ipynb
│   ├── Random_Forest/
│   │   ├── random_forest.py
│   │   ├── decision_tree.py
│   │   └── 01-random_forest.ipynb
│   ├── Classificador_Bayesiano/
│   │   ├── naive_bayes.py
│   │   ├── 01-classificador_bayesiano.ipynb
│   │   └── 02-classificador_bayesiano.ipynb
│   └── SVM/
│       ├── svm.py
│       └── 01-svm.ipynb
│
├── Unsupervised_Learning/
│   ├── K_Means/
│   │   ├── k_means.py
│   │   └── 01-k_means.ipynb
│   └── Fuzzy_C_Means/
│       ├── c_means.py
│       └── 01-c_means.ipynb
│
├── datasets/                # Arquivos CSV para testes
│
├── requirements.txt         # Dependências
│
└── README.md               # Este arquivo

---

🛠️ Tecnologias Utilizadas

🔹 Core

• NumPy: Operações vetoriais e álgebra linear
• Python 3.8+: Linguagem base

🔹 Visualização & Análise

• Pandas: Manipulação de datasets
• Matplotlib: Gráficos e visualizações
• Seaborn: Visualizações estatísticas

🔹 Ambiente de Desenvolvimento

• Jupyter Notebook: Notebooks interativos de exemplo
• Scikit-learn: Apenas para comparação de resultados e geração de datasets sintéticos

---

🎯 Sobre o Projeto

🔹 Filosofia

Este repositório segue o princípio de "Entender fazendo". Cada algoritmo foi implementado:

• ✅ Do zero: Sem usar bibliotecas de ML prontas
• ✅ Com matemática explícita: Equações implementadas passo a passo
• ✅ Com comentários educativos: Explicando cada decisão
• ✅ Interface padronizada: Métodos fit() e predict() como Scikit-Learn

---

🧮 Algoritmos Implementados

🤖 Supervisionado (Supervised Learning)

Modelos que aprendem a mapear entradas X para saídas y com base em dados rotulados.

Algoritmo	Tipo	Descrição	Principais Conceitos
Regressão Linear	Regressão	Previsão de valores contínuos	Gradient Descent, MSE, Função de Custo
Regressão Logística	Classificação	Classificação binária probabilística	Função Sigmoide, Binary Cross-Entropy
K-Nearest Neighbors	Classificação	Classificação baseada em vizinhança	Distância Euclidiana, Vetorização
Árvore de Decisão	Ambos	Regras de decisão hierárquicas	Entropia, Ganho de Informação, Recursão
Random Forest	Ambos	Ensemble de árvores (Bagging)	Bootstrap Aggregating, Votação
Naive Bayes	Classificação	Classificação probabilística	Teorema de Bayes, Likelihood Gaussiano
SVM (Linear)	Classificação	Classificação de margem máxima	Hinge Loss, Otimização de Margem

---

🔍 Não Supervisionado (Unsupervised Learning)

Modelos que encontram padrões e estruturas em dados não rotulados.

Algoritmo	Tipo	Descrição	Principais Conceitos
K-Means	Clustering	Agrupamento rígido (Hard Clustering)	Centroides, Distância Euclidiana, Convergência
Fuzzy C-Means	Clustering	Agrupamento difuso (Soft Clustering)	Matriz de Pertinência, Lógica Fuzzy

---

📚 Detalhamento dos Algoritmos

🔹 1. Regressão Linear

Equação:

y = β₀ + β₁x₁ + β₂x₂ + ... + βₙxₙ

Loss Function (MSE):

L = (1/n) Σ(y_pred - y_true)²

Conceitos Implementados:

• Gradient Descent para otimização
• Cálculo de derivadas parciais
• Atualização iterativa de pesos

---

🔹 2. Regressão Logística

Função Sigmoide:

σ(z) = 1 / (1 + e^(-z))

Loss Function (Binary Cross-Entropy):

L = -[y·log(p) + (1-y)·log(1-p)]

Conceitos Implementados:

• Transformação logística para probabilidades
• Gradient Descent adaptado
• Decisão com threshold (padrão: 0.5)

---

🔹 3. K-Nearest Neighbors (KNN)

Distância Euclidiana:

d(x₁, x₂) = √Σ(x₁ᵢ - x₂ᵢ)²

Conceitos Implementados:

• Cálculo vetorizado de distâncias
• Ordenação e seleção de k vizinhos
• Votação majoritária para classificação

---

🔹 4. Árvore de Decisão

Entropia:

H(S) = -Σ pᵢ·log₂(pᵢ)

Ganho de Informação:

IG(S, A) = H(S) - Σ(|Sᵥ|/|S|)·H(Sᵥ)

Conceitos Implementados:

• Cálculo de entropia e ganho de informação
• Seleção recursiva do melhor atributo
• Construção da árvore via recursão

---

🔹 5. Random Forest

Conceitos Implementados:

• Bootstrap sampling (amostragem com reposição)
• Construção de múltiplas árvores
• Agregação por votação (classificação) ou média (regressão)
• Feature bagging (subset aleatório de features)

---

🔹 6. Naive Bayes

Teorema de Bayes:

P(y|X) = P(X|y)·P(y) / P(X)

Conceitos Implementados:

• Cálculo de probabilidades a priori
• Likelihood gaussiano para features contínuas
• Assumption de independência condicional

---

🔹 7. SVM (Linear)

Hinge Loss:

L = max(0, 1 - y·(w·x + b))

Conceitos Implementados:

• Maximização de margem
• Gradient Descent com Hinge Loss
• Regularização L2

---

🔹 8. K-Means

Objetivo:

minimize: Σ Σ ||xᵢ - μⱼ||²

Conceitos Implementados:

• Inicialização aleatória de centroides
• Assignment step (atribuir pontos ao centroide mais próximo)
• Update step (recalcular centroides)
• Convergência por tolerância

---

🔹 9. Fuzzy C-Means

Matriz de Pertinência:

uᵢⱼ = 1 / Σₖ(dᵢⱼ/dᵢₖ)^(2/(m-1))

Conceitos Implementados:

• Membership degrees (graus de pertinência)
• Parâmetro de fuzziness (m)
• Atualização ponderada de centroides

---

🚀 Como Usar

Todos os algoritmos seguem a interface padrão fit() e predict(), similar ao Scikit-Learn.

🔹 Exemplo 1: Regressão Linear

import numpy as np
from Supervised_Learning.Linear_Regression.linear_regression import LinearRegression

# 1. Preparar dados
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

# 2. Instanciar e Treinar
model = LinearRegression()
model.fit(X, y, alpha=0.01, iterations=1000)

# 3. Prever
prediction = model.predict(np.array([[6]]))
print(f"Previsão para 6: {prediction}")  # Esperado: ~12

---

🔹 Exemplo 2: K-Means

import numpy as np
from Unsupervised_Learning.K_Means.kmeans import KMeans

# 1. Preparar dados (sem labels)
X = np.array([[1, 2], [1.5, 1.8], [5, 8], [8, 8], [1, 0.6], [9, 11]])

# 2. Instanciar e Treinar
kmeans = KMeans(k=2)
kmeans.fit(X)

# 3. Prever clusters
labels = kmeans.predict(X)
print(f"Cluster assignments: {labels}")

---

🔹 Exemplo 3: Regressão Logística

import numpy as np
from Supervised_Learning.Logistic_Regression.logistic_regression import LogisticRegression

# 1. Preparar dados (classificação binária)
X = np.array([[1, 2], [2, 3], [3, 3], [4, 5], [5, 5]])
y = np.array([0, 0, 0, 1, 1])

# 2. Instanciar e Treinar
model = LogisticRegression()
model.fit(X, y, alpha=0.1, iterations=1000)

# 3. Prever
prediction = model.predict(np.array([[3.5, 4]]))
print(f"Classe predita: {prediction}")

---

⚙️ Como Executar

1️⃣ Clone o repositório

git clone https://github.com/oalvarobraz/ClassicMLAlgorithms.git
cd ClassicMLAlgorithms

2️⃣ Instale as dependências

pip install -r requirements.txt

3️⃣ Explore os notebooks

jupyter notebook

Navegue até a pasta de qualquer algoritmo e abra o example.ipynb para ver demonstrações interativas.

4️⃣ Use em seus projetos

# Importe qualquer algoritmo
from Supervised_Learning.Decision_Tree.decision_tree import DecisionTree

# Use normalmente!
model = DecisionTree()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

---

📦 Dependências

# Core
numpy>=1.24.0

# Data Processing
pandas>=2.0.0

# Visualization
matplotlib>=3.7.0
seaborn>=0.12.0

# Notebooks
jupyter>=1.0.0
ipython>=8.12.0

# Comparison (opcional)
scikit-learn>=1.3.0  # Apenas para comparação

---

✅ Principais Aprendizados

• Matemática por trás dos algoritmos: Implementar do zero força compreensão profunda
• Gradient Descent: Base da maioria dos algoritmos de otimização
• Vetorização com NumPy: Essencial para performance
• Trade-offs: Bias-variance, complexidade vs. interpretabilidade
• Fundamentos sólidos: Base para entender frameworks modernos

---

🎯 Objetivo Educacional

Este projeto não visa:

• ❌ Substituir bibliotecas de produção (Scikit-Learn, TensorFlow)
• ❌ Otimização máxima de performance
• ❌ Implementar todos os detalhes de produção

Este projeto visa:

• ✅ Aprender fundamentos de ML
• ✅ Desmistificar algoritmos clássicos
• ✅ Fornecer base sólida para entender frameworks

---

📌 Autor

Álvaro Braz

Projeto desenvolvido para fins de educação, aprendizado profundo de Machine Learning e portfólio profissional.

---

📄 Licença

Este projeto está sob a licença MIT. Veja o arquivo LICENSE para mais detalhes.

---

🙏 Agradecimentos

• NumPy Community: Por uma biblioteca essencial e bem documentada
• Scikit-Learn: Por estabelecer padrões de interface em ML
• Comunidade de ML: Por compartilhar conhecimento abertamente
• Andrew Ng: Pelos cursos que inspiraram este projeto

---

📚 Referências

1. Hastie, T., Tibshirani, R., & Friedman, J. (2009). The Elements of Statistical Learning.
2. Bishop, C. M. (2006). Pattern Recognition and Machine Learning.
3. Murphy, K. P. (2012). Machine Learning: A Probabilistic Perspective.
4. Scikit-learn Documentation. https://scikit-learn.org/