Random Forest

import pandas as pd
import matplotlib.pyplot as plt
from io import BytesIO

# Carregar dataset
url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)

# --- ETAPA 1: Data Cleaning
df["Age"].fillna(df["Age"].median(), inplace=True)
df["Gender"].fillna(df["Gender"].mode()[0], inplace=True)
df["AnnualSalary"].fillna(df["AnnualSalary"].median(), inplace=True)

# --- ETAPA 2: Encoding
df["Gender"] = df["Gender"].map({"Male": 1, "Female": 0})

# --- ETAPA 3: Normalização
for col in ["Age", "AnnualSalary"]:
    cmin, cmax = df[col].min(), df[col].max()
    df[col] = 0.0 if cmax == cmin else (df[col] - cmin) / (cmax - cmin)


df0 = df[df["Purchased"] == 0]
df1 = df[df["Purchased"] == 1]

# --- PLOT: Dispersão Idade x Salário ---
fig, ax = plt.subplots(1, 1, figsize=(7, 5))

ax.scatter(
    df0["Age"], df0["AnnualSalary"],
    label="Não comprou (0)", alpha=0.4,
    color="lightcoral", edgecolor="darkred", linewidth=0.8
)
ax.scatter(
    df1["Age"], df1["AnnualSalary"],
    label="Comprou (1)", alpha=0.4,
    color="skyblue", edgecolor="navy", linewidth=0.8
)

ax.set_title("Idade x Salário por Decisão de Compra")
ax.set_xlabel("Idade")
ax.set_ylabel("Salário Anual")
ax.grid(linestyle="--", alpha=0.6)
ax.legend()


buffer = BytesIO()
plt.savefig(buffer, format="svg", bbox_inches="tight")
buffer.seek(0)
print(buffer.getvalue().decode("utf-8"))

import pandas as pd
import matplotlib.pyplot as plt
from io import BytesIO

# Carregar dataset
url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)

# --- ETAPA 1: Data Cleaning 
df["Gender"].fillna(df["Gender"].mode()[0], inplace=True)


counts = df["Gender"].value_counts()

# --- PLOT: Distribuição por Gênero ---
fig, ax = plt.subplots(1, 1, figsize=(6, 4))

ax.bar(
    counts.index, counts.values,
    color=["pink", "skyblue"], edgecolor="lightcoral"
)

ax.set_title("Distribuição por Gênero")
ax.set_xlabel("Gênero")
ax.set_ylabel("Quantidade")
ax.grid(axis="y", linestyle="--", alpha=0.6)


buffer = BytesIO()
plt.savefig(buffer, format="svg", bbox_inches="tight")
buffer.seek(0)
print(buffer.getvalue().decode("utf-8"))

import pandas as pd
import matplotlib.pyplot as plt
from io import BytesIO

# Carregar dataset
url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)

# --- ETAPA 1: Data Cleaning
df["AnnualSalary"].fillna(df["AnnualSalary"].median(), inplace=True)

# --- PLOT: Boxplot
fig, ax = plt.subplots(figsize=(7, 5))

bp = ax.boxplot(df["AnnualSalary"], patch_artist=True, widths=0.5)

for box in bp["boxes"]:
    box.set(facecolor="skyblue", edgecolor="navy", linewidth=1.2)
for whisker in bp["whiskers"]:
    whisker.set(color="navy", linewidth=1.2)
for cap in bp["caps"]:
    cap.set(color="navy", linewidth=1.2)
for median in bp["medians"]:
    median.set(color="darkred", linewidth=1.5)

ax.set_title("Distribuição do Salário Anual")
ax.set_ylabel("Salário Anual")
ax.set_xticks([])
ax.grid(axis="y", linestyle="--", alpha=0.6)


buffer = BytesIO()
plt.savefig(buffer, format="svg", bbox_inches="tight")
buffer.seek(0)
print(buffer.getvalue().decode("utf-8"))

import pandas as pd

def preprocess(df):
    df['Age'].fillna(df['Age'].median(), inplace=True)
    df['Gender'].fillna(df['Gender'].mode()[0], inplace=True)
    df['AnnualSalary'].fillna(df['AnnualSalary'].median(), inplace=True)

    features = ['Gender', 'Age', 'AnnualSalary']
    return df[features]

df = pd.read_csv('https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv')
df = df.sample(n=10, random_state=42)
df = preprocess(df)


print(df.sample(n=10).to_markdown(index=False))

import pandas as pd

def preprocess(df):
    # Limpeza
    df['Age'].fillna(df['Age'].median(), inplace=True)
    df['Gender'].fillna(df['Gender'].mode()[0], inplace=True)
    df['AnnualSalary'].fillna(df['AnnualSalary'].median(), inplace=True)

    # Encoding simples para Gender
    df['Gender'] = df['Gender'].map({'Male': 1, 'Female': 0})


    return df


