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

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

13/34
Recursos

Aportes 60

Preguntas 11

Ordenar por:

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

import numpy as np
class_names = [0,1]
fig, ax = plt.subplots()
tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)

sns.heatmap(pd.DataFrame(cnf_matrix), annot = True, cmap="Blues_r", fmt="g")
ax.xaxis.set_label_position("top")
plt.tight_layout()
plt.title("Matriz de confusion", y=1.1)
plt.ylabel("Etiqueta Actual")
plt.xlabel("Etiqueta de prediccion")```

Matriz de confusión
Representación gráfica que nos permite ver el grado de acierto de nuestro modelo. El gráfico tiene cuatro divisiones: Verdaderos Positivos (VP), Falsos Positivos (FP), Falsos Negativos (FN) y Verdaderos Negativos (VN). Siendo los datos verdaderos los que nos interesa maximizar (valores de la diagonal).

Graficado de la Matriz de Confusion:

  • Los datos necesarios los obtenemos de nuestro modelo (con ayuda del módulo metrics):
cnf_matrix = metrics.confusion_matrix(y_test,y_pred)
  • Definimos los ejes con sus respectivas etiquetas
class_names = [0,1]
fig,ax = plt.subplots() #obtenemos las variables figura y ejes del gráfico (nos permite cambiar los atributos propios de cada seccion)
tick_marks = np.arange(len(class_names))  #definimos los valores que van a tener las líneas de guía
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names) #definimos los tick marks en el gráfico
  • Creamos la presentación del gráfico
sns.heatmap(pd.DataFrame(cnf_matrix), annot = True, cmap='Blues_r', fmt='g')
ax.axis.set_label_position('top')
plt.tight_layout()
plt.title('Matriz de confusion', y=1.1)
plt.y_label('Etiqueta Actual')
plt.x_label('Etiqueta de Prediccion)
- seaborn nos permite crear un mapa de calor a partir de los valores entregados (la matriz de confusión en este caso), los parámetros que entregamos son: annot → permite colocar los valores sobre el gráfico, cmap → estilo del gráfico, fmt → formato de los valores
- ax.xaxis,set_label_position() → nos permite definir donde colocar la etiqueta del eje x
- plt.tight_layout() → crea un padding en torno al gráfico (lo enmarca)

Nota

  • Otra forma de evaluar nuestro modelo es a través del método accuracy_score del módulo metrics:
metrics.accuracy_score(Y_test,y_pred)

Bueno, donde trabajo, con mi equipo nosotros clasificamos estudiantes el alto riesgo de deserción al siguiente periodo académico. Igual usamos regresión logística, ya que nos interesa mucho la alta interpretabilidad que nos da este modelo.

saludos.

En una entrevista técnica me solicitaron resolver el siguiente problema: a partir de muchos (millones) de datos de usuarios (desordenados y en varios csv con diferentes columnas con información de todo tipo) de cierta plataforma hacer un modelo que indique si el usuario iba a suscrbirse por mas de dos años. En ese entonces no sabía ni siquiera tratar tanta cantidad de datos. Luego aprendí pandas y ahora que se un poco de scikit y de pytorch siento que era un ejercicio no tan complicado.

Podríamos predecir si un estudiante entendió lo que se explicó en una clase.

muy útil para problemas de clasificacion binaria.

lo utilizaría para poder predecir si es fraude o no.

Una formas mas sencilla aunque menos grafica
pd.crosstab(Y_test ,y_pred ,rownames=[‘Etiqueta actual’], colnames=[‘Etiqueta de prediccion’])

¡Hola!
Soy estudiante de medicina y me gustaría aclarar algunos conceptos interesantes sobre la diabetes por si alguno tiene curiosidad:

  • La diabetes es una enfermedad del metabolismo (es decir, la falla está en los procesos bioquímicos de nuestro cuerpo que se encargan de convertir los alimentos en energía)

  • La diabetes se caracteriza por glucosa alta en sangre (se llama Hiperglucemia).

  • La glucosa es una de las moléculas energéticas más importantes, del grupo de los azúcares o lo que también llamamos carbohidratos (este nombre es más correcto)

  • Generalmente esta enfermedad inicia en pacientes mayores de 40 años de edad (es muy raro verlo en pacientes más jóvenes, y si lo vemos, pensamos en que esta pueda tener un origen genético

  • El cuerpo requiere, para procesar correctamente la glucosa, de una proteína llama Insulina que entre otras funciones disminuye la cantidad de glucosa en sangre

  • Lo que pasa en el cuerpo de un paciente con diabetes es que, por muchas posibles causas, su cuerpo no está procesando correctamente esta glucosa.

La razón más común de esto es que, por una dieta inadecuada (alta en carbohidratos) a lo largo de muchos años, el cuerpo es incapaz de producir la cantidad suficiente de Insulina para compensar la alta concentración de glucosa en sangre .

Esto produce toxicidad en las células del cuerpo de quien padece diabetes, debido a que la glucosa en altas concentraciones resulta tóxica para muchos órganos.
Entre los problemas más relevantes causados por diabetes en un paciente previamente sano, se encuentran:

  • Ceguera
  • Daño al riñón (que puede causar falla renal)
  • Problemas en la circulación de sangre de las piernas del paciente (lo que puede causar hasta la muerte de parte de la pierna del paciente por falta de nutrientes y falta de protección del sistema inmune contra virus y bacterias, y, en muchos casos, requerir de amputación)
  • Muerte a edad relativamente temprana o problemas relacionados al daño al corazón (como infarto).

La diabetes puede reducir la esperanza de vida (la cantidad máxima de años que una persona viviría normalmente estando sana) en hasta 10 años.

Una aclaración. En Wikipedia y otras fuentes la matriz de confusión viene con la siguiente convención para los axes:

Sin embargo, en Scikit-Learn, por defecto, es esta:

En la misma documentación lo menciona:

Wikipedia entry for the Confusion matrix (Wikipedia and other references may use a different convention for axes).

Por lo tanto, tendríamos que leer la matriz de confución de nuestro código así:

Dicho esto, en realidad tenemos 117 verdaderos negativos y 36 verdaderos positivos.


Estuve un rato largo investigando para concluir esto. 😅
Aquí les dejo algunas fuentes:

Si un paciente puede padecer una enfermedad renal crónica el año siguiente, de acuerdo a un ciertas variables de riesgo

Creo que la regresión logística se puede aplicar para identificar si un equipo en una planta va a fallar. Se requerirían datos de condiciones de proceso claves (que afecten el tipo de falla que se quiere analizar) de momentos en los que ha fallado y de otros en los que ha funcionado bien para enseñar al algoritmo.

  • Podríamos saber si una pieza fabricada está en buen estado o con fallas

Si es fraude o no.

  • si una persona es un cliente potencial o no segun la segmentacion que hagamos y sus caracteristicas.

Para evitar que salga la advertencia de iteraciones agregamos la siguiente línea antes del entrenamiento:

logreg.max_iter = len(y_test)

como nota, si la matriz es cercana o mas bien, es cero, es que es negativa. el primer elemento (izquierda arriba) es verdadero negativo, y así 😃

y que bueno, la mayoría no tiene diabetes , uuuf

Podríamos usar este modelo para predecir, con base en los signos clínicos que presente un paciente (temperatura, saturación de oxígeno, tos, etc), si un paciente tiene COVID-19 o no.😎 (o incluso predecir si se recuperará sin requerir ventilación mecánica)

Para mi se me hace más fácil con este codigo:

from sklearn.metrics import confusion_matrix

fig = plt.subplots(figsize=(10,10))
matrix = confusion_matrix(y_test, y_pred)
sns.heatmap(matrix, annot = True, fmt ='d', cmap ='Blues', square = True)
plt.xlabel("predicted")
plt.ylabel("actual")
plt

Hola compañeros

¿Será que los datos de la profesora son diferentes?

Los datos varían por poco

A mi me salió así:

para evaluar las features que involucran a un buen aprendizaje de los alumnos de una materia

Para predecir si un cliente comprará o no un producto

para predecir el estado de animo y saber como hay que dirigirse a esa persona

Muy interesante
la podriamos utilizar en la prediccion de Churn

Cuando hago el código en windows y corro el código en terminal no me muestra la matriz de confusión. Alguna idea para arreglar?

todas las clasificación que sean binarias.
comer tacos
estudiar o no
levantarme de la cama o no
todo los dobles negativos ejej

Para ampliar lo visto en la clase sobre la Matriz de confusión les recomiendo visitar la publicación Confusion Matrix in Machine Learning de GeekForGeeks.

Modificando la Matriz de Confusión

Si desean reorientar la matriz de confusión y extraer sus valores, solo es necesario realizar algunos cambios:

tp, fn, fp, tn = metrics.confusion_matrix(y_test, y_pred, labels=[0,1]).reshape(-1)
print('Confusion Matrix Parameters: \n', tp, fn, fp, tn)

Creo que se puede aplicar este algoritmo para detectar:

  • Si una persona o animal posee cierta enfermedad o no
  • Si mañana llueve o no llueve
  • Si un producto lanzado al mercado será bien recibido o no
  • Si la metodología de aprendizaje utilizada por el profesor hace que sus estudiantes aprendan o no
  • etc.

Hola, les comparto mi código:

#!/usr/bin/env python
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
import argparse
import logging
import matplotlib.pyplot as plt
import matplotlib
import seaborn as sns


matplotlib.use('Agg')

logger = logging.getLogger(__name__)

def regresion_logistica(load):
    feature_cols = ['Pregnancies', 'Insulin', 'BMI', 'Age', 'Glucose', 'BloodPressure', 'DiabetesPedigreeFunction']
    x = load[feature_cols]
    y = load.Outcome
    X_train,X_test, Y_train, Y_test = train_test_split(x,y, test_size = 0.25, random_state =0)
    logreg = LogisticRegression(max_iter=200)
    logreg.fit(X_train, Y_train)
    y_pred = logreg.predict(X_test)
    cnf_matrix = metrics.confusion_matrix(Y_test,y_pred)
    accuracy = metrics.accuracy_score(Y_test, y_pred)
    print(f'La exactitud del modelo es de: {accuracy}')
    return cnf_matrix

def graficar_matriz(matriz):
    class_names = [0,1]
    fig, ax= plt.subplots()
    tick_marks = np.arange(len(class_names))
    plt.xticks(tick_marks, class_names)
    plt.yticks(tick_marks, class_names)

    sns.heatmap(pd.DataFrame(matriz), annot=True, cmap = 'Blues_r', fmt = 'g')
    ax.xaxis.set_label_position('top')
    plt.tight_layout()
    plt.title('Matriz de confusion', y = 1.1)
    plt.xlabel('Etiqueta prediccion')
    plt.ylabel('Etiqueta actual')
    fig.savefig('Matriz.png')


def regresion_lineal_simple(load):
    x = load.iloc[:,:-1].values
    y = load.iloc[:,1].values
    X_train, X_test, Y_train, Y_test = train_test_split(x, y, test_size = 0.2, random_state = 0)
    regressor = LinearRegression()
    regressor.fit(X_train, Y_train)
    viz_train = plt
    fig = viz_train.figure()
    viz_train.scatter(X_train, Y_train, color= 'blue')
    viz_train.plot(X_train, regressor.predict(X_train), color='black')
    viz_train.title('Salario vs experiencia')
    viz_train.xlabel('Experiencia')
    viz_train.ylabel('Salario')
   #viz_train.show(block=True)
    fig.savefig('test.png')
    Scores = regressor.score(X_test, Y_test)
    return Scores

def main(Archivo):
    load = pd.read_csv(Archivo)
    #Scores = regresion_lineal_simple(load)
    #print(f'El performance del modelo es de {Scores}')
    p = regresion_logistica(load)
    graficar_matriz(p)
    print(p)

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('Archivo',
            help = ' El archivo tiene que ser extensión csv',
            type = str)
    args = parser.parse_args()
    main(args.Archivo)

Interesante el presente modelo “Regresión Logistica”, yo lo utilizaré con un data set de clientes, que elaboré en mi trabajo que consta de variables dependientes (regional,actividadEconomica, indiceLiquidez, CapitalNetoDeTrabajo, Rentabilidad, EdeudamientoTotal, EndeudamientoFuturo, genero, estadoCivil, Edad, tipoGarantia) y con la variable indedendiente (MuyBueno, Bueno, Regular, Aceptable, Malo).
El objetivo es utilizar el modelo resultante para clasificar todo nuevo cliente que acude a la institución financiera a solicitar un crédito.
Saludos

  • Para saber si una persona -según sus caracteristicas- encajará bien en un equipo o no.
  • Detectar contenido ofensivo en un mensaje.
  • Para saber si una persona compraría un producto.
  • Para detectar si un material es parte del planeta Tierra o no.
  • Detectar si una persona tiene descendencia de alguna cultura específica.

En el minuto 2:49 la profesora asigna las clases (class_name) como 0 y 1, donde 0 es que no tiene diabetes y 1 que sí tiene diabetes.
Sin embargo, en la matriz de confusión, se leen los positivos como 0 y negativos como 1. Fue un detalle solamente, pero al final lo correcto sería asignar la clase como 0 (sí tiene diabetes) y 1 (no tiene).

Clasificar clientes que van a hacer una compra segun tiempo que ha estado en la pagina web, veces que vio el anuncion de el producto y que tan seguido compra en la compañia.

¡Hola! Soy estudiante de medicina y me gustaría saber si los datos en la tabla son valores tomados de pacientes reales o es un ejemplo arbitrario, además de conocer las unidades en que se expresa cada parámetro.

Esto porque existen pacientes como el que muestro a continuación con los que no estoy de acuerdo con su diagnóstico:

  • Presenta glucosa en rango “normal” (no diabético)
  • No recibe insulina
  • Es muy joven
    -Etc.

A su vez, existen pacientes que presentan presión arterial de 0 o muy baja y datos por el estilo que no corresponden a la realidad (al menos en las unidades en las que estoy pensando que se encuentran).

No es una queja, me parece que la clase es igualmente valiosa y es un modelo muy interesante, tan solo que mi intención era profundizar más en este tema por amor al tema abordado😅.

import pandas as pd
from sklearn import metrics
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
import seaborn as sns
#%matplotlib inline

diabetes = pd.read_csv('diabetes.csv')
print("5 registros diabetes:",diabetes.head(5))
print("forma tabla:",diabetes.shape)

feature_cols = ["Pregnancies","Insulin","BMI","Age","Glucose","BloodPressure","DiabetesPedigreeFunction"]
x = diabetes[feature_cols] #necesario para saber si tiene diabetes
y = diabetes.Outcome #indicador si tiene diabetes

X_train, X_test, Y_train, Y_test = train_test_split(x,y,test_size=0.25, random_state=0)

logreg = LogisticRegression(max_iter=10000000)
logreg.fit(X_train, Y_train)
y_pred = logreg.predict(X_test)
print("Como se clasificaron los datos: (1 tiene diabetes, 0 no tiene diabetes)", y_pred)

#validar resultados con la matriz de confusion
cnf_matrix = metrics.confusion_matrix(Y_test, y_pred)
print("matriz de confusion:",cnf_matrix)

import numpy as np
class_names = [0,1]
fig, ax = plt.subplots()
tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)

sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap='Blues_r', fmt='g')
ax.xaxis.set_label_position('top')
plt.tight_layout()
plt.title('Matriz de confusion', y=1.1)
plt.ylabel('Etiqueta actual')
plt.xlabel('Etiqueta de prediccion')
plt.show()
print("Exactitud:", metrics.accuracy_score(Y_test, y_pred))

Hay muchos ejemplos de aplicaciones. Una empresa que ditca cursos/programas, puede, en base al histórico de notas y otros elementos, saber que estudiantes pueden tomar un siguiente curso. También en la industria de las finanzas para conocer si una persona es apta para recibir un crédito.

La matriz de confusión también se puede realizar de la siguiente manera en pandas:

Al medir el accuracy del modelo con los datos de test nos sale un resultado de 0.807. Sin embargo, si hacemos lo mismo pero con los datos de entrenamiento, sale un accuracy de 0.757. ¿Es pura casualidad que el modelo se ajuste mejor a los datos de test que a los de entrenamiento o es mera coincidencia?

Les dejo un ejemplo de regresión logística para el diagnostico de cancer de mama a partir de un dataset de mediciones del núcleo celular de muestras observadas por microscopio. Probando diferentes features llega a clasificar correctamente el 96%. Dataset de UCI.
Ver en GitHub

Predicción de tumores
Detección de spam
Fraude de Tarjeta de Crédito
Marketing, en las redes sociales para predecir si estaría interesado o no en cierto contenido.

Se podría utilizar en la predicción de valores de una divisa en la bolsa, para verificar la tendencia alcista y bajista.

Super bueno !

Este tipo de modelo, lo podríamos aplican en las instituciones académicas para analizar la deserción de estudiantes.

Dato curioso, utilize la funcion para randomizar la distribucion de los datos, y dio un peor resultado en los positivo, pero un mejor resultado en los negativos 😮

a mi me dío 100%, tendrá algo que ver el conjunto de datos?

Buena noche, se puede predecir si una persona que solicita un credito bancario, es apta o no

Hola

para ver si las personas tiene problemas psicologicos, si algun producto será aceptado en el mercado, para notificaciones en los celulares, etc.

DATO IMPORTANTE: La matriz de confusión confusion_matrix de sklearn tiene como output con los siguientes valores

[True Negative  False Positive]
[False Negative  True Positive]

Primero los negativos y después los positivos. Cuando lo mas usual de ver es

[True Positive  False Negative]
[False Positive  True Negative]

Primero los positivos y después lo negativos.
True Positive: Son los valores acertados correctamente de los positivos predichos.
**False Positive:**Son los valores erróneos de los positivos predichos.
True Negative: Son los valores acertados correctamente de los negativos predichos.
**False Negative:**Son los valores erróneos de los negativos predichos.

EJEMPLO:
SI los valores los valores reales (y_test) de predicción y_pred y son:

y_test =  [1, 0, 0, 1, 0, 1]
y_pred = [1, 1, 0, 1, 0, 1] 

Entonces los valores quedarían de la siguiente manera:
True Positive = 3
False Positive = 1
True Negative = 2
False Negative = 0
Y la matriz de confusión quedaría:

[3  0]
[1  2]

Pero si usamos las métricas de sklearn da esto:

metrics.confusion_matrix(y_test, y_pred)
**Output**
[2  1]
[0  3]

Es todo 😄

En caso que aparezca el siguiente mensaje:
/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
https://scikit-learn.org/stable/modules/preprocessing.html
Please also refer to the documentation for alternative solver options:
https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression
extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)

Puedes utilizar esta sentencia:

logreg = LogisticRegression(max_iter =1000)

Así:

logreg = LogisticRegression()
logreg = LogisticRegression(max_iter =1000) # <---- Así
logreg.fit(X_train, y_train)
y_pred = logreg.predict(X_test)```

Lo utilizaría en el mantenimiento preventivo, por ejemplo de materiales rodantes (autos, caminos, subtes). De esta manera según el estado de sus componente sabría si podría quedar fuera de servicio.

En el caso del diagnostico de diabetes se prefiere que el modelo prediga un falso ( no diabetes) postivo para diabetes, a un positivo ( si diabetes) falso para diabetes. Sin embargo estos modelos contienen un limite de clasificación default en 50% lo cual es una probabilidad muy alta.

importante complementar esta clase con los conceptos de sensibilidad y especificidad en la curva ROC.

Hay que tener en cuenta que la matriz de confusión debe ir acompañado del contexto y otra información para evaluar el modelo. Esto se puede ver en el siguiente ejemplo.
Supongamos que se quiere hacer un modelo que basado en unos datos médicos, diga si un paciente tiene o no un tipo de cáncer muy especifico. Si la probabilidad de tener ese cáncer es del 2%, entonces el modelo que le dice a todos los pacientes “usted no tiene cáncer”, va a tener por matriz de confusión un acierto del 98%. El problema es que no le detecta la enfermedad a ninguna las personas enfermas. Siempre hay que tener el mente el contexto cuando se evalúa un modelo.

Dejo el link de la documentación de la librería seaborn para seaborn.heatmap que fue la usada para la matriz de confusión

https://seaborn.pydata.org/generated/seaborn.heatmap.html

Buenas explicaciones. Bastante claro.

Clasificacion de Hematomas en el cerebro

Cantidad de personas que pueden sobrevivir a tratamientos