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

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Visualización del árbol de decisión

20/34
Recursos

Aportes 34

Preguntas 11

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Se obtiene el árbol pero hubiese sido interesante se analizara el árbol y mencionar cosas al menos ligeramente sobre el indice de Gini que es el que por defecto asume sklearn, pero también se hubiera podido usar “entropy” para hablar del Gain_info. tambien faltó mencionar que una vez obtenido se puede pensar en hacer una “poda” del árbol que mejore el modelo. y de los diagramas de complejidad que te permite ayudarte en este proceso.

A alguno le interesa crear un grupo de wpp donde vayamos tirando data sobre ML y los cursos?

La graficación del árbol se puede hacer de manera más fácil haciendo

from sklearn.tree import plot_tree

plt.figure(figsize=(14, 8))
plot_tree(decision_tree = tree_one, feature_names = dummy_encoded_train_predictors.columns, filled = True, fontsize=10);

Y modifiquen

tree_one = tree.DecisionTreeClassifier(max_depth=3)

Para que no salga un árbol gigante, difícil de leer. La diferencia de este método con el de la clase, es que aquí no se guarda en un archivo de imagen, sino que se muestra directo en Jupyter/Colab.

En caso de estar utilizando Jupyter Notebooks y les marque el error "import pydotplus 4 5 out = StringIO() ModuleNotFoundError: No module named ‘pydotplus’”
Me resulto realizar los siguiente:

  1. conda config --add channels conda-forge
  2. conda install pydotplus
  3. reinician kernel para poder utilizar el paquete actualizado
    fuente: https://stackoverflow.com/questions/55463363/even-after-pip-install-pydotplus-it-says-no-module-named-pydotplus-what-should

Cuando ejecuto el ultimo bloque, no me corre correctamente

out= StringIO()
tree.export_graphviz(tree_one, out_file= out)

graph= pydotplus.graph_from_dot_data(out.getvalue())
graph.write_png('titanic.png')

Este es el error: InvocationException: GraphViz’s executables not found

Visualización del árbol

  • Importamos los módulos necesarios
from io import StringIO #nos permite trabaja con archivos externos
from IPython,display import Image, display #permite interactuar y crear imágenes
import pydotplus #permite usar el lenguaje graphviz para crear imágenes
  • Exportamos los datos a graphviz y luego los representamos en un archivo png:
out = StringIO()
tree.export_graphviz(tree_one, out_file=out) # exportamos los datos del árbol en lenguaje graphviz a StringIO
graph = pydotplus.graph_from_dot_data(out.getvalue()) #generamos el gráfico a través de pydotplus
graph.write_png('titanic.png') #guardamos el archivo en formato png

Falta recalcar o hablar un poco sobre que variables le ayudaron a nuestro arbol a tener una mejor predicción o imprimirlas ya que casa columna tiene un score diferente

Este link es simple, y me explico muy como interpretar el arbol de decision y como hacer predicciones, ALTAMENTE RECOMIENDO VER ESTE LINK

https://www.w3schools.com/python/python_ml_decision_tree.asp

Es muy tedioso leer todo el arbol recuerden que tambien podemos imprimir cuantas ramas queremos observar

max_depth = profundidad del arbol

Este fue el método que usé para importar el .csv y que funcionara bien en Jupyter Notebooks, no me funcionó el método de sklearn entonces tuve que descargarlo por aquí https://gist.github.com/netj/8836201 y hacerle este tratamiento, este es mi granito de arena por si le sirve a alguien, si encuentran algún error por favor háganlo saber 😃

iris = pd.read_csv(‘data/iris.csv’, header = 0)
x_iris = iris.iloc[:,:-1]
y_iris = iris.iloc[:,4].values
x = pd.DataFrame(x_iris.values, columns= [‘Sepal Length’, ‘Sepal Width’, ‘Petal Length’,‘Petal Width’])
y = pd.DataFrame(y_iris, columns = [‘Target’])