df = pd.read_csv('https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv')
df = df.sample(n=10, random_state=42)
df = preprocess(df)


print(df.to_markdown(index=False))

import pandas as pd
from sklearn.preprocessing import MinMaxScaler

# Carregar dataset
url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)

# Selecionar colunas numéricas para normalizar
features_to_normalize = ['Age', 'AnnualSalary']

# Inicializar o scaler
scaler = MinMaxScaler()

# Aplicar normalização e substituir no DataFrame
df[features_to_normalize] = scaler.fit_transform(df[features_to_normalize])

# Mostrar amostra dos dados normalizados
print(df.sample(10).to_markdown(index=False))

import pandas as pd
from sklearn.model_selection import train_test_split

# Carregar dataset
url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)

# --- Data Cleaning
df["Age"].fillna(df["Age"].median(), inplace=True)
df["Gender"].fillna(df["Gender"].mode()[0], inplace=True)
df["AnnualSalary"].fillna(df["AnnualSalary"].median(), inplace=True)

# --- Encoding
df["Gender"] = df["Gender"].map({"Male": 1, "Female": 0})

# --- Normalização
for col in ["Age", "AnnualSalary"]:
    cmin, cmax = df[col].min(), df[col].max()
    df[col] = 0.0 if cmax == cmin else (df[col] - cmin) / (cmax - cmin)

# --- Separar variáveis preditoras 
X = df[["Gender", "Age", "AnnualSalary"]]
y = df["Purchased"]

# --- Divisão em treino e teste 
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

print("Tamanho treino:", X_train.shape[0])
print("Tamanho teste:", X_test.shape[0])

import random
import pandas as pd
from collections import Counter

# ===== PREPROCESS =====
def preprocess(df):
    df["Age"].fillna(df["Age"].median(), inplace=True)
    df["Gender"].fillna(df["Gender"].mode()[0], inplace=True)
    df["AnnualSalary"].fillna(df["AnnualSalary"].median(), inplace=True)

    df["Gender"] = df["Gender"].map({"Female": 0, "Male": 1})

    for col in ["Age", "AnnualSalary"]:
        cmin, cmax = df[col].min(), df[col].max()
        df[col] = 0.0 if cmax == cmin else (df[col] - cmin) / (cmax - cmin)

    X = df[["Gender", "Age", "AnnualSalary"]].values.tolist()
    y = df["Purchased"].astype(int).tolist()
    return X, y

# ===== LOAD DATA =====
url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)
X, y = preprocess(df)

# ===== STRATIFIED SPLIT (listas, sem numpy) =====
def stratified_train_test_split(X, y, test_size=0.3, seed=42):
    rnd = random.Random(seed)
    idx0 = [i for i, t in enumerate(y) if t == 0]
    idx1 = [i for i, t in enumerate(y) if t == 1]
    rnd.shuffle(idx0); rnd.shuffle(idx1)
    n0_test = max(1, int(len(idx0) * test_size))
    n1_test = max(1, int(len(idx1) * test_size))
    test_idx = idx0[:n0_test] + idx1[:n1_test]
    train_idx = idx0[n0_test:] + idx1[n1_test:]
    def take(ix): 
        return [X[i] for i in ix], [y[i] for i in ix]
    return *take(train_idx), *take(test_idx)

X_train, y_train, X_test, y_test = stratified_train_test_split(X, y, test_size=0.3, seed=42)

# ===== GINI, TREE, FOREST (seu estilo) =====
def gini_impurity(y):
    if not y:
        return 0.0
    counts = Counter(y)
    imp = 1.0
    n = len(y)
    for c in counts.values():
        p = c / n
        imp -= p * p
    return imp

def split_dataset(X, y, feature_idx, value):
    left_X, left_y, right_X, right_y = [], [], [], []
    for i in range(len(X)):
        if X[i][feature_idx] <= value:
            left_X.append(X[i]); left_y.append(y[i])
        else:
            right_X.append(X[i]); right_y.append(y[i])
    return left_X, left_y, right_X, right_y

class Node:
    def __init__(self, feature_idx=None, value=None, left=None, right=None, label=None):
        self.feature_idx = feature_idx
        self.value = value
        self.left = left
        self.right = right
        self.label = label

