Aprender los conceptos clave

1

Todo lo que aprender谩s sobre MA con Scikit-Learn

2

驴C贸mo aprenden las m谩quinas?

3

Problemas que podemos resolver con Scikit-learn

4

Las matem谩ticas que vamos a necesitar

Iniciar un proyecto con sklearn

5

Configuraci贸n de nuestro entorno Python

6

Instalaci贸n de librer铆as en Python

7

Datasets que usaremos en el curso

Optimizaci贸n de features

8

驴C贸mo afectan nuestros features a los modelos de Machine Learning?

9

Introducci贸n al PCA

10

Preparaci贸n de datos para PCA e IPCA

11

Implementaci贸n del algoritmo PCA e IPCA

12

Kernels y KPCA

13

驴Qu茅 es la regularizaci贸n y c贸mo aplicarla?

14

Implementaci贸n de Lasso y Ridge

15

Explicaci贸n resultado de la implementaci贸n

16

ElasticNet: Una t茅cnica intermedia

Regresiones robustas

17

El problema de los valores at铆picos

18

Regresiones Robustas en Scikit-learn

19

Preparaci贸n de datos para la regresi贸n robusta

20

Implementaci贸n regresi贸n robusta

M茅todos de ensamble aplicados a clasificaci贸n

21

驴Qu茅 son los m茅todos de ensamble?

22

Preparaci贸n de datos para implementar m茅todos de ensamble

23

Implementaci贸n de Bagging

24

Implementaci贸n de Boosting

Clustering

25

Estrategias de Clustering

26

Implementaci贸n de Mean-Shift

27

Implementaci贸n de Batch K-Means

Optimizaci贸n param茅trica

28

Validaci贸n de nuestro modelo usando Cross Validation

29

Implementaci贸n de K-Folds Cross Validation

30

Optimizaci贸n param茅trica

31

Implementaci贸n de Randomized

32

Bonus: Auto Machine Learning

Salida a producci贸n

33

Revisi贸n de nuestra arquitectura de c贸digo

34

Importar y exportar modelos con Sklearn

35

Creaci贸n de una API con Flask para el modelo

36

Cierre del curso

37

Material adicional para consultar

A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Implementaci贸n de K-Folds Cross Validation

29/37
Recursos

Aportes 9

Preguntas 1

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

Al final me parece que qued贸 muy en el aire esa informaci贸n, asi que quise complementar. Aqu铆 les dejo mi codigo de la implementaci贸n del Cross-Validation con KFold:

data = dataset.drop(["country","score"],axis=1)
targets = dataset["score"]

kf = KFold(n_splits=3,shuffle=True)
    
mse_values = []
for train,test in kf.split(data):
    x_train = pd.DataFrame(columns=list(data),index=range(len(train)))
    x_test = pd.DataFrame(columns=list(data),index=range(len(test)))
    y_train = pd.DataFrame(columns=['score'],index=range(len(train)))
    y_test = pd.DataFrame(columns=['score'],index=range(len(test)))
    for i in range(len(train)):
        x_train.iloc[i] = data.iloc[train[i]]
        y_train.iloc[i] = targets.iloc[train[i]]
    for j in range(len(test)):
        x_test.iloc[j] = data.iloc[test[j]]
        y_test.iloc[j] = targets.iloc[test[j]]
    model = DecisionTreeRegressor().fit(x_train,y_train)
    predict = model.predict(x_test)
    mse_values.append(mean_squared_error(y_test,predict))
    
print("Los tres MSE fueron: ",mse_values)
print("El MSE promedio fue: ", np.mean(mse_values))

no entiendo como interpretar el resultado de score

En este caso al hacer tres splits, es decir al dividir nuestros datos en A,B,C, tenemos solo tres posibles combinaciones AB para training y C para test, luego AC con B, y por ultimo BC con A.

Implementaci贸n de cross validation con KFolds

X = dataset.drop(['country', 'score', 'rank'], axis=1)
y = dataset['score']
model = DecisionTreeRegressor()
kf = KFold(n_splits=10, shuffle=True, random_state=1)
results = cross_val_score(model, X, y, cv=kf, scoring='neg_mean_squared_error')
print(f'Promedio de los cross validation scores: {np.abs(np.mean(results))}')

Dejo la implementaci贸n de los entrenamientos dentro del ciclo for de la 煤ltima parte. Es decir, c贸mo usar los 铆ndices generados por KFold y usar una medida como la que ven铆amos usando antes para la p茅rdida (mean_squared_error):

# se importa adicional a las que ya se tienen
from sklearn.metrics import mean_squared_error

if __name__ == "__main__":

    dataset = pd.read_csv('./data/happiness.csv')

    X = dataset.drop(['country', 'score'], axis=1)
    y = dataset['score']
    
    model = DecisionTreeRegressor()

    kf = KFold(n_splits=3, shuffle=True, random_state=42)
    losses = []
    for train, test in kf.split(dataset):
        X_train = X.iloc[train]
        X_test = X.iloc[test]
        y_train = y[train]
        y_test = y[test]
        model.fit(X_train, y_train)
        predictions = model.predict(X_test)
        loss = mean_squared_error(y_test, predictions)
        losses.append(loss)

    print('Error para cada partici贸n: ', losses)
    print('Promedio de los errores: ', np.mean(losses))

Aqu铆 les comparto mi implementaci贸n del KFold:

X = dataset.drop(['country','rank', 'score'], axis=1)
y = dataset[['score']]

k_fold = KFold(n_splits=3, shuffle=True, random_state=2)
dtr = DecisionTreeRegressor()
mse = []

for train_index, test_index in k_fold.split(X):

  # X_train
  X_train = pd.DataFrame(X.iloc[train_index, :], columns= list(X))
  X_train = X_train.reset_index().drop('index', axis = 1)

  # X_test
  X_test = pd.DataFrame(X.iloc[test_index, :], columns= list(X))
  X_test = X_test.reset_index().drop('index', axis = 1)

  # y_train
  y_train = pd.DataFrame(y.iloc[train_index, :], columns= list(y))
  y_train = y_train.reset_index().drop('index', axis = 1)

  # y_test
  y_test = pd.DataFrame(y.iloc[test_index, :], columns= list(y))
  y_test = y_test.reset_index().drop('index', axis = 1)

  dtr.fit(X_train, y_train)
  y_predit = dtr.predict(X_test)

  mse.append(mean_squared_error(y_test, y_predit))

print(mse)

COMPLETO

import pandas as pd
import numpy as np

from sklearn.metrics import mean_squared_error

from sklearn.tree import DecisionTreeRegressor

from sklearn.model_selection import (
cross_val_score, KFold
)

dataset = pd.read_csv(鈥榝elicidad.csv鈥)
X = dataset.drop([鈥榗ountry鈥, 鈥榮core鈥橾, axis=1)
y = dataset[鈥榮core鈥橾

model = DecisionTreeRegressor()

score = cross_val_score(model, X,y, cv=5, scoring=鈥榥eg_mean_squared_error鈥)
print (鈥淢SE para cv=5, 5 valores鈥)
print(score)
print(np.abs(np.mean(score)))

print("")

kf = KFold(n_splits=3, shuffle=True, random_state=42)
mse_values = []

for train, test in kf.split(dataset):
X_train = X.iloc[train]
X_test = X.iloc[test]

y_train = y[train]
y_test = y[test]

model = DecisionTreeRegressor().fit(X_train,y_train)
predict = model.predict(X_test)
mse = mean_squared_error(y_test,predict)
mse_values.append(mse)

#model.fit(X_train, y_train)
#predictions = model.predict(X_test)

#.append(mean_squared_error(y_test,predict))

print('Error para cada partici贸n: ', mse_values)
print('Promedio de los errores: ', np.mean(mse_values))

Mi implementaci贸n de K-Folds

lst = []
cv = 1
for train , test in kf.split(X,y= y): 
    # datasets 
    X_train = pd.DataFrame(X.iloc[train,:], columns=X.columns)
    y_train = pd.DataFrame(y.iloc[train,])
    X_test  = pd.DataFrame(X.iloc[test,:], columns=X.columns)
    y_test  = pd.DataFrame(y.iloc[test,])
    
    #Modelo
    dt = DecisionTreeRegressor().fit(X_train,y_train)
    y_predict = dt.predict(X_test)
    lst.append(mean_squared_error(y_predict, y_test))
    print(f'The error for the folder number {cv} =',mean_squared_error(y_predict, y_test))
    cv += 1
    
print(f'\nThe mean of ther erros is equal to {np.mean(lst)}')

Resultado

The error for the folder number 1 = 0.260119109314712
The error for the folder number 2 = 0.21976508857008575
The error for the folder number 3 = 0.23677062451690725
The error for the folder number 4 = 0.31030546626208927

The mean of ther erros is equal to 0.2567400721659486