#Factorizar los valores de objects a numeros
y[‘Target’] = pd.factorize(y[‘Target’])[0]
y[‘Target’].value_counts()```

Definitivamente lo que hace grande a Platzi es su comunidad, hay que revisar siempre los comentarios. Si seguía el curso tal cual, no notaba la diferencia con respecto al accuracy mencionado en comentarios anteriores y el uso de los valores en el entrenamiento.

Hay más características importantes a analizar en el árbol de decisión, que deberían ser por lo menos, mencionadas.

Si no fuese por los comentarios cualquiera que recién inicia se pierde.

La visualización del árbol se lee así:

¿El pasajero es hombre (Sex_female=0)? Si se cumple toma el camino de la izquierda. En caso de que se haya cumplido lo anterior ahora pregunta ¿La edad del pasajero es menor de 13 años? Nuevamente, si se cumple toma el camino de la izquierda. Y así.

Luego, ‘samples’ se refiere a cuántos pasajeros caen dentro de esa condición (cada cuadro). Y ‘value’ se refiere a cuántas personas no sobrevivieron y cuántas sobrevivieron. Si por ejemplo: sample = 29 y value = [9, 20] tenemos que 29 pasajeros caen en esa condición, de los cuales sobrevivieron 20.

Como reto hay que hacer el recorrido del árbol resultante en Pre Orden. ^^

En caso de error al generar el gráfico del árbol de decisión EN UBUNTU, hay que instalar ‘graphviz’:

sudo apt-get install graphviz

Visualización del árbol de decisión

  • Lo complicado es poder encontrar el aprendizaje, la división. Si no se tuviera un modelo de aprendizaje sería muy difícil encontrar la relación, esa es la importancia de un modelo de aprendizaje supervisado.

Cuando usar un árbol de decisión (Decision tree)?

Cuando quieres manejar datos numéricos y categóricos para predecir el target.

En caso de que alguien tenga problemas con su jupyter lab o notebook, para correr el grafico, recuerden instalar los modulos. Para hacerlo directamente en la notebook

!pip3 install pydotplus
!pip3 install graphviz

y si aun asi tienen el problema, me sirvio instalarlo en la terminal, con el siguiente comando obtenido de StackOverflow

sudo apt-get install graphviz
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

sns.set()

test_df = pd.read_csv('titanic-test.csv')
train_df = pd.read_csv('titanic-train.csv')
print("Primeros registros:",train_df.head())

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

from sklearn import preprocessing
label_encoder = preprocessing.LabelEncoder()

#VAMOS A REALIZAR EL LIMPIADO DE LA TABLA

# convertir labeles a numeros
encoder_sex = label_encoder.fit_transform(train_df['Sex'])
print("nueva modificacion a la tabla:",train_df.head())

#reemplazar age datos vacios en la media de age
train_df['Age'] = train_df['Age'].fillna(train_df['Age'].median())
#reemplazar emarked datos vacios con s
train_df['Embarked'] = train_df['Embarked'].fillna('S')

#eliminar datos que no son utiles
train_predictors = train_df.drop(['PassengerId', 'Survived', 'Name', 'Ticket', 'Cabin'], axis=1)

#obtener variables categoricas
categorical_cols = [cname for cname in train_predictors.columns if train_predictors[cname].nunique()<10 and train_predictors[cname].dtype=='object']
print("categorical_cols:", categorical_cols)

#obtener variables numericas
numeric_cols = [cname for cname in train_predictors.columns if train_predictors[cname].dtype in ['int64', 'float']]
print("numeric_cols:", numeric_cols)

#juntar las variables categoricas con las numericas
my_cols = categorical_cols + numeric_cols

train_predictors = train_predictors[my_cols]

#permite generar informacion aleatoria
dummy_encoded_train_predictors = pd.get_dummies(train_predictors)
print("dummy_encoded_train_predictors:", dummy_encoded_train_predictors.head())
print("como dividio los datos:",train_df['Pclass'].value_counts())

"""

    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
    > uando 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().

"""

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_features_one, y_target)

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

Este es el resultado, pero como se había dicho antes: Está sobre entrenado (overfiting).

Si tienen problemas en Ubuntu/Jupyter Notebook, pueden usar lo siguiente:
!pip3 install pydotplus
!pip3 install graphviz
y si el error persiste, abren una terminal y escriben el siguiente código
sudo apt-get install graphviz
Espero sirva de mucha ayuda

Despues de instalar el graphviz con la instruccion:

pip install graphvid

como descandome el instalable de la pagina

https://www.graphviz.org/download/

y seguir dandome error…

La solucion estuvo en volver a arrancar el entorno de jupyter-notebook.

PD: en el instalable descargado permitir escribir el PATH en la instalacion, asi no hay que hacerlo luego manualmente.

Espero os sea de ayuda

Vaya.

Que gran curso. Se aprende mucho en este mismo.

Código para visualizar la imagen el colab

import cv2
from google.colab.patches import cv2_imshow

img = cv2.imread("titanic.png")
cv2_imshow(img)

Tuve problemas con graphviz; yo uso Visual Studio Code, pero igual funciona con Jupyter. El error que me aparecía era el siguiente: graphviz’s executables not found

Para resolverlo abrí la terminal de anaconda y escribí

conda install graphviz

Normalmete quedará guardado en la siguiente ruta en tu PC:
C:\Users\username\Anaconda3\Library\bin\graphviz

Una vez realizado lo anterior agrega esa ruta en tus rutas (PATH) de Variables de Entorno; para ello sigue lo siguiente:
Control Panel > System and Security > System > Advanced System Settings > Environment Variables > Path > Edit > New

Finalmente te recomiendo que cierres ya sea tu pestaña en Jupyter o la app de VS Code y vuelvas a entrar y ejecutes nuevamente todo.

Para más información visita este link en la respuesta 32.

Problemas con dependencias, en mi caso use deepnote

!pip install IPython pydotplus

código

from io import StringIO
#from IPython.dilplay import Image, display
import IPython
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 los que no les funcione (como a mi) el 'pydotplus’
ejecuten esto primero: !pip install pydotplus

Para quienes estén usando Mac y Jupiter Notebook, les aparece el problema “InvocationException: GraphViz’s executables not found”

Se puede solucionar instalando el paquete de graphviz con HomeBrew

brew install graphviz

hola! Esta es una prueba súper famosa en kaggle , es una plataforma muy buena para practicar ml!. Si quieren intentar terminar el reto en la página esto les puede ayudar:

  • tuve problemas llenando la edad con la media, si les ocurre eso es mejor hacer esto
train_data['Age'].fillna(train_data['Age'].mean(), inplace=True)
  • hay que tratar los datos de test_data.csv tal cual como con los del training

  • usé .predict() para generar los resultados y esto lo uní con los passengerid así

presenting_info = {
    'PassengerId':test_data['PassengerId'].values,
    'Survived': survivals_prediction
}
presenting_info = pd.DataFrame(presenting_info)
  • Dataframe.to_csv() te servirá para convertir el archivo en un .csv

  • al subir a Kaggle obtuve 0.715 de accuracy, ahora lo siguiente sería encontrar la forma de hacerlo más accurate. 😃

MI árbol luce algo diferente

me manda error GraphViz’s executables not found y ya instale por pip graphviz que podra ser?

Documentación Oficial Arboles en Scikit Learn

https://scikit-learn.org/stable/modules/tree.html