def build_tree(X, y, max_depth, min_samples_split, max_features, rnd):
    if len(y) < min_samples_split or max_depth == 0:
        return Node(label=Counter(y).most_common(1)[0][0])

    n_features = len(X[0])
    features = rnd.sample(range(n_features), max_features)

    best_gini = float("inf")
    best = None

    for f in features:
        values = sorted({row[f] for row in X})
        for v in values:
            LX, Ly, RX, Ry = split_dataset(X, y, f, v)
            if not Ly or not Ry:
                continue
            pL = len(Ly) / len(y)
            g = pL * gini_impurity(Ly) + (1 - pL) * gini_impurity(Ry)
            if g < best_gini:
                best_gini = g
                best = (f, v, LX, Ly, RX, Ry)

    if best is None:
        return Node(label=Counter(y).most_common(1)[0][0])

    f, v, LX, Ly, RX, Ry = best
    left = build_tree(LX, Ly, max_depth - 1, min_samples_split, max_features, rnd)
    right = build_tree(RX, Ry, max_depth - 1, min_samples_split, max_features, rnd)
    return Node(f, v, left, right)

def predict_tree(node, x):
    if node.label is not None:
        return node.label
    if x[node.feature_idx] <= node.value:
        return predict_tree(node.left, x)
    else:
        return predict_tree(node.right, x)

class RandomForest:
    def __init__(self, n_estimators=25, max_depth=6, min_samples_split=2, max_features="sqrt", seed=42):
        self.n_estimators = n_estimators
        self.max_depth = max_depth
        self.min_samples_split = min_samples_split
        self.max_features = max_features
        self.seed = seed
        self.trees = []

    def fit(self, X, y):
        rnd = random.Random(self.seed)
        n = len(y)
        n_features = len(X[0])
        mf = int(n_features ** 0.5) if self.max_features == "sqrt" else self.max_features

        for _ in range(self.n_estimators):
            idx = [rnd.randint(0, n - 1) for _ in range(n)]
            Xb = [X[i] for i in idx]
            yb = [y[i] for i in idx]
            tree = build_tree(Xb, yb, self.max_depth, self.min_samples_split, mf, rnd)
            self.trees.append(tree)

    def predict(self, X):
        preds = []
        for x in X:
            votes = [predict_tree(t, x) for t in self.trees]
            preds.append(Counter(votes).most_common(1)[0][0])
        return preds

rf = RandomForest(n_estimators=50, max_depth=6, min_samples_split=2, max_features="sqrt", seed=42)
rf.fit(X_train, y_train)
y_pred = rf.predict(X_test)

acc = sum(1 for yp, yt in zip(y_pred, y_test) if yp == yt) / len(y_test)
print(f"Accuracy: {acc:.2f}")

cm = [[0, 0], [0, 0]]
for yt, yp in zip(y_test, y_pred):
    cm[yt][yp] += 1
cm_df = pd.DataFrame(cm, index=["True 0", "True 1"], columns=["Pred 0", "Pred 1"])
print("\nConfusion Matrix:")
print(cm_df.to_markdown())

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.ensemble import RandomForestClassifier

# ===== PREPROCESS =====
def preprocess(df):
    df["Age"].fillna(df["Age"].median(), inplace=True)
    df["Gender"].fillna(df["Gender"].mode()[0], inplace=True)
    df["AnnualSalary"].fillna(df["AnnualSalary"].median(), inplace=True)

    enc = LabelEncoder()
    df["Gender"] = enc.fit_transform(df["Gender"])  # Female=0, Male=1

    for col in ["Age", "AnnualSalary"]:
        cmin, cmax = df[col].min(), df[col].max()
        df[col] = 0.0 if cmax == cmin else (df[col] - cmin) / (cmax - cmin)

    X = df[["Gender", "Age", "AnnualSalary"]].to_numpy(float)
    y = df["Purchased"].to_numpy(int)
    return X, y, ["Gender", "Age", "AnnualSalary"]

# ===== DATA =====
url = "https://raw.githubusercontent.com/EnzoMalagoli/machine-learning/refs/heads/main/data/car_data.csv"
df = pd.read_csv(url)
X, y, feat_names = preprocess(df)

# ===== SPLIT =====
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.30, random_state=42, stratify=y
)

# ===== MODEL =====
rf = RandomForestClassifier(
    n_estimators=300,
    max_depth=None,
    max_features="sqrt",
    bootstrap=True,
    oob_score=True,
    n_jobs=-1,
    random_state=42
)
rf.fit(X_train, y_train)

# ===== EVAL =====
y_pred = rf.predict(X_test)
acc = accuracy_score(y_test, y_pred)
cm = confusion_matrix(y_test, y_pred)

print(f"Accuracy: {acc:.2f}")
print(f"OOB Score: {getattr(rf, 'oob_score_', float('nan')):.2f}")

cm_df = pd.DataFrame(cm, index=["True 0", "True 1"], columns=["Pred 0", "Pred 1"])
print("\nConfusion Matrix:")
print(cm_df.to_markdown())

imp = pd.DataFrame({"Feature": feat_names, "Importance": rf.feature_importances_}).sort_values("Importance", ascending=False)
print("\nFeature Importances:")
print(imp.to_markdown(index=False))