Aprendizaje supervisado

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

x = np.array([1., 2., 3., 4.])
y = np.array([2., 4., 5., 4.])

# Desde cero (ecuaciones normales)
x_mean, y_mean = x.mean(), y.mean()
w = ((x - x_mean) * (y - y_mean)).sum() / ((x - x_mean) ** 2).sum()
b = y_mean - w * x_mean
print(f"desde cero: y = {w:.3f}x + {b:.3f}")

# Con Scikit-learn
X = x.reshape(-1, 1)
modelo = LinearRegression().fit(X, y)
print(f"sklearn:    y = {modelo.coef_[0]:.3f}x + {modelo.intercept_:.3f}")

y_pred = modelo.predict(X)
print("R²:", r2_score(y, y_pred))
print("RMSE:", mean_squared_error(y, y_pred) ** 0.5)

plt.scatter(x, y, color="#3355c8", zorder=3)
plt.plot(x, y_pred, color="#b42318")
for xi, yi, yp in zip(x, y, y_pred):
    plt.plot([xi, xi], [yi, yp], color="gray", linestyle=":", lw=.8)
plt.xlabel("x"); plt.ylabel("y"); plt.title("Mínimos cuadrados")
plt.grid(alpha=.3); plt.show()

import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import r2_score
from sklearn.datasets import fetch_california_housing

# --- Regresión múltiple ---
datos = fetch_california_housing(as_frame=True)
X, y = datos.data, datos.target
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=.2, random_state=42)

modelo = LinearRegression().fit(X_tr, y_tr)
print("R² test:", modelo.score(X_te, y_te))
for nombre, coef in zip(X.columns, modelo.coef_):
    print(f"{nombre:>12}: {coef: .4f}")

# --- Multicolinealidad: VIF ---
from statsmodels.stats.outliers_influence import variance_inflation_factor
X_num = X_tr.select_dtypes("number").copy()
vif = pd.DataFrame({
    "feature": X_num.columns,
    "VIF": [variance_inflation_factor(X_num.values, i)
            for i in range(X_num.shape[1])],
})
print(vif.sort_values("VIF", ascending=False))

# --- Polinómica: comparar grados ---
x = np.linspace(-3, 3, 40)
y_poly = 0.5 * x**3 - x**2 + 2 + np.random.default_rng(0).normal(0, 1.2, 40)

for grado in [1, 2, 3, 6, 12]:
    pipe = make_pipeline(PolynomialFeatures(grado, include_bias=False), LinearRegression())
    scores = cross_val_score(pipe, x.reshape(-1, 1), y_poly, cv=5, scoring="r2")
    print(f"grado {grado:2d}: R² CV = {scores.mean(): .3f}")

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, roc_auc_score
from sklearn.datasets import load_breast_cancer

# --- Desde cero: un paso de gradiente ---
def sigmoide(z):
    return 1 / (1 + np.exp(-z))

x, y, w, b, lr = 2.0, 1.0, 1.0, -3.0, 0.1
p = sigmoide(w * x + b)
loss = -(y * np.log(p) + (1 - y) * np.log(1 - p))
grad_w = (p - y) * x
grad_b = (p - y)
w, b = w - lr * grad_w, b - lr * grad_b
print(f"p={p:.3f} loss={loss:.3f} -> w={w:.3f} b={b:.3f}")

# --- Con Scikit-learn ---
datos = load_breast_cancer(as_frame=True)
X, y = datos.data, datos.target
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=.2, random_state=42, stratify=y
)

modelo = make_pipeline(
    StandardScaler(),
    LogisticRegression(C=1.0, max_iter=5000, class_weight="balanced")
).fit(X_tr, y_tr)

y_pred = modelo.predict(X_te)
y_prob = modelo.predict_proba(X_te)[:, 1]
print(classification_report(y_te, y_pred, target_names=datos.target_names))
print("AUC:", roc_auc_score(y_te, y_prob))

# Coeficientes en escala estandarizada
coefs = modelo[-1].coef_[0]
for nombre, c in sorted(zip(X.columns, coefs), key=lambda t: abs(t[1]), reverse=True)[:5]:
    print(f"{nombre:>20}: {c: .3f}")

