Please enable JavaScript.

Coggle requires JavaScript to display documents.

sklearn - Coggle Diagram

sklearn

cross-validation

from sklearn.model_selection import cross_val_score

cross_val_score(model, X_train, y_train, cv=5)

проверка конкретной модели на кросс-валидации

from sklearn.model_selection import GridSearchCV,

params = {"max_depth": range(1, 11), "max_features": range(4, 19)}
grid = GridSearchCV(tree, params, cv=5, n_jobs=-1, verbose=True)
grid.fit(X_train, y_train)

grid.best_params_, grid.best_score_ , grid.best_estimator_
grid.param_grid[param_name], grid.cv_results_

модель обучается на сетке параметров

from sklearn.model_selection import train_test_split


X_train, X_testt, y_train, y_test = train_test_split(
    df.values, y, test_size=0.3, random_state=17)

LogisticRegressionCV
a grid search of parameters followed by cross-validation

logit_searcher = LogisticRegressionCV(
   Cs=np.logspace(-2, 3, 500), 
   cv=5, 
   n_jobs=-1)
logit_searcher.fit(X_poly, y);
logit_searcher.scores_[1]

from sklearn.model_selection import StratifiedKFold

skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
for train_index, test_index in skf.split(X, y):
    pass

learning_curve

from sklearn.model_selection import learning_curve

n_train, val_train, val_test = learning_curve(
logit_pipe, X, y, train_sizes=train_sizes, cv=5, scoring="roc_auc")

validation_curve

from sklearn.model_selection import validation_curve

val_train, val_test = validation_curve(
    model, X=X, y=y, param_name="alpha", 
    param_range=alphas, cv=5, scoring="roc_auc")

sklearn.tree

from sklearn.tree import DecisionTreeClassifier

tree = DecisionTreeClassifier(criterion="entropy", min_samples_leaf=100, max_depth=3, max_features=10, random_state=17)
tree.fit(train_data, train_labels)
preds = tree.predict_proba(X_test)

max_features - the maximum number of features with which to search for the best partition

visualization

from sklearn import tree

tree.plot_tree(
    tree, filled=True,
    feature_names=feature_names,
    class_names=["Y", "N"],
    node_ids=True,
);

import pydotplus
from sklearn.tree import export_graphviz

tree_str = export_graphviz(
tree, feature_names=feature_names, filled=True, out_file=None)
graph = pydotplus.graph_from_dot_data(tree_str)
graph.write_png(png_path)

metrics

from sklearn.metrics import accuracy_score, roc_auc_score

model = make_pipeline(CountVectorizer(), LogisticRegression(...))

pipeline

from sklearn.pipeline import Pipeline

knn_pipe = Pipeline(
    [("scaler", StandardScaler()), ("knn", KNeighborsClassifier(n_jobs=-1))]
)

datasets

from sklearn.datasets import load_digits, load_files

data = load_digits()
X, y = data.data, data.target

unsupervised learning

from sklearn import decomposition

pca = decomposition.PCA(n_components=2)
X_centered = X - X.mean(axis=0)
pca.fit(X_centered)
X_pca = pca.transform(X_centered)

# the percent of variance that can be explained by each of the selected components
for i, component in enumerate(pca.components_):
  print("{} component: {}% of initial variance".format(i + 1, round(100 * pca.explained_variance_ratio_[i], 2)))
  print(" + ".join("%.3f x %s" % (value, name) for value, name in zip(component, feature_names)))

plt.plot(np.cumsum(pca.explained_variance_ratio_), color="k", lw=2)
plt.axhline(0.9, c="r")

cluster

agglomerative clasterization

from scipy.cluster import hierarchy
from scipy.spatial.distance import pdist

# the upper triangle of the pairwise distance matrix
distance_mat = pdist(X)
# linkage — is an implementation of agglomerative algorithm
Z = hierarchy.linkage(distance_mat, "single")
dn = hierarchy.dendrogram(Z, color_threshold=0.5)

StandardScaler

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_holdout_scaled = scaler.transform(X_holdout)

from sklearn.linear_model import LogisticRegression
logit = LogisticRegression(C=C, random_state=17)
logit.score(X_train, y_train)
classifier.coef_ # w of features

bag of words

from sklearn.feature_extraction.text import CountVectorizer

cv = CountVectorizer(ngram_range=(1, 2)) # analyzer="char_wb" ngram из символов
cv.fit(text)
X_train = cv.transform(text)

cv.vocabulary_
cv.get_feature_names_out()

logistic regression with stochastic gradient descent

from sklearn.linear_model import SGDClassifier
SGDClassifier(loss="log", n_jobs=-1, random_state=17, max_iter=5)

from sklearn.dummy import DummyClassifier 
dc_mf = DummyClassifier(strategy="most_frequent")