from sklearn import (
    cluster,
    datasets,
    ensemble,
    linear_model,
    metrics,
    model_selection,
    neighbors,
    svm,
    tree,
)

%matplotlib inline
import matplotlib.pyplot as plt

import numpy as np

import seaborn as sns

import matplotlib as mpl

mpl.rcParams["mathtext.fontset"] = "stix"
mpl.rcParams["font.family"] = "serif"
mpl.rcParams["font.sans-serif"] = "stix"

sns.set(style="whitegrid")

sns.set(style="darkgrid")

datasets.load_wine  # ()

datasets.fetch_california_housing

datasets.make_regression

np.random.seed(123)

X_all, y_all = datasets.make_regression(
    n_samples=50, n_features=50, n_informative=10
)  # , noise=2.5)

X_train, X_test, y_train, y_test = model_selection.train_test_split(
    X_all, y_all, train_size=0.5
)

X_train.shape, y_train.shape

X_test.shape, y_test.shape

model = linear_model.LinearRegression()

model.fit(X_train, y_train)

def sse(resid):
    return sum(resid**2)

resid_train = y_train - model.predict(X_train)
sse_train = sse(resid_train)
sse_train

resid_test = y_test - model.predict(X_test)
sse_test = sse(resid_train)
sse_test

model.score(X_train, y_train)

model.score(X_test, y_test)

def plot_residuals_and_coeff(resid_train, resid_test, coeff):
    fig, axes = plt.subplots(1, 3, figsize=(12, 3))
    axes[0].bar(np.arange(len(resid_train)), resid_train)
    axes[0].set_xlabel("sample number")
    axes[0].set_ylabel("residual")
    axes[0].set_title("training data")
    axes[1].bar(np.arange(len(resid_test)), resid_test)
    axes[1].set_xlabel("sample number")
    axes[1].set_ylabel("residual")
    axes[1].set_title("testing data")
    axes[2].bar(np.arange(len(coeff)), coeff)
    axes[2].set_xlabel("coefficient number")
    axes[2].set_ylabel("coefficient")
    fig.tight_layout()
    return fig, axes

fig, ax = plot_residuals_and_coeff(resid_train, resid_test, model.coef_)
fig.savefig("ch15-regression-ols.pdf")

model = linear_model.Ridge()  # alpha=2.5)

model.fit(X_train, y_train)

resid_train = y_train - model.predict(X_train)
sse_train = sum(resid_train**2)
sse_train

resid_test = y_test - model.predict(X_test)
sse_test = sum(resid_test**2)
sse_test

model.score(X_train, y_train), model.score(X_test, y_test)

fig, ax = plot_residuals_and_coeff(resid_train, resid_test, model.coef_)
fig.savefig("ch15-regression-ridge.pdf")

model = linear_model.Lasso(alpha=1.0)

model.fit(X_train, y_train)

resid_train = y_train - model.predict(X_train)
sse_train = sse(resid_train)
sse_train

resid_test = y_test - model.predict(X_test)
sse_test = sse(resid_test)
sse_test

fig, ax = plot_residuals_and_coeff(resid_train, resid_test, model.coef_)
fig.savefig("ch15-regression-lasso.pdf")

alphas = np.logspace(-4, 2, 100)

coeffs = np.zeros((len(alphas), X_train.shape[1]))
sse_train = np.zeros_like(alphas)
sse_test = np.zeros_like(alphas)

for n, alpha in enumerate(alphas):
    model = linear_model.Lasso(alpha=alpha)
    model.fit(X_train, y_train)
    coeffs[n, :] = model.coef_
    resid = y_train - model.predict(X_train)
    sse_train[n] = sum(resid**2)
    resid = y_test - model.predict(X_test)
    sse_test[n] = sum(resid**2)

fig, axes = plt.subplots(1, 2, figsize=(12, 4), sharex=True)

for n in range(coeffs.shape[1]):
    axes[0].plot(np.log10(alphas), coeffs[:, n], color="k", lw=0.5)

axes[1].semilogy(np.log10(alphas), sse_train, label="train")
axes[1].semilogy(np.log10(alphas), sse_test, label="test")
axes[1].legend(loc=0)

axes[0].set_xlabel(r"${\log_{10}}\alpha$", fontsize=18)
axes[0].set_ylabel(r"coefficients", fontsize=18)
axes[1].set_xlabel(r"${\log_{10}}\alpha$", fontsize=18)
axes[1].set_ylabel(r"sse", fontsize=18)
fig.tight_layout()
fig.savefig("ch15-regression-lasso-vs-alpha.pdf")

model = linear_model.LassoCV()

model.fit(X_all, y_all)

model.alpha_

resid_train = y_train - model.predict(X_train)
sse_train = sse(resid_train)
sse_train

resid_test = y_test - model.predict(X_test)
sse_test = sse(resid_test)
sse_test

model.score(X_train, y_train), model.score(X_test, y_test)

fig, ax = plot_residuals_and_coeff(resid_train, resid_test, model.coef_)
fig.savefig("ch15-regression-lasso-cv.pdf")

model = linear_model.ElasticNetCV()