import numpy as np
from sklearn.linear_model import RidgeCV, LassoCV, ElasticNetCV
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_squared_error

datos = fetch_california_housing(as_frame=True)
X, y = datos.data, datos.target
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=.2, random_state=42)

alphas = np.logspace(-3, 3, 30)

ridge = make_pipeline(StandardScaler(), RidgeCV(alphas=alphas, cv=5))
lasso = make_pipeline(StandardScaler(), LassoCV(alphas=alphas, cv=5, max_iter=20_000))
enet  = make_pipeline(StandardScaler(), ElasticNetCV(
    alphas=alphas, l1_ratio=[.2, .5, .8, 1.0], cv=5, max_iter=20_000))

for nombre, modelo in [("ridge", ridge), ("lasso", lasso), ("elastic", enet)]:
    modelo.fit(X_tr, y_tr)
    pred = modelo.predict(X_te)
    rmse = mean_squared_error(y_te, pred) ** .5
    print(f"{nombre:>8}: RMSE={rmse:.3f}  alpha={modelo[-1].alpha_:.4f}")

coefs = lasso[-1].coef_
print("coeficientes cero:", (coefs == 0).sum(), "de", len(coefs))
print(dict(zip(X.columns, coefs.round(3))))

import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_iris
from sklearn.metrics import pairwise_distances

# --- KNN desde cero (versión simple) ---
def knn_predict(X_train, y_train, x, k=3):
    distancias = np.linalg.norm(X_train - x, axis=1)
    idx = np.argsort(distancias)[:k]
    valores, conteos = np.unique(y_train[idx], return_counts=True)
    return valores[np.argmax(conteos)]

# --- Con Scikit-learn ---
iris = load_iris()
X, y = iris.data, iris.target

for k in [1, 3, 5, 9, 15, 25]:
    modelo = make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=k))
    scores = cross_val_score(modelo, X, y, cv=5, scoring="accuracy")
    print(f"k={k:2d}: {scores.mean():.3f} ± {scores.std():.3f}")

# Matriz de distancias
D = pairwise_distances(X[:5], X[:5])
print(D.round(2))

from sklearn.tree import DecisionTreeClassifier, export_text, plot_tree
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

iris = load_iris(as_frame=True)
X, y = iris.data, iris.target
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=.2, random_state=42, stratify=y)

for depth in [1, 2, 3, 5, None]:
    arbol = DecisionTreeClassifier(max_depth=depth, random_state=42)
    arbol.fit(X_tr, y_tr)
    train = arbol.score(X_tr, y_tr)
    test = arbol.score(X_te, y_te)
    print(f"depth={str(depth):>4}: train={train:.3f} test={test:.3f} hojas={arbol.get_n_leaves()}")

arbol = DecisionTreeClassifier(max_depth=3, random_state=42).fit(X_tr, y_tr)
print(export_text(arbol, feature_names=list(X.columns)))

plt.figure(figsize=(12, 6))
plot_tree(arbol, feature_names=X.columns, class_names=iris.target_names,
          filled=True, rounded=True, fontsize=8)
plt.show()

# Importancia de features
for n, imp in sorted(zip(X.columns, arbol.feature_importances_), key=lambda t: -t[1]):
    print(f"{n:>14}: {imp:.3f}")

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import classification_report, roc_auc_score
import pandas as pd

datos = load_breast_cancer(as_frame=True)
X, y = datos.data, datos.target
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=.2, random_state=42, stratify=y)

rf = RandomForestClassifier(
    n_estimators=500,
    max_features="sqrt",
    min_samples_leaf=2,
    oob_score=True,
    n_jobs=-1,
    random_state=42,
).fit(X_tr, y_tr)

print("OOB score:", round(rf.oob_score_, 3))
print("Test AUC:", round(roc_auc_score(y_te, rf.predict_proba(X_te)[:, 1]), 3))
print(classification_report(y_te, rf.predict(X_te)))

# Importancia por impureza (con cautela)
imp = pd.Series(rf.feature_importances_, index=X.columns).sort_values(ascending=False)
print(imp.head(10))

