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

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

23/34
Recursos

Aportes 18

Preguntas 7

Ordenar por:

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

Les comparto un código para hacer el calculo del numero de cluster usando el método del codo mencionado en la clase anterior

from sklearn.cluster import KMeans

wcss = []
for i in range(1, 11):
    kmeans = KMeans(n_clusters=i, max_iter=1000, random_state=0)
    kmeans.fit(x)
    wcss.append(kmeans.inertia_)
plt.plot(range(1, 11), wcss)
plt.title('Elbow Method')
plt.xlabel('Number of clusters')
plt.ylabel('WCSS')
plt.show()

lo que me dio como resultado

Ahí se ve que según la técnica del codo el numero k = 3 es el numero de clusters ideal.

Acá debemos de tener cuidado en como se calculo el accuracy ya que esta truqueado el ejemplo, es obvio que va a funcionar mejor con 3, ¿Porqué?
Y_iris tiene valores entre 0 y 2

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

entonces, al ejecutar el modelo con K = 2, solo nos puede arrojar valores de predicción de 0 o 1:

Predictions [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]

Lo mismo pasa si ejecutamos el modelo con K = 4, nos va dar valores el modelo de 3, los cuales Y_iris no tiene

Por lo tanto, esta manera de calcular el numero de K es a mi punto de vista incorrecta, ya que de antemano ya sabemos que son 3.

Más abajo alguien comenta el método del codo, el cual se puede ver mejor como calcular el numero de K, graficando el valor de “inertia”, les recomiendo que lo agreguen a su código 😃

dic_acc = {}

for i in range(1,11):
  model = KMeans(n_clusters = i, max_iter=1000)
  model.fit(x)

  y_pred = model.predict(x)

  acc = metrics.adjusted_rand_score(Y_iris,y_pred)

  dic_acc[i] = 1.0 - acc

plt.plot(list(dic_acc.keys()), list(dic_acc.values()))
plt.xlabel('K´s Numerb')
plt.ylabel('Error')
plt.show()

Hola, les comparto como hice variar las K para hallar el optimo.

ks = [i for i in range(2, 10)] # Genero una lista con los valores de K
scores = []

for i in ks:
    # Variamos el valor de K
    model = KMeans(n_clusters=i, max_iter=1000) # Variamos K
    model.fit(x) # Entrenamos el modelo 
    
    y_labels = model.labels_ 
    
    y_kmeans = model.predict(x) # Creamos predicciones
    
    accuracy = metrics.adjusted_rand_score(Y_iris, y_kmeans) # Revisamos la precicion del modelo
    scores.append(accuracy)
    

optimo = ks[scores.index(max(scores))]
model_op = KMeans(n_clusters=optimo, max_iter=1000)
model_op.fit(x)
    
y_labels_op = model_op.labels_ 
    
y_kmeans_op = model_op.predict(x)
    
accuracy = metrics.adjusted_rand_score(Y_iris, y_kmeans_op) 
print(f'Max accuracy: {round(accuracy,5)}% \nUsando {optimo} Ks')

tengo unas ganas de saber todo jajaja

Evaluación del modelo
Podríamos decir que nuestra evaluación será semi-supervisada puesto que usamos los datos del target del data set, simplemente comparamos nuestros resultados con los datos del target (accuracy). El número de grupos (k) óptimo será el que mejor accuracy tenga.

en un caso real no se tiene el target por lo tanto, como se podria saber el accuracy???

![](

tengo una ganas de hacer un sistema de recomiendo de caminar, y de rostro para abrir una puerta


Tomando la idea de Marco Antonio, prueba y error entre 2 a 8

from sklearn.cluster import KMeans
from sklearn import datasets
import pandas as pd

import matplotlib.pyplot as plt
from sklearn import metrics

iris = datasets.load_iris()

x = pd.DataFrame(iris.data, columns = [‘Sepal Lenght’, ‘Sepal Width’, ‘Petal Length’, ‘Petal Width’])

DataToTrain = x
DataTarget = iris.target

K_optimo = 0;
Mejor = 0

for K in range(2,8):

# Variamos K
model = KMeans(n_clusters= K, max_iter=1000) 

#Se entrena modelo
model.fit(DataToTrain)  

y_labels = model.labels_ 

#Creamos prediccion
y_kmeans = model.predict(DataToTrain) 

# Revisamos la precicion del modelo
accuracy = metrics.adjusted_rand_score(DataTarget, y_kmeans) 
print(K,' ',accuracy)

if accuracy > Mejor:    
    K_optimo = K
    Mejor = accuracy

print(’’)
print(f’Max accuracy: {round(Mejor,3)}% \nUsando K: {K_optimo} ')

Para ver la diferenciación que ha realizado el algoritmo, podemos definir una lista de colores como sigue:

colors = []
for int in y_kmeans:
    if int == 0:
        colors.append('b')
    else:
        colors.append('r')

De forma que a la predicción 0 le asigna el color azul, y a la predicción 1 le asigna el color rojo.

Ahora para ver esto en el plot, lo que hacemos es en el atributo color indicamos la lista previamente creada.

plt.scatter(x['Petal Length'], x['Petal Width'], c=colors)
plt.xlabel('Petal Length', fontsize=10)
plt.ylabel('Petal Width', fontsize=10)
plt.show()

Esta es mi solución con la ayuda de mis compañeros en los comentarios para la estandarización

from sklearn.cluster import KMeans 
from sklearn import datasets #Nos permite cargar el data_Set tiene varios populares
from sklearn.preprocessing import StandardScaler #PAra estandarizar
import pandas as pd #para facilitar el trabajo de mirar la info
import matplotlib.pyplot as plt # para poder mirar visualmente
import numpy as np


def wine():
    acurracy1=0

    for i in range(1,11):
        wine = datasets.load_wine()
        variables = np.array(wine.feature_names)
        X_wine= wine.data
        Y_wine=wine.target

        x= pd.DataFrame(standar(X_wine), columns=variables)
        y= pd.DataFrame(wine. target, columns=['Target'])

        plt.scatter(x['alcohol'], x['ash'], c='blue')
        plt.xlabel('alcohol', fontsize=10)
        plt.ylabel('ash', fontsize=10)
        
        model=KMeans(n_clusters=i, max_iter=1000)

        model.fit(x)
        y_labels= model.labels_

        y_kmeans= model.predict(x)

        from sklearn import metrics
        acurracy2=acurracy1
        acurracy1= metrics.adjusted_rand_score(Y_wine, y_kmeans)

        if acurracy2 > acurracy1:
            print(acurracy1)
            plt.scatter(x['alcohol'], x['ash'], c=y_kmeans, s=30)
            plt.xlabel('alcohol', fontsize=10)
            plt.ylabel('ash', fontsize=10)
            plt.show()
            break

def standar(X_wine):
    scaler= StandardScaler()
    scaler.fit(X_wine)
    X_scalar=scaler.transform(X_wine)

    return X_scalar


def main():
    wine()

if __name__ =='__main__':
    main()

El resultado:

Para el reto me ayude con los comentarios de algunos compañeros, la estandarización de los datos fue lo que mas me ayudo.
La verdad recién estoy empezando con esto y por lo tanto no descarto que tenga una falla grande en mi código o mi lógica.
El código esta separado en funciones para hacerlo mas amigable.

from sklearn.cluster import KMeans
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import metrics


def upload_dataset():
    dataset_wine = datasets.load_wine()
    X_wine = dataset_wine.data
    Y_wine = dataset_wine.target

    x = pd.DataFrame(standard_data(X_wine), columns=dataset_wine.feature_names)
    y =pd.DataFrame(Y_wine, columns=['Target'])
 
    plt.scatter(x['alcohol'], x['color_intensity'])
    plt.xlabel('Alcohol')
    plt.ylabel('Color_intensity')
    plt.show()

    training(x, Y_wine)


def standard_data(X_wine):
    scaler = StandardScaler()
    scaler.fit(X_wine)
    x_scalar = scaler.transform(X_wine)

    return x_scalar


def training(x, Y_wine):
    model = KMeans(n_clusters = 3, max_iter = 1000)
    model.fit(x)
    y_labels = model.labels_
    y_kmeans = model.predict(x)

    accuracy(y_kmeans,Y_wine)
    graph_model(x,y_kmeans)

 
def accuracy(Y_wine, y_kmeans):
    accuracy = metrics.adjusted_rand_score(Y_wine, y_kmeans)
    print("Exactitud: ", round((accuracy * 100),2), '%')


def graph_model(x,y_kmeans):
    plt.scatter(x['alcohol'], x['color_intensity'], c=y_kmeans, s=30)
    plt.xlabel('Alcohol')
    plt.ylabel('Intensidad del color')
    plt.show()


def main():
    upload_dataset()

if __name__ == '__main__':
    main()

RESULTADOS


Creamos el modelo

model = KMeans(n_clusters=2, max_iter=1000)
model.fit(x)
y_labels = model.labels_

n-clusters es la similitud a K, lo que nos va a permitir generar los centroides en nuestro valor de X, Y. Cada uno de esos grupos está definido por n clusters, lo siguiente es que tenemos que iterar, que es el siguiente parámetro, y esa iteración es cómo vamos a mover K hasta encontrar las distancias más cercanas en cada uno de esos puntos, anteriormente mostrados en el plano X, Y.

Creamos las predicciones

y_kmeans = model.predict(x)
print(f'Predicciones {y_kmeans}')

Predicciones [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0]

Probamos el accuracy

from sklearn import metrics

accuracy = metrics.adjusted_rand_score(y_iris, y_kmeans)
print(accuracy)

0.5399218294207123

Con el resultado obtenido podemos decir que es un mal modelo, porque la predicción es prácticamente como arrojar una moneda al aire.

Código para encontrar el número de ideal centroídes

Gracias danielfzc

wcss = []
for i in range(1, 11):
    kmeans = KMeans(n_clusters=i, max_iter=1000, random_state=0)
    kmeans.fit(x)
    wcss.append(kmeans.inertia_)
plt.plot(range(1, 11), wcss)
plt.title('Elbow Method')
plt.xlabel('Number of clusters')
plt.ylabel('WCSS')
plt.show()

Podemos observar que el número de centroides ideales es 3. Probamos con el código y verificamos que el accuracy es de 0.7302382722834697.

Se puede validar el accuracy para ver si es menor a 70 por ejemplo cambiar mediante el programa el numero de centroides ?

Dado que en la clase el factor que se tuvo en cuenta para seleccionar el mejor valor de K fue el accuracy, realicé este sencillo método para probar varios valores y graficar el resultado:

bow_accuracy_array = []
for n in range(1,11):
  Kmodel = KMeans(n_clusters=n, max_iter=1000)
  Kmodel.fit(x)
  KLabels = Kmodel.labels_
  predict = Kmodel.predict(x)
  bow_accuracy_array.append(metrics.adjusted_rand_score(iris.target, predict))
plt.plot(range(1,11),bow_accuracy_array, marker='+')
plt.xlabel('n_clusters', fontsize=12)
plt.ylabel('accuracy', fontsize=12)
plt.title('Cálculo de K')

En la gráfica se ratifica que K=3 es el valor adecuado:

Excelente tema.