Creando un clasificador con Scikit-Learn

algunas cosas que comentar que pueden ser utiles

• cuando se hace el drop intentando eliminar algunas variables que no serán de interés, axis = 1 indica que estas variables son "columnas ", axis = 0 , indicaría que son filas.
• las dummy variables que se mencionan ligeramente convierten las variables categóricas en indicadoras como 0,1,2,…etc
• cuando se completaron los valores faltantes en las variables edad y la clase del pasajero (embarked), faltó mencionar un comando muy util para saber en que variables se tienen valores faltantes. Se puede usar train_df.isnull.any().

Cuando se llenan los espacios con vacíos (fillna), para el caso de datos numéricos se utiliza la mediana porque es una de las medidas de tendencia central que menos se afecta por los datos atípicos.

Para el caso de los datos categóricos relacionados con el embarque, se utiliza la letra S porque representa el embarque en la ciudad de South Hampton, en donde más personas se unieron al viaje.

Estos datos se obtienen de un análisis previo a los datos trabajados.

Tratamiento de Datos

• Para transformar datos cualitativos a un código que entienda la máquina podemos usar un label encoder, se encuentra en el módulo preprocessing:

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

Obtenemos así un encoder para la columna Sexo (no usaremos este encoder, usaremos el método de dummies)

• Completaremos los valores nulos de Age (con la media de edades) y Embarked (con ‘S’; embarcados en Southampton)

train_df.Age = train_df.Age.fillna(train_df.Age.median())
train_df.Embarked = train_df.Embarked.fillna('S')

• Eliminamos la columnas que no consideramos necesarias

train_predictors = train_df.drop(['PassengerId','Survived','Name','Ticket','Cabin'], axis=1) #axis=1 se refiere a las columnas (axis=0 → filas)

• Separamos las columnas categóricas de las numéricas:
  • Para detectar la columnas categóricas analizamos la columna con dtype (debe ser igual a ‘object’), consideramos además que no haya mas de 10 diferentes valores (como factor de seguridad)

categorical_cols = [cname for cname in train_predictors.columns if train_predictors[cname].nunique() <10
                    and train_predictors[cname].dtype=='object']

- Para detectar la columnas numéricas analizamos la columna con dtype (debe ser igual a 'int64' o 'float64')

numerical_cols = [cname for cname in train_predictors if
                  train_predictors[cname].dtype in ['int64','float64']]

-  Unimos nuevamente las columnas en una sola variable pero con los datos numéricos separados de los categóricos

my_cols = categorical_cols+numerical_cols
train_predictors = train_predictors[my_cols]

• Usamos el método get_dummies para codificar las variables numéricas

dummy_encoded_train_predictors = pd.get_dummies(train_predictors)

• Ahora tenemos nuestra data sin valores vacíos y codificada, lista para entrenar nuestro algoritmo

• Ésta línea: encoder_sex = label_encoder.fit_transform(data_set_train[‘Sex’]) , transforma una etiqueta textual a un equivalente numérico.
• Ésta línea: categorical_cols = [cname for cname in train_predictors.columns if
  train_predictors[cname].nunique() <10 and
  train_predictors[cname].dtype == ‘object’
  ]
  Encuentra las columnas que contiene información no numérica.
• Ésta línea: numerical_cols = [cname for cname in train_predictors.columns if
  train_predictors[cname].dtype in [‘int64’, ‘float64’]
  ]
  Encuentra las columnas con datos numéricos.

Estoy bien? o entendí algo mal. Quedo a la espera de sus comentarios. gracias.

Si a alguno de ustedes no les quedo muy en claro cómo funciona la instrucción ". get_dummies() " , en este video lo esplican muy bien.

https://www.youtube.com/watch?v=0s_1IsROgDc

Una manera mas sencilla de filtrar las columnas a mi parecer, parece un poco mas enredoso por que todo se hace con funciones y propiedades de pandas, pero les recomiendo mucho aprender ha usar esta libreria.

number_cols = df_train.select_dtypes(include = 'number').columns.tolist()

categorical_cols = ( df_train.select_dtypes(include='object').nunique() < 10 )
categorical_cols = categorical_cols[categorical_cols == True].index.tolist()
number_cols, categorical_cols

Con la funcion select_dtypes puedes muestra el valor de las columnas que tengan ese tipo ( Los tipos de todas columnas se puede ver con el metodo info o con la propiedad dtypes), puedes incluir o excluir los tipos, como en ese caso solo nos interesan las columnas usamos la propiedad columns del DataFrame y lo convertimos a una lista con la funcion tolist

Para las variables categoricas es un poco mas complejo ya que la primer parte devuelve un objeto de tipo Series de pandas como indices tiene todas las columnas del tipo seleccionado y como valor es un valor booleano ( True o False ) depende de si cumple la condicion ( En ese caso, que el numero de datos unicos sea menor a 10 ) y al final solo filtro la Serie para quedarme con los valores que cumplen con la condicion ( valor True ) y como los indices son las columnas me quedo solo con los indices y lo convierto a una lista

No entendí realmente por qué después de separar los datos categóricos y los númericos, a train_predictors se le asigna los mismos datos pero organizados diferente, pero sigue siendo lo mismo.

No entendí para que se hace el LabelEncoder en la columna Sex, pero nunca se lo utiliza.

No entiendo la utilidad de contar los valores de la columna ‘Pclass’ al final del video. La profesora solo lo hace y da una explicación muy vaga y ambigua al respecto. “Cuáles son las clases de este entrenamiento, cómo es que lo ha dividido”. ¿Qué significa eso? ¿No se supone que esa columna venía en el dataset original y no fue incluida dentro de la manipulación de los datos? Esta clase es la peor del curso hasta ahora, muy mal explicada…

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

%matplotlib inline  
sns.set()

test_df = pd.read_csv('/content/titanic-test.csv')
train_df = pd.read_csv('/content/titanic-train.csv')

train_df.head()


train_df.info()

train_df.Sex.value_counts().plot(kind='bar', color =['b', 'r'])
plt.title('Distribucion de sobrevivientes')
plt.show()


from skelearn preprocessing
label_encoder = preprocessing.LabelEcoder()
encoder_sex = label_encoder.fit_transform(train_df['sex'])
train_df.head()
train_df['Age'] = train_df['Age'].fillna(train_df['Age'].median())
train_df['Embarked'] = train_df ['Embarked'].fillna('S')

#Eliminar datos inensarios
train_predictors = train_df.drop(['PassengerId','Survived', 'Name','Tciket', 'Cabin'], axis = 1)

categorical_cols = [cname for in train_predictos.columns if 
                    train_predictors[cname].nunique() < 10 and 
                    train_predcitors[cname].dtype  == 'object'  
                                       
                    ]            

numerical_cols [cname for cname in train_predictors.columns if train_predictors[cname].dtype in ['int64', 'float64']]
my_cols = categorical_cols + numeric_cols
train_predictors = Train_predictors ['my_cols']

dummy_encoded_train_predictors = pd.get_dummies(train_predictors)
train_df ['Pclass'].value_counts()

#variable predictora
y_target = train_df ['Survived'].values
x_features_one = dummy_encoded_train_predictors

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

#prediccion
tree_one = tree.DecisionTreeClassifier()
tree_one = tree_one.fit(x_features_one, y_target)

#que tan cercano predice
tree_one_accuracy = round (tree_one.score(x_features_one, y_target), 4)
print('Accuracy:  %0.4f' % (tree_one_accuracy))

from io import StringIO
from IPython.display import Image, display
import pydotplus

out = StringIO
tree.export_graphviz(tree_one, out_file=out)
graph = pydotplus.graph_from_dot_data(out.getvalue())
graph.write_png('titanic.png')```

Para saber si tenemos elementos nulos en nuestro dataset y en que columnas, usamos

trainTitanicDataset.isnull().any()

Que da como resultado:

PassengerId    False
Survived       False
Pclass         False
Name           False
Sex            False
Age             True
SibSp          False
Parch          False
Ticket         False
Fare           False
Cabin           True
Embarked        True
dtype: bool

Recordemos que la columna Cabin fue descartada con la funcion .drop, por lo que no fue necesario rellenar sus valores nulos.

Un error en el min 3:31 escribió la mediana en lugar de la media

Muchas cosas en el aire… Pero bueno, algo sacamos, ahí vamos avanzando.

Me sentí súper perdido en esta clase
Realmente creo que buscaré más inofrmación aparte…
¿Alguna recomendación?

En el minuto 1:48 la profesora dice que quiere ver “qué información tenemos una vez que hacemos el encoder”, pero se trae el head del dataset original. Le faltó decir que train_df[‘Sex’] = encoder_sex.

Me parece insólito que después de hacer el head() no se dé cuenta de que no hizo ese paso tan importante y que perfectamente puede confundir mucho a los estudiantes con poca práctica.

Deberían ser más rigurosos con el contenido, y si una clase queda mal hecha (como es este caso), hacerla de nuevo, ya que es más importante que sus alumnos aprendan a que ustedes ahorren recursos.

Una manera de llenar los datos faltantes de la edad, es, utilizar una nube de datos alrededor de la media, para ser más preciso, una desviación estándar de la media, de esta meneara nos adherimos un poco más a la distribución de los datos.

mean = np.mean(train_df.append(test_df)['Age'])
    std  = np.std(train_df.append(test_df)['Age'])
    nans = dataset['Age'].isna().sum()
    
    
ramdom_age = np.random.randint(mean - std , mean + std , size=nans)
    copy = dataset['Age'].copy()
    copy[copy.isna()] = ramdom_age
    dataset['Age'] = copy
    dataset['Age'] = dataset['Age'].astype(int)

Cuando la profesora completo los datos de la edad no utiliza la media como ella lo dice, si no utiliza la mediana que no en todos los casos son iguales.

Sugiero tener más cuidado con las palabras que se utilizan para explicar los conceptos. Para alguien que no maneje ciertos contenidos, una palabra puede hacer la diferencia entre comprender algo o no y esto puede ser fatal. En el minuto 5:29 la profesora dice “Todo esto se encuentra en la posición 1 de nuestro dataset” cuando en realidad ese parámetro (axis) determina si estamos hablando de columnas o filas. axis=0 significa filas, axis=1 columnas.

Error en su codigo, al hacer get_dummies() solo ejecuta el metodo en la ultima columna “Embarked”(lo clasifica en embarked_C,embarked_Q y embarked_S ), hagan un print para verificar.
Si quieren aplicar get_dummies a una tabla con varias columnas seria asi:
pd.get_dummies(data = table_name , columns = columns_names ), o sea

pd.get_dummies(data = train_predictors, columns = my_cols )

Que mal que cometan estos errores, confunden cuando uno no se da cuenta.

no entendí muy bien el paso de categorical_cols y numerical_cols

Se puede hacer exactamente lo mismo con este código:

cat_col = ['Sex','Embarked']
df_cat = pd.get_dummies(train[cat_col])
df_cat

#Concatenar dos dataframes
train_dummies = pd.concat([train_predictors, df_cat], axis=1)
train_dummies.drop(['Sex','Embarked'], axis = 1, inplace = True)
train_dummies

Algo que no me parece correcto es eliminar variables porque si. Entiendo que para facilitar el curso es mucho mejor borrar estas variables del dataframe, pero al hacerlo no se menciona que se pierde información VALIOSA.

Para los que se quedaron con la dudas del dummy:
Lo que hace es transformar variables categóricas a cero y uno pero tomando en cuanta todas las posibilidades.

• Para el caso de Sex: Dummies me devuelve dos columnas una por cada categoría como esta en la siguiente imagen:
  imagen:

  

• Para el caso de Embarked: Dummies me devuelve 3 columnas ya que hay 3 categorías como en la siguiente figura:
  imagen:

  

De esto es importante entender que no necesitamos todas las columnas solo necesitamos las K-1, donde K es el numero de categorías. Es decir, podemos eliminar una columna de cada categoría. Para este caso en particular quedaría así:

dummy_encoded_train_predictor = pd.get_dummies(train_predictors, columns=['Sex','Embarked'], drop_first=True )

Obtendríamos la siguiente tabla final:

NOTA: en la clase no lo hicieron de esta forma no sabría decir porque, pero la información la saque del siguiente video que explica bien la lógica de dummies video

En el minuto 3:30 dice media pero usa la mediana

otra forma de obtener las columnas categoricas y numericas:

numerical_cols = train_predictors.select_dtypes(include=['int64','float64']).columns

Dummies, lo que hace es dividir las columnas de “categorias” que tengan un valor no numerico (como por ejemplo una letra), si revisan la tabla van a ver que tiene 3 columnas mas

Aunque la columna Pclass es de tipo entero, yo creo que debería de ser una variable categórica y no numérica

• Los datos categóricos aparecen cuando una variable se mide en una escala que solo incluye a los posibles encuestados en un número limitado de grupos. Por ejemplo, una encuesta donde se recoge información sobre variables como el género, estado civil o afiliación política. Fuente: Tema 1: Introducción al Análisis de datos Categóricos

• Una variable ficticia o dummy variable es aquella para reemplazar una variable no cuantificable y que toma solo el valor 0 o 1 para indicar la ausencia o presencia de algún efecto categórico que se puede esperar que cambie el resultado. Fuentes: Dummy variable y Variable ficticia

Un aporte constructivo para esta clase es que cuando la profe hace imputación de datos ella dice que reemplaza los datos faltantes por la media en el caso de “Age” y no es así .Estrictamente lo que ella utilizo fue la MEDIANA que es “median” si fuese la media tendría haber digitado “mean()”.

Error en la codificación de la Linea de código por parte de la profesora

Compañeros, no entendí exactamente que es cname y como funciona la siguiente estructura
cname for cname in …
Recuerdo que la estudie en cursos anteriores, pero no recuerdo donde
Si alguien me pudiera ayudar estaría muy agradecido
Saludos

Me parece que la Dra. Yesi muestra las diversas formas en las que se puede transformar los valores categoricos en numericos, de forma puntual con :

label_encoder.fit_transform(train_df['sex'])

Separando las variables en conjuntos, para convertirlos los categoricos unicamente y luego juntarlos con los numericos

categorical_cols 
numerical_cols

o usando get_dummies para hacerlo de golpe todo.

dummy_encoded_train_predictors = pd.get_dummies(train_predictors) 

Asi lo entendi.

correccion de errores

recomiendo corrijan esta clase, ya que al colocar partes del codigo donde no se explica su funcionamiento o donde nisiquiera se usa el codigo solo genera muchas confusiones.
mencionare algunos errores:

• la maestra menciona que se usara la media para llenar valores nulos
• en la clase no sirvio de nada hacer:

from sklearn import preprocessing
label_encoder = preprocessing.LabelEncoder()

encoder_sex = label_encoder.fit_transform(train_df['Sex'])

y

categorical_cols = [cname for cname in train_predictors.columns if
                        train_predictors[cname].nunique() < 10 and
                        train_predictors[cname].dtype == 'object'
                        ]
numerical_cols = [cname for cname in train_predictors.columns if
                train_predictors[cname].dtype in ['int64', 'float64']
                ]
print(categorical_cols, numerical_cols)

my_cols = categorical_cols + numerical_cols
train_predictors = train_predictors[my_cols]

ya que pd.dummy hizo todo el trabajo , en relaidadtodo el codigo que se necesitaba era:

train_df['Age'] = train_df['Age'].fillna(train_df['Age'].median()) # la mediana
train_df['Embarked'] = train_df['Embarked'].fillna('S')

train_predictors = train_df.drop(['PassengerId', 'Survived', 'Name', 'Ticket', 'Cabin'], axis = 1)

dummy_encoded_train_predictors = pd.get_dummies(train_predictors)
dummy_encoded_train_predictors.head()

y literalmente obtendriamos el mismo dataset preparado que el de la clase

Por si eres distraido como yo y tardaste en entender por que embarked y Age, al inicio con el describe pudimos notar que tenian un numero de non nulls menor al total de filas

Esta clase se pone cada vez más buena. Muchas gracias Yesi!!!

Guiado por la sección de preguntas he notado muchas personas confundidas por estas lineas de código:

Estas lineas hacen referencia a un for para recorrer las columnas, simplemente la profesora hizo
List Comprehension, este tema se toca en los cursos de python aquí en Platzi es parte de la ruta de Data Science,

categorical_cols = [cname for cname in train_predictors.columns if train_predictors[cname].nunique() < 10 and train_predictors[cname].dtype == 'object'

Escoge los mejores features

Es importante realizar un análisis estadístico para saber cuales variables independientes (features) son significativos en tu modelo, ya que en varias ocasiones muchos de ellos no aportan nada al modelo. De igual forma, es importante ver si existen correlaciones entre ellos, puesto que en ocasiones una variable podría representar el comportamiento de las demas. Esto es útil para optimizar recursos computacionales y tiempos de entrenamiento.

TODO HASTA EL MOMENTO CON COMENTARIOS
EN ALGUNOS CASOS SI DESEA MAS INFORMACION ELIMINE COMENTARIO

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 < 10 y tipo objeto

TENGO DUDA DE PORQUE nunique< 10 ???

categorical_cols = [cname for cname in train_predictors.columns if
train_predictors[cname].nunique() < 10 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’]

pd.get_dummies(train_predictors)
estamos convirtiendo datos categórigos en datos numéricos

Me siento iluminado al ver el curso por segunda vez 😄

Para saber cual es la cantidad de nulos que se tienen con pandas es:

df.isna().sum()

El resultado indicará la cantidad de nulos por columna

La definición de las variables en el data set del titanic:
https://www.kaggle.com/c/titanic/data

Basic Feature Engineering with the Titanic Data:

https://triangleinequality.wordpress.com/2013/09/08/basic-feature-engineering-with-the-titanic-data/

Recomiendo leer esto para entender mejor preprocessing.LabelEncoder

Dummies, lo que hace es dividir las columnas de “categorias” que tengan un valor no numerico (como por ejemplo una letra), si revisan la tabla van a ver que tienen nuevas columnas.
Esto es util porque reemplaza lo de usar “encoders” todo el rato

Algunos puntos que es importante saber:
-label_encoder

Codifica etiquetas de una característica categórica en valores numéricos entre 0 y el número de clases menos 1

El metodo fit lo entrena (crea un mapeado entre las etiquetas y los numeros dichos anteriormente

El metodo transform, transforma las etiquetas que se incluyan como argumento

Fuentes:
https://www.interactivechaos.com/python/function/labelencoder#:~:text=LabelEncoder codifica etiquetas de una,número de clases menos 1.&text=El único atributo de esta,cada etiqueta en el array).

Las variables dummies, podríamos decir, que separa ciertas etiquetas o columnas de acuerda a la variedad de sus datos

Sería bueno cursos donde expliquen las librerías mas usadas, ya sé que existe la documentación y el curso de Pandas pero mejoraría la comprensión de los estudiantes si ya tenemos experiencias usandos estás librerías

Tengo una observación, al utilizar las siguientes lineas de codigo:

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

no se le asigno al DataFrame train_df original, es decir no se guardo el cambio, por lo que la columna train_df[‘Sex’] no surtió efectos.