# Búsqueda de hiperparámetros
parametros = {
    "n_estimators": [300, 600],
    "max_depth": [None, 8, 16],
    "min_samples_leaf": [1, 2, 4],
    "max_features": ["sqrt", 0.5],
}
busqueda = GridSearchCV(
    RandomForestClassifier(random_state=42, n_jobs=-1),
    parametros, cv=5, scoring="roc_auc", n_jobs=-1,
).fit(X_tr, y_tr)
print(busqueda.best_params_, round(busqueda.best_score_, 3))

from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import classification_report, roc_auc_score

datos = load_breast_cancer(as_frame=True)
X, y = datos.data, datos.target
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=.2, random_state=42, stratify=y)

parametros = [
    {"svc__kernel": ["linear"], "svc__C": [0.01, 0.1, 1, 10, 100]},
    {"svc__kernel": ["rbf"], "svc__C": [0.1, 1, 10, 100],
     "svc__gamma": [0.001, 0.01, 0.1, 1]},
]

pipe = make_pipeline(StandardScaler(), SVC(probability=True, random_state=42))
busqueda = GridSearchCV(pipe, parametros, cv=5, scoring="roc_auc", n_jobs=-1)
busqueda.fit(X_tr, y_tr)

print("mejores params:", busqueda.best_params_)
print("mejor AUC CV:", round(busqueda.best_score_, 3))

y_pred = busqueda.predict(X_te)
y_prob = busqueda.predict_proba(X_te)[:, 1]
print(classification_report(y_te, y_pred))
print("AUC test:", round(roc_auc_score(y_te, y_prob), 3))
print("vectores de soporte:", busqueda.best_estimator_[-1].n_support_)

from sklearn.naive_bayes import MultinomialNB, GaussianNB
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split
from sklearn.datasets import fetch_20newsgroups
from sklearn.metrics import classification_report

# --- Texto: 4 categorías de 20 Newsgroups ---
categorias = ["alt.atheism", "comp.graphics", "sci.med", "soc.religion.christian"]
datos = fetch_20newsgroups(subset="train", categories=categorias,
                           remove=("headers", "footers", "quotes"))
X_tr, X_te, y_tr, y_te = train_test_split(
    datos.data, datos.target, test_size=.25, random_state=42, stratify=datos.target)

modelo = make_pipeline(
    TfidfVectorizer(stop_words="english", max_features=20_000, ngram_range=(1, 2)),
    MultinomialNB(alpha=0.1),
).fit(X_tr, y_tr)

y_pred = modelo.predict(X_te)
print(classification_report(y_te, y_pred, target_names=datos.target_names))

# --- Continuo: GaussianNB ---
from sklearn.datasets import load_iris
iris = load_iris()
Xtr, Xte, ytr, yte = train_test_split(iris.data, iris.target,
                                      test_size=.2, random_state=42, stratify=iris.target)
gnb = GaussianNB().fit(Xtr, ytr)
print("GaussianNB accuracy:", gnb.score(Xte, yte))

# pip install xgboost
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score, classification_report
from sklearn.datasets import load_breast_cancer

datos = load_breast_cancer(as_frame=True)
X, y = datos.data, datos.target
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=.2, random_state=42, stratify=y)

modelo = xgb.XGBClassifier(
    n_estimators=1000,
    learning_rate=0.03,
    max_depth=4,
    min_child_weight=3,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_lambda=1.0,
    reg_alpha=0.0,
    objective="binary:logistic",
    eval_metric="auc",
    early_stopping_rounds=50,
    random_state=42,
    n_jobs=-1,
)

modelo.fit(
    X_tr, y_tr,
    eval_set=[(X_tr, y_tr), (X_te, y_te)],
    verbose=False,
)

print("mejor iteración:", modelo.best_iteration)
print("AUC test:", roc_auc_score(y_te, modelo.predict_proba(X_te)[:, 1]))
print(classification_report(y_te, modelo.predict(X_te)))

# Importancia de features
import pandas as pd
imp = pd.Series(modelo.feature_importances_, index=X.columns).sort_values(ascending=False)
print(imp.head(10))