model.fit(X_all, y_all)

model.alpha_

model.l1_ratio

resid_train = y_train - model.predict(X_train)
sse_train = sum(resid_train**2)
sse_train

resid_test = y_test - model.predict(X_test)
sse_test = sum(resid_test**2)
sse_test

model.score(X_train, y_train), model.score(X_test, y_test)

fig, ax = plot_residuals_and_coeff(resid_train, resid_test, model.coef_)
fig.savefig("ch15-regression-elastic-net-cv.pdf")

iris = datasets.load_iris()

type(iris)

iris.target_names

iris.feature_names

iris.data.shape

iris.target.shape

# print(iris['DESCR'])

X_train, X_test, y_train, y_test = model_selection.train_test_split(
    iris.data, iris.target, train_size=0.7, random_state=0
)

classifier = linear_model.LogisticRegression()

classifier.fit(X_train, y_train)

y_test_pred = classifier.predict(X_test)

print(metrics.classification_report(y_test, y_test_pred))

np.bincount(y_test)

metrics.confusion_matrix(y_test, y_test_pred)

classifier = tree.DecisionTreeClassifier()
classifier.fit(X_train, y_train)
y_test_pred = classifier.predict(X_test)
metrics.confusion_matrix(y_test, y_test_pred)

classifier = neighbors.KNeighborsClassifier()
classifier.fit(X_train, y_train)
y_test_pred = classifier.predict(X_test)
metrics.confusion_matrix(y_test, y_test_pred)

classifier = svm.SVC()
classifier.fit(X_train, y_train)
y_test_pred = classifier.predict(X_test)
metrics.confusion_matrix(y_test, y_test_pred)

classifier = ensemble.RandomForestClassifier()
classifier.fit(X_train, y_train)
y_test_pred = classifier.predict(X_test)
metrics.confusion_matrix(y_test, y_test_pred)

train_size_vec = np.linspace(0.1, 0.9, 30)

classifiers = [
    tree.DecisionTreeClassifier,
    neighbors.KNeighborsClassifier,
    svm.SVC,
    ensemble.RandomForestClassifier,
]

cm_diags = np.zeros((3, len(train_size_vec), len(classifiers)), dtype=float)

for n, train_size in enumerate(train_size_vec):
    X_train, X_test, y_train, y_test = model_selection.train_test_split(
        iris.data, iris.target, train_size=train_size
    )

    for m, Classifier in enumerate(classifiers):
        classifier = Classifier()
        classifier.fit(X_train, y_train)
        y_test_pred = classifier.predict(X_test)
        cm_diags[:, n, m] = metrics.confusion_matrix(y_test, y_test_pred).diagonal()
        cm_diags[:, n, m] /= np.bincount(y_test)

fig, axes = plt.subplots(1, len(classifiers), figsize=(12, 3))

for m, Classifier in enumerate(classifiers):
    axes[m].plot(train_size_vec, cm_diags[2, :, m], label=iris.target_names[2])
    axes[m].plot(train_size_vec, cm_diags[1, :, m], label=iris.target_names[1])
    axes[m].plot(train_size_vec, cm_diags[0, :, m], label=iris.target_names[0])
    axes[m].set_title(type(Classifier()).__name__)
    axes[m].set_ylim(0, 1.1)
    axes[m].set_xlim(0.1, 0.9)
    axes[m].set_ylabel("classification accuracy")
    axes[m].set_xlabel("training size ratio")
    axes[m].legend(loc=4)

fig.tight_layout()
fig.savefig("ch15-classification-comparison.pdf")

X, y = iris.data, iris.target

np.random.seed(123)

n_clusters = 3

c = cluster.KMeans(n_clusters=n_clusters)

c.fit(X)

y_pred = c.predict(X)

y_pred[::8]

y[::8]

idx_0, idx_1, idx_2 = (np.where(y_pred == n) for n in range(3))

y_pred[idx_0], y_pred[idx_1], y_pred[idx_2] = 2, 0, 1

y_pred[::8]

metrics.confusion_matrix(y, y_pred)

N = X.shape[1]

fig, axes = plt.subplots(N, N, figsize=(12, 12), sharex=True, sharey=True)

colors = ["coral", "blue", "green"]
markers = ["^", "v", "o"]
for m in range(N):
    for n in range(N):
        for p in range(n_clusters):
            mask = y_pred == p
            axes[m, n].scatter(
                X[:, m][mask],
                X[:, n][mask],
                marker=markers[p],
                s=30,
                color=colors[p],
                alpha=0.25,
            )

        for idx in np.where(y != y_pred):
            axes[m, n].scatter(
                X[idx, m],
                X[idx, n],
                marker="s",
                s=30,
                edgecolor="red",
                facecolor=(1, 1, 1, 0),
            )

    axes[N - 1, m].set_xlabel(iris.feature_names[m], fontsize=16)
    axes[m, 0].set_ylabel(iris.feature_names[m], fontsize=16)
fig.tight_layout()
fig.savefig("ch15-clustering.pdf")
fig.savefig("ch15-clustering.png", dpi=600)