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.

• É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.

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

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.

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')```

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

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

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)

no entendí muy bien el paso de categorical_cols y numerical_cols

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

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

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.

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.

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

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’]

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

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/

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

Recomiendo leer esto para entender mejor preprocessing.LabelEncoder

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 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.

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.