Fundamentos prácticos

1

Aplica Platzidoro en este curso y asegura el éxito de tu aprendizaje

2

Los fundamentos de machine learning que aprenderás

3

Introducción a Numpy

4

Introducción y manipulación de datos con Pandas

5

Introducción a ScikitLearn

6

Comandos básicos de las librerías usadas en el curso (Numpy, Pandas y ScikitLearn)

Regresión Lineal y Logística

7

¿Qué es la predicción de datos?

8

Sobreajuste y subajuste en los datos

9

Regresión lineal simple y regresión lineal múltiple

10

Regresión lineal simple con Scikit-Learn: división de los datos

11

Regresión lineal simple con Scikit-Learn: creación del modelo

12

Regresión logística con Scikit-Learn: definición y división de datos

13

Regresión logística con Scikit-Learn: evaluación del modelo

14

Matriz de confusión

15

PlatziDoro Cápsula 1

Árboles de decisión

16

¿Qué es un árbol de decisión y cómo se divide?

17

Comprendiendo nuestro data set para la creación de un árbol de decisión

18

Creando un clasificador con Scikit-Learn

19

Entrenamiento del modelo de clasificación

20

Visualización del árbol de decisión

K-Means

21

¿Qué es K-Means?

22

Cargando el data set de Iris

23

Construcción y evaluación del modelo con K-Means

24

Graficación del modelo

25

PlatziDoro Cápsula 2

Aprendizaje profundo

26

Introducción al aprendizaje profundo

27

Conceptos básicos de Tensor Flow

28

Red neuronal convolucional

29

Conociendo el set de datos para la creación de la red neuronal

30

Crea y entrena tu primera red neuronal convolucional con Tensor Flow

31

Evaluación de la red convolucional

32

PlatziDoro Cápsula 3

Despedida

33

Recomendaciones para analizar correctamente tu problema

34

Siguientes pasos para continuar aprendendiendo de Machine Learning

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Entrenamiento del modelo de clasificación

19/34
Recursos

Aportes 41

Preguntas 9

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Creo que hubo un error al final del video con los datos con los que entrenamos el modelo y con los que calculamos el accuray. Aquí esta la forma cómo creo que se debió probar. De esta forma el accuracy obtenito es de aproximadamente 0.74

x_train , x_test, y_train , y_test =  train_test_split(x_features_one, y_target, test_size= .25, random_state=1)
tree_one = tree.DecisionTreeClassifier()
tree_one = tree_one.fit(x_train,y_train)
tree_one_accuracy = round(tree_one.score(x_test,y_test), 4)
tree_one_accuracy

Varias cosas que creo son importantes aclarar y que he podido aprender por mi parte:

1.- Lo ya mencionado en otros comentarios: Entiendo que fue un error haber entrenado y luego evaluado el estimador (en este caso el árbol de decisión) con los mismos datos y haber hecho caso omiso de los splits hechos con train_test_split. Esto explica el valor tan alto de exactitud (accuracy) que dio el modelo al final; seguramente hubo un overfitting (encima porque no se usó ningún parámetro de regularización como max_depth (más al respecto)) y el modelo terminó memorizando los datos. Sin un X_test para evaluar es difícil saber si el modelo será bueno para predecir nuevas observaciones. De hecho, tal como el mismo sitio de sklearn lo menciona , los árboles de no suelen generalizar bien y tienden a sobreajustarse a los datos de entrenamiento.

2.- De los cursos de ML de platzi que he visto no he podido ver una clase que aborde las diferentes métricas que hay para evaluar el desempeño del modelo, y es algo muy importante. Para clasificadores sólo he visto que muestren accuracy, siendo que NO siempre es la mejor métrica para evaluar un modelo.

  1. Lo anterior lo menciono porque en el minuto 4:40, la profesora da a entender que el accuracy está relacionado con la probabilidad de que el estimador acierte correctamente una predicción, pero sería bueno aclarar que esto no es del todo cierto, sobre todo con datasets con class imbalance (donde el número de observaciones de cada clase no es uniforme). Una métrica más acertada sería el roc_auc_score (el área bajo la curva ROC). (Más info: )

La verdad son errores muy groseros. Para los que ya tenemos base es algo evidente pero al que recién está aprendiendo puede llevarle a confusiones.

usando los datos de validacion, a mi me da el resultado mostrado arriba!

1- Para que hacen el train_test_split si al final no lo van a usar

2-Entrenan al modelo con unos datos(x_features_one) y luego hacen un test del modelo con los mismos datos(??), obviamente asi siempre saldra un score cercano al 100% porque son datos que el modelo ya conoce, es como decirle que 1+1 es 2 y luego preguntarle cuanto es 1+1.Espero que eso haya sido una confusion y no hayan tratado de engañar a otros estudiantes.

3-En la clase pasada cometieron un error con el metodo get_dummies ya que no se aplica a todas las columnas

No se que les pasa Platzi pero como plataforma educativa estan bastante mal, si van a hacer cursos de machine learning haganlos bien porque son errores que no se puede cometer.

Les dejo el notebook con mi análisis; pudiera serle de ayuda a las personas más nuevas para que no se confundan ni se pierdan
https://github.com/semiramisCJ/data_science_notes/blob/master/python/decision_tree_sklearn/bin/decision_tree_titanic.ipynb

Aparte del final, que, como comentan los compañeros, está erróneo. Me ha causado un poco de confusión el preprocessing.LabelEncoder(), está codificando los labels a 0 y 1 pero no aplica al dataframe dichos valores en ningún momento, simplemente no hace nada con ello O_o. Y después utiliza la columna Sex de forma categórica igualmente. Deberían prestar un poco de atención al código que generan, puede confundir a la gente.

Entrenamiento del Modelo

  • Generamos nuestras variables de entrenamiento
y_target = train_df['Survived'].values
x_features_one = dummy_encoded_train_predictors
  • Podemos dividir los datos en entrenamiento y test con train_test_split pero tenemos un csv con datos de test, usaremos estos datos (previamente tratados al igual que los datos de entrenamiento)
y_test = test_df['Survived'].values
x_test = dummy_encoded_test_predictors
  • Entrenamos el modelo:
tree_one = tree.DecisionTreeClassifier()
tree_one.fit(x_train,y_train)
  • Obtenemos el grado de precisión de nuestro modelo con el metodo score:
tree_one_accuracy = tree_one.score(x_test, y_test)

En el video utilizan el comando tree_one = tree_one.fit(x_features_one, y_target) en ves de tree_one = tree_one.fit(x_train, y_train), creo que esto es un error ya que se utiliza la totalidad de los datos, o sea, x_features_one, y no el porcentaje de entrenamiento generado por train_test_split.

me quedan algunas dudas de las clases:

  1. ¿porque el ajuste de los datos antes lo hacíamos solo con los datos de entrenamiento y ahora lo hacemos con todos los datos?
    hago una acotación: a mi me parece mas preciso usar todos los datos posibles para realizar un modelo.
  2. ¿como puedo saber los parámetros y como esta conformado el modelo? me imagino que en algún lado hay una ecuación que vincula los datos de cada individuo con su probabilidad de supervivencia.
  3. vinculado a la pregunta anterior ¿como puedo estimar la probabilidad de supervivencia de un nuevo individuo? porque el modelo estima si sobrevive o no sobrevive, pero en realidad cada persona tiene una determinada probabilidad de sobrevivir.

Espero tu respuesta Yecely, muchas gracias por todo, realmente estoy aprendiendo mucho con este curso

por cierto, aparte de que en la clase se usa el train_test_split para separar el dataset y no se usaron los datos separados.

El dataset de titanic ya fue previamente separado, por eso es que son dos .csv, uno de entrenamiento y otro de prueba, asi que nisiquiera habia necesidad de separar el dataset de entrenamiento, solo comparar los datos con el de prueba.

Si bien hay muchos comentarios al respecto, creo que se han cometido muchos errores que terminan confundiendo y haciendo difícil entender el tema.
El curso es importante, creo que vale la pena una actualización de este no solo con las correcciones, sino prestando un poco más de cuidado a la explicación.

Me parece que al no usar los datos de test_df para calcular el accuaracy, va dejar confundida a muchas persona y va en contra de todo lo que se había explicado con anterioridad, ya que vamos a generar que el modelo memorice.

Bueno, he leído muchos comentarios que dicen que se equivocó con el entrenamiento, que es un error grosero y tales. Aquí les pregunto, ¿errar no es de humanos? y lo más importante, ¿No han prestado la suficiente atención a las clases como para poder corregir el error ustedes mismos?

La solución es fácil, entrenen con los datos de entrenamiento y midan el accuracy con los datos de validación, no hay pierde, estamos empezando, pero no es tampoco cosa del otro mundo.

y_target = train_df['Survived'].values
x_features_one = dummy_encoded_train_predictors.values

x_train, x_validation, y_train, y_validation = train_test_split(x_features_one, y_target, test_size = .25, random_state = 1)

tree_one = tree.DecisionTreeClassifier()
tree_one = tree_one.fit(x_train, y_train)

tree_one_accuracy = round(tree_one.score(x_validation, y_validation), 4)
print(f'tree_one_accuracy: {tree_one_accuracy * 100}%')

PAra que separamos el Data Train del data Test ? ademas de que esto tiene overfitting por que estas utilizando el 100% de los datos.

Para los que quieran saber si hubieran sobrevivido en el titanic deben crear un arreglo de numpy con los atributos del DataFrame dummy_encoded_train_predictors. Sibsp es el número de hijos a bordo y esposa y Parch es número de padres o niños a tu cargo a bordo. En mi caso, no hubiera sobrevivido!

Si no me equivoco, en el entrenamiento, le está pasando todos los datos que ya hemos preprocesado, por lo que la validación es inútil puesto que el modelo conoce tanto los datos de entrenamiento como los de prueba, el entrenamiento se debió pasar el x_train y en la prueba x_validation, mi hipótesis es que el resultado no dió 1 debido a el ruido de los datos, pero de ahí es evidente que el modelo está mal entrenado dado que conoce todos los datos.

No etendi como le hago para agregar yo mi caso particular si con mi edad y status social viviria o moriria en el titanic, donde agrego esos datos para que me diga si muero o vivo?

Por qué se entreno con la totalidad de los datos y se probo igualmente con la misma totalidad con la cual se entreno. Obviamente va a dar 100% o muy cercano a este.

No me queda claro el por qué.

Quizás puede ser algo tonto… pero la implementación de la función round() en el contexto del ejemplo resulta innecesaria…

Hubieron fallos en esta clase, pero lo que mas me sorprendio, fue que utilizamos el dataset de entrenamiento para todo, teniendo a nuestra disposicion el dataset de test. Quiza si usabamos los dos datasets en uno y haciamos todo junto el arbol habria sido mas exitoso

Este es mi código donde he eliminado todo lo repetitivo y uso el set de test, tal vez le pueda ayudar a alguien a aclarar los huecos que se dejan en los videos.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

# Load the data
train_data = pd.read_csv('../../data/external/titanic/titanic-train.csv')
test_data = pd.read_csv('../../data/external/titanic/titanic-test.csv')


# Function to preprocess data
def preprocess_data(data, drop_survived_column=True):
    predictors = data.drop(['PassengerId', 'Name', 'Ticket', 'Cabin'], axis=1)
    if drop_survived_column:
        predictors = predictors.drop(['Survived'], axis=1)
    predictors['Age'] = predictors['Age'].fillna(predictors['Age'].median())
    predictors['Fare'] = predictors['Fare'].fillna(predictors['Fare'].median())
    predictors['Embarked'] = predictors['Embarked'].fillna('S')
    categorical = [cname for cname in predictors.columns if predictors[cname].dtype == "object"]
    numerical = [cname for cname in predictors.columns if
                 predictors[cname].dtype in ['int64', 'float64', 'int32', 'float32']]
    predictors = predictors[categorical + numerical]
    encoded = pd.get_dummies(predictors)
    return encoded


# Create encoded data for training and testing
encoded_train = preprocess_data(train_data)
encoded_test = preprocess_data(test_data, False)

# Create train and test sets
x = encoded_train.values
y = train_data['Survived'].values
x_test = encoded_test.values

# Create and train the model
x_train, x_validation, y_train, y_validation = train_test_split(x, y, test_size=0.2, random_state=0)
tree_one = DecisionTreeClassifier()
tree_one.fit(x_train, y_train)

# Evaluate the model
tree_one_accuracy = tree_one.score(x_validation, y_validation)
print("Accuracy: ", tree_one_accuracy)

# Make predictions over the test set
predictions = tree_one.predict(x_test)
test_data['Survived'] = predictions
print(test_data[['PassengerId', 'Survived']])

# Create CSV file for submission
test_data[['PassengerId', 'Survived']].to_csv('../../data/processed/titanic/submission.csv', index=False)

Reto: creo el CSV para poder hacer una entrega en Kaggle (https://www.kaggle.com/competitions/titanic/leaderboard), el acurracy es ~70% por medio de este método, ¿Cómo puedes mejorar estos resultados?

‘.get_dummies’ sirve para pasar la clasificación de datos tipo texto a datos tipo numérico. Por ejemplo, ‘Sexo = hombre’ pasaría a ‘Sexo_hombre = 1, Sexo_mujer = 0’ y ‘Sexo = mujer’ pasaría a ‘Sexo_hombre = 0, Sexo_mujer = 1’

Pueden revisar la variable ‘dummy_encoded_train_predictors’ para ver cómo cambió la clasificación.

usando train test split
seria de la siguiente forma

tree_one = tree.DecisionTreeClassifier()
tree_one = tree_one.fit(x_train, y_train)

tree_one_accuracy = round(tree_one.score(x_validations, y_validation), 4)
print('Accyracy: %0.4f' % (tree_one_accuracy))
//...accuracy de 0.7489

RESUMEN, SI DESEAN MAS INFORMACION ELIMINEN ‘#’ DE COMENTARIO

HASTA EL MOMENTO NO SE USA EL DATAFRAME dummy_encoded_train_predictors

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import re
import numpy as np
from sklearn import tree
from sklearn.model_selection import train_test_split

#datos prueba / entrenamiento
test_df = pd.read_csv(‘titanic-test.csv’)
train_df = pd.read_csv(‘titanic-train.csv’)

#Exploracion
train_df.info()
train_df.head()
train_df.dtypes

#Si desea explorar por Sexo sin grafica

train_df.Sex.value_counts()

Explore visualizacion de sobrevivientes x Sexo

train_df[train_df[‘Survived’] == 1 ][‘Sex’].value_counts().plot(kind=‘bar’, color=[‘b’,‘r’])

plt.title(‘Distribucion de sobrevivientes’)

#Para ser entendido un dato
#por la maquina, se crea un label encoder
#el modelo usara campo Sex de tipo ‘object’
#el cual puede ser modificado a tipo categoria

from sklearn import preprocessing
label_encoder = preprocessing.LabelEncoder()
encoder_sex = label_encoder.fit_transform(train_df[‘Sex’])
train_df[‘Sex’] = encoder_sex

#Limpiar informacion
#===================

#Manejo de nulos
train_df[‘Age’] = train_df[‘Age’].fillna(train_df[‘Age’].median() )
train_df[‘Embarked’] = train_df[‘Embarked’].fillna(‘S’)

#Los campos que no se pueden predecir eliminelos
#y cree nuevo dataframe
train_predictors = train_df.drop([‘PassengerId’, ‘Survived’, ‘Name’, ‘Cabin’], axis=1)

#Crear lista de columnas categoricas del dataFrame
#Condiciones unicos < de tamano menor a 3 characteres y tipo objeto
#Sino ponemos esta condicion incluye ticket, o bien eliminamos la columna ticket antes
categorical_cols = [cname for cname in train_predictors.columns if
train_predictors[cname].nunique() < 3 and
train_predictors[cname].dtype ==‘object’
]

print(categorical_cols)

-> Resultado [‘Embarked’]

#Si desea explorar valores posibles de Embarked

train_df.Embarked.value_counts()

#Crear lista de columnas numericas del dataFrame
#Condicion int64, float64
numerical_cols = [cname for cname in train_predictors.columns if
train_predictors[cname].dtype in [‘int64’,‘float64’]
]
#print(numerical_cols)

-> Resultado [‘Pclass’, ‘Sex’, ‘Age’, ‘SibSp’, ‘Parch’, ‘Fare’]

#union de los datos
my_cols = categorical_cols + numerical_cols
train_predictors = train_predictors[my_cols]

#crea nuevo dataFrame con las columnas que se escogieron
dummy_encoded_train_predictors = pd.get_dummies(train_predictors)
y_target = train_df[‘Survived’].values
x_features_one = dummy_encoded_train_predictors.values

#verificar el nivel que tendra de exactitud modelo

aun no se usa dummy_encoded_train_predictors

x_train , x_test, y_train , y_test = train_test_split(x_features_one, y_target, test_size= .25, random_state=1)
tree_one = tree.DecisionTreeClassifier()
tree_one = tree_one.fit(x_train,y_train)
tree_one_accuracy = round(tree_one.score(x_test,y_test), 4)
tree_one_accuracy

En honor a la verdad no me quedo muy claro este modelo, toca invertigar por mi parte.
Les dejo este Link:
https://www.youtube.com/watch?v=1D2oOmXs1Vg

Además del problema con el train_test_split que ya han comentado, otra cosa que no tiene sentido es tener dos ficheros CSV, titanic-train y titanic-set. Al principio se leen ambos ficheros en train_df y test_df, pero luego no se utiliza para nada test_df. Debería haberse entrenado el modelo con todos los datos del fichero titanic-train.csv y haberse validado su precisión con los datos del fichero titanic-test.csv.

En la fila de ‘Age’ seguía habiendo un Nan incluso después de haber limpiado los Nan con la media , si alguno presenta este error, pude solucionarlo volviendo a iterar sobre esta fila para agregarle la media en donde existía el Nan, pero lo hice con la variable train_predictors , les dejo las lineas por si les sirve.

my_cols = categorical_cols + numerical_cols

train_predictors = train_predictors[my_cols]

train_predictors['Age'] = train_predictors['Age'].fillna(train_predictors['Age'].median())

Para los que quieren saber como se aplicaría eso con un dato nuevo, aquí le muestro, además aquí se muestra como debería haberse entrenado y calculado el score correctamente

Tengo la siguiente duda u anotación: por que se utilizó el método de separación train_test_split si se supone que íbamos a trabajar con 2 DataFrame por separado. el train_df y el test_df

Utilicé los valores x_train, x_validation, y_train y y_validation obteniendo una precisión de 0.6233, la cual me parece algo menor en comparación con la obtenido por otros compañeros. ¿Alguna sugerencia del por qué?

Entrenamiento del modelo de clasificación

  • Se debe validar que tan bien se está entrenando el modelo. Este proceso se realiza para saber que tan cercano puede agregar una etiqueta dadas las características.

  • 0.9798 significa que es muy buen modelo, indica que cuando llegue un nuevo valor va a tener 97% de probabilidad de que le asigne la etiqueta correcta.

  • Siempre se debe cuidar que los datos estén divididos de una una manera adecuada para no caer en sobreajustes o subajustes.

  • Se tiene que hacer un modelo totalmente generalizado, esto quiere decir, que si llega un nuevo atributo o registro, tendrá que asignarle la etiqueta que le corresponde.

Que pasó con la gráfica? la siguiente clases es “¿Que es K-Means?”

La ultima parte estuvo mal la idea era entrenar con los datos de entrenamiento y probar con los de prueba

x_train, x_test, y_train, y_test = train_test_split(x,y, test_size=.25, random_state=1)
tree= DecisionTreeClassifier()
tree = tree.fit(x_train, y_train)

tree_accuracy = round(tree.score(x_test, y_test), 4)
tree_accuracy

Efectivamente hay confusión en este video del curso, lo que yo veo incorrecto a diferencia de los demás comentarios es esta linea:

x_train, x_test, y_train, y_test = train_test_split(x,y, test_size=.25, random_state=1)

Y en realidad no la usamos para nada, por lo que podríamos decir que todo va bien, eso de entrenar el modelo con todos los datos me parece que es falso, ya que desde un principio el dataset que trabajamos es ya el split que se tiene de entrenamiento y tenemos otro CSV que espero se use para hacer un test del modelo (titanic-test).

Lo que aun no estoy seguro es si el Accuracy se usa sobre los datos de test o de train, por ejemplo si es con los de train, tendría sentido ver cuantos datos pudo clasificar correctamente de nuestra totalidad con la que se entrenó el modelo (0.9798) suena a que los reconoció muy bien, pero no se hasta que momento le podríamos llamar overfiting.

Para ver el Accuracy de los datos de test, primero tendríamos que probar el modelo y aun no hacemos ese paso en este video 😃

Para qué usamos train_test_split si nuestros datos ya están separados inicialmente en dos archivos diferentes de train y de test? Pensé que esto sólo se usaba para separar la totalidad de los datos en train y test pero si ya los tienes de entrada por qué se vuelven a separar?
Había entendido todo hasta ahora, pero ahora sí me perdí.

Creo que le da una accuracy demasiado alta para que alguien experimentado no se de cuenta que hay un error en el modelo. Al entrenar y probar con los mismos datos la precision siempre sera muy cercana y a veces 100

Es verdad que x_train y y_train no fueron usados. Sin embargo no entiendo por qué a ustedes les da 74%, a mi me da incluso más que a la profesora: 98%

Hay errores imperdonables que no deberían existir en nada que se haga llamar curso. Yo soy nuevo en esto y aún así veo presente, desde hace varias clases, los errores y la mala explicación del código, que es vaga y contradictoria. La explicación de los conceptos también es confusa. Afortunadamente, están los compañeros y la web que nos ayudan a poder seguir. Sin embargo, eso no quita que hay defectos graves por superar en este curso.

Si efectivamente hay un error, deberían grabar la clase nuevamente. entreno el modelo con los datos erróneos y eso lleva a confusiones.