Creando un clasificador para la flor Iris con Python
A continuación aprenderás cómo desarrollar un proyecto de Machine Learning. En el proyecto de hoy vamos a construir un clasificador para las flores tipo Iris. Este proyecto es otro de los básicos, como el del Titanic, que se utilizan al momento de estar aprendiendo Machine Learning.
Por lo tanto, comencemos a desarrollar este proyecto.
Definición del proyecto
Los datos lo vamos a obtener de la página de Kaggle, para ello se deben suscribir para poder tener acceso a los mismos, aunque este dataset está también disponible en el repositorio de la Universidad de California, lugar en donde originalmente se publicaron estos datos.
Igual que en los anteriores programas vamos a utilizar como lenguaje de programación Python.
Antes de empezar a programar entendamos un poco este dataset. Este conjunto de datos contiene 50 muestras de cada una de tres especies de Iris: Iris setosa, Iris virginica e Iris versicolor, para cada una de estas especies se midieron cuatro rasgos de cada muestra: la longitud y el ancho del sépalos y pétalos. Los sépalos son los que envuelven a las otras piezas florales en las primeras fases de desarrollo, cuando la flor es solo un capullo, por su parte los pétalos son la parte inferior del perianto y comprende las partes estériles de una flor.
En estas fotos podrás observar la diferencia entre pétalo y sépalo y a su vez la diferencia entre las tres especies de Iris.
Sabiendo todo esto ahora si podemos empezar a programar.
Obtener los de datos
import numpy as np
import pandas as pd
Seguidamente importamos los datos, para ello se descarga el archivo csv de la página de Kaggle y se guarda en el computador en donde se está trabajando. Posteriormente precedimos a leer el archivo para ello utilizamos la instrucción read_csv.
#Importamos el dataset para iniciar el análisis
iris = pd.read_csv("Iris.csv")
Tenemos mucha información dentro de esta variable lo que se nos hace difícil entender la información, por lo tanto, ahora procedemos a entender la data.
Entender los datos
Visualizamos ahora los primeros 5 datos del dataset utilizando la instrucción head.
#Visualizamos los primeros 5 datos del dataset
print(iris.head())
Como podemos observar el dataset cuenta 6 columnas, en donde están las características de ancho y longitud del sépalo y pétalo, a su vez el nombre de cada una de las especies. Pero adicionalmente a todo esto se encuentra una columna llamada ID que está demás, ya que una vez que los datos se convierten en pandas se crea automáticamente una columna con la numeración por lo que podemos eliminar la columna ID. Para esto utilizamos la instrucción drop.
#Eliminamos la primera columna ID
iris = iris.drop('Id',axis=1)
print(iris.head())
Ahora procedemos a analizar los datos. Acá utilizamos todos los comandos necesarios para entender el dataset.
Primeramente, utilizaremos info.
#Análizamos los datos que tenemos disponibles
print('Información del dataset:')
print(iris.info())
Acá nos indica que todas las columnas contienen 150 datos, en las primeras tenemos datos flotantes mientras que la última contiene datos objetos y es justamente acá en donde se encuentra la información de las especies de la flor.
Seguidamente utilizamos describe. En donde podemos observar los datos estadísticos del dataset.
print('Descripción del dataset:')
print(iris.describe())
Por último, verificamos la distribución de los datos de acuerdo a las especies de Iris, para ello utilizamos la instrucción groupby, especificando la columna Species y el tamaño de la misma.
print('Distribución de las especies de Iris:')
print(iris.groupby('Species').size())
Como podemos observar tenemos 50 datos para cada una de las especies, Iris setosa, Iris versicolor e Iris Virginica.
Visualización de los datos
Entendiendo todo esto veamos los datos de manera visual, para ello importamos la librería de matplotlib y procedamos a graficar el dataset.
import matplotlib.pyplot as plt
La gráfica a construir será del tipo dispersión, y vamos a graficar primero los datos correspondientes al sépalo. Colocamos en el eje X los datos de longitud y en el eje Y los datos del ancho, a su vez para cada una de las especies de Iris le colocamos un color. Para los datos del Iris setosa los colocamos de color azul, para el Iris Versicolor será de color verde y para el Iris Virginica colocamos los datos de color rojo.
De igual forma colocamos los nombres correspondientes al eje X y Y y el título de la gráfica y procedemos a graficarlos.
#Grafico Sepal - Longitud vs Ancho
fig = iris[iris.Species == 'Iris-setosa'].plot(kind='scatter', x='SepalLengthCm', y='SepalWidthCm', color='blue', label='Setosa')
iris[iris.Species == 'Iris-versicolor'].plot(kind='scatter', x='SepalLengthCm', y='SepalWidthCm', color='green', label='Versicolor', ax=fig)
iris[iris.Species == 'Iris-virginica'].plot(kind='scatter', x='SepalLengthCm', y='SepalWidthCm', color='red', label='Virginica', ax=fig)
fig.set_xlabel('Sépalo - Longitud')
fig.set_ylabel('Sépalo - Ancho')
fig.set_title('Sépalo - Longitud vs Ancho')
plt.show()
Si te fijas en la gráfica los datos están distribuidos de manera casi uniforme sobretodo los correspondientes al Iris setosa, mientras que los correspondientes a versicolor y virginica tienen cualidades algo parecidas por lo que se solapan en ocasiones.
Ahora procedemos a hacer exactamente lo mismo, pero con la información de los pétalos. Si te fijas el código de programación es exactamente el mismo al anterior lo único diferente es que ahora se especifica los datos del pétalo.
#Grafico Pétalo - Longitud vs Ancho
fig = iris[iris.Species == 'Iris-setosa'].plot(kind='scatter', x='PetalLengthCm', y='PetalWidthCm', color='blue', label='Setosa')
iris[iris.Species == 'Iris-versicolor'].plot(kind='scatter', x='PetalLengthCm', y='PetalWidthCm', color='green', label='Versicolor', ax=fig)
iris[iris.Species == 'Iris-virginica'].plot(kind='scatter', x='PetalLengthCm', y='PetalWidthCm', color='red', label='Virginica', ax=fig)
fig.set_xlabel('Pétalo - Longitud')
fig.set_ylabel('Pétalo - Ancho')
fig.set_title('Pétalo Longitud vs Ancho')
plt.show()
Acá podemos observar una distribución mucho más uniforme en comparación con el sépalo.
Hasta este momento hemos importado los datos, los hemos analizados e inclusive los hemos graficado, por lo que ha llegado el momento de desarrollar el clasificador utilizando los algoritmos de Machine Learning.
Desarrollo del algoritmo
Lo primero que debemos hacer es importar todas las librerías a utilizar, comenzando por train_test_split. Seguidamente por las librerías de los algoritmos, en este caso vamos a trabajar con Regresión Logística, Máquinas de Vectores de Soporte, Vecinos más Cercanos y Árboles de Decisión Clasificación. Recuerda que este es un ejercicio de clasificación por lo que todos los algoritmos a implementar deberán ser para este tipo de problemas.
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
Acá nos vamos a detener un momento para indicar que en realidad podemos construir varios modelos, el primero de será con todos los datos del dataset, es decir para utilizar este modelo deberás tener la información del sépalo y el pétalo para poderlo utilizar. Pero adicionalmente podemos desarrollar otros dos modelos en donde utilicemos solamente los datos del sépalo y otro con el pétalo. Por lo que al final vamos a tener 3 modelos en total. Adicionalmente, para la construcción de nuestro modelo evaluaremos distintos algoritmos de Machine Learning para encontrar el más adecuado.
Entonces comencemos a construir nuestro primer modelo con todos los datos, lo primero que debemos hacer es separar los datos con las características, que vendrían siendo todas menos la columna de especies, a estos datos los vamos a llamar “X” y los datos con las etiquetas o respuestas que sería la columna de especies vendrían siendo la variable “y”.
#Separo todos los datos con las características y las etiquetas o resultados
X = np.array(iris.drop(['Species'], 1))
y = np.array(iris['Species'])
En este punto separamos los datos de entrenamiento y prueba utilizando la instrucción train_test_split.
#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
print('Son {} datos para entrenamiento y {} datos para prueba'.format(X_train.shape[0], X_test.shape[0]))
Ahora si empecemos a aplicar los algoritmos de Machine Learning comenzando con Regresión Logística. Obviamente lo primero que debemos hacer es definir el algoritmo, LogisticRegression, seguidamente lo entrenamos utilizando la instrucción fit y realizamos la una predicción utilizando los datos de X_test. Para determinar la precisión o confianza del algoritmo utilizamos la instrucción score para calcularla.
#Modelo de Regresión Logística
algoritmo = LogisticRegression()
algoritmo.fit(X_train, y_train)
Y_pred = algoritmo.predict(X_test)
print('Precisión Regresión Logística: {}'.format(algoritmo.score(X_train, y_train)))
Con ella nos da un resultado de 0,975, lo cual no esta nada mal pero aún así vamos a verificar con otros algoritmos para ver si mejoramos este número.
Procedemos a desarrollar un nuevo modelo ahora con el algoritmo de Máquinas de Vectores de Soporte, el procedimiento es exactamente igual, primero definimos el algoritmo, en este caso será SVC, lo entrenamos utilizando los datos de entrenamiento, realizamos una predicción y finalmente calculamos la precisión del mismo.
#Modelo de Máquinas de Vectores de Soporte
algoritmo = SVC()
algoritmo.fit(X_train, y_train)
Y_pred = algoritmo.predict(X_test)
print('Precisión Máquinas de Vectores de Soporte: {}'.format(algoritmo.score(X_train, y_train)))
El resultado es de 0,991, un valor mucho mejor que el que obtuvimos con el anterior algoritmo.
Continuemos realizando las evaluaciones de los algoritmos y ahora vamos hacer el cálculo con el algoritmo de K vecinos más cercanos. El procedimiento es el mismo que hicimos con los otros algoritmos, solamente que acá tenemos que definir el número de vecinos que se evaluaran, entonces definimos el algoritmo KNeighborsClassifier y definimos el número de vecinos que sería para nosotros igual a 5, este número podemos cambiarlo y ver como cambia la precisión del algoritmo. Seguidamente entrenamos el algoritmo, realizamos una predicción y finalmente calculamos la precisión del algoritmo.
#Modelo de Vecinos más Cercanos
algoritmo = KNeighborsClassifier(n_neighbors=5)
algoritmo.fit(X_train, y_train)
Y_pred = algoritmo.predict(X_test)
print('Precisión Vecinos más Cercanos: {}'.format(algoritmo.score(X_train, y_train)))
Obtenemos como resultado 0,983, siendo muy parecido al obtenido con el primer algoritmo, por lo que hasta los momentos el modelo obtenido con el algoritmo de Máquinas de Soporte es el mejor.
Evaluemos ahora el algoritmo de Árboles de Decisión Clasificación, definamos el algoritmo que sería DecisionTreeClassifier, seguidamente lo entrenamos y realizamos una predicción y seguidamente calculamos la precisión del mismo.
#Modelo de Árboles de Decisión Clasificación
algoritmo = DecisionTreeClassifier()
algoritmo.fit(X_train, y_train)
Y_pred = algoritmo.predict(X_test)
print('Precisión Árboles de Decisión Clasificación: {}'.format(algoritmo.score(X_train, y_train)))
Acá el resultado es igual a 1, es decir que se puede decir que este modelo es perfecto, por lo que sería el ideal para realizar las próximas predicciones.
Con esto tenemos un modelo creado con todo el conjunto de datos, ahora vamos a desarrollar y evaluar un nuevo modelo pero esta vez solamente con los datos correspondientes al sépalo, es decir que este modelo solamente evaluara estos datos más no los del pétalo.
El procedimiento es muy parecido al anterior la diferencia son los datos que tomares para construir el modelo, entonces empecemos el desarrollo.
Lo primero es definir los datos, como son exclusivamente los del sépalo debemos seleccionar estas columnas, que sería el de la longitud y ancho del sépalo y obviamente la columna correspondiente a la de especies.
#Separo todos los datos con las características y las etiquetas o resultados
sepalo = iris[['SepalLengthCm','SepalWidthCm','Species']]
Definido los datos ahora procedemos a separar las características con las etiquetas, a estos datos los vamos a llamar X_sepalo y Y_sepalo.
X_sepalo = np.array(sepalo.drop(['Species'], 1))
y_sepalo = np.array(sepalo['Species'])
Ahora procedemos a separar los datos de entrenamiento y prueba para proceder a construir los modelos.
#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train_s, X_test_s, y_train_s, y_test_s = train_test_split(X_sepalo, y_sepalo, test_size=0.2)
print('Son {} datos sépalo para entrenamiento y {} datos sépalo para prueba'.format(X_train.shape[0], X_test.shape[0]))
Comencemos con el algoritmo de Regresión Logística, el procedimiento es exactamente igual que hicimos anteriormente, definimos el algoritmo, lo entrenamos, realizamos una predicción y calculamos la precisión del modelo. Ten la precaución acá que los datos que utilizamos deberán ser los correspondientes al sépalo únicamente.
#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train_s, X_test_s, y_train_s, y_test_s = train_test_split(X_sepalo, y_sepalo, test_size=0.2)
#Modelo de Regresión Logística
algoritmo = LogisticRegression()
algoritmo.fit(X_train_s, y_train_s)
Y_pred = algoritmo.predict(X_test_s)
print('Precisión Regresión Logística - Sépalo: {}'.format(algoritmo.score(X_train_s, y_train_s)))
La precisión de este modelo es de 0,75 lo que cual no es tan bueno, por lo que tenemos que evaluar otros algoritmos para verificar si podemos obtener algo mejor.
Por lo tanto, ahora desarrollemos un modelo utilizando el algoritmo de Máquinas de Vectores de Soporte, igual que anteriormente, definimos el algoritmo, lo entrenamos, realizamos una predicción y finalmente calculamos la precisión.
#Modelo de Máquinas de Vectores de Soporte
algoritmo = SVC()
algoritmo.fit(X_train_s, y_train_s)
Y_pred = algoritmo.predict(X_test_s)
print('Precisión Máquinas de Vectores de Soporte - Sépalo: {}'.format(algoritmo.score(X_train_s, y_train_s)))
El resultado obtenido es de 0,825, el cual mejoro comparándolo con el anterior algoritmo, aunque no es el mejor resultado.
Evaluemos el algoritmo de K Vecinos más Cercanos, definimos el algoritmo en nuestro programa, entrenamos el modelo, realizamos una predicción y calculamos la precisión del modelo.
#Modelo de Vecinos más Cercanos
algoritmo = KNeighborsClassifier(n_neighbors=5)
algoritmo.fit(X_train_s, y_train_s)
Y_pred = algoritmo.predict(X_test_s)
print('Precisión Vecinos más Cercanos - Sépalo: {}'.format(algoritmo.score(X_train_s, y_train_s)))
La precisión de este algoritmo es de 0,825, muy parecido al anterior algoritmo, pero aún este resultado no es muy optimo.
Por lo que evaluemos el último algoritmo que sería Árboles de Decisión Clasificación, igual que anteriormente y utilizando los datos correspondientes al sépalo, definimos el algoritmo, lo entrenamos, realizamos una predicción y calculamos la precisión.
#Modelo de Árboles de Decisión Clasificación
algoritmo = DecisionTreeClassifier()
algoritmo.fit(X_train_s, y_train_s)
Y_pred = algoritmo.predict(X_test_s)
print('Precisión Árboles de Decisión Clasificación - Sépalo: {}'.format(algoritmo.score(X_train_s, y_train_s)))
El resultado es de 0,941, siendo este el mejor de los resultados por lo que este es el mejor modelo de todos.
Ahora desarrollemos el último de los modelos que vamos hacer en este proyecto, para este vamos a utilizar los datos correspondientes al pétalo, tanto longitud como ancho y por supuesto la columna de especies que sería la etiqueta.
El procedimiento acá es exactamente igual al anterior, la única diferencia son los datos que vamos a tomar para entrenar el modelo, entonces empecemos con este desarrollo.
Lo primero que debemos hacer es definir las columnas con las que vamos a trabajar, como ya lo indicamos son las correspondientes al pétalo.
petalo = iris[['PetalLengthCm','PetalWidthCm','Species']]
Seguidamente separamos las columnas correspondientes a las características con las etiquetas.
X_petalo = np.array(petalo.drop(['Species'], 1))
y_petalo = np.array(petalo['Species'])
Procedemos a separar los datos de entrenamiento con los de pruebas.
#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train_p, X_test_p, y_train_p, y_test_p = train_test_split(X_petalo, y_petalo, test_size=0.2)
print('Son {} datos pétalo para entrenamiento y {} datos pétalo para prueba'.format(X_train.shape[0], X_test.shape[0]))
Con esto ya podemos realizar las pruebas respectivas con cada uno de los algoritmos igual que lo hicimos anteriormente.
Comencemos con el algoritmo de Regresión Logística.
#Modelo de Regresión Logística
algoritmo = LogisticRegression()
algoritmo.fit(X_train_p, y_train_p)
Y_pred = algoritmo.predict(X_test_p)
print('Precisión Regresión Logística - Pétalo: {}'.format(algoritmo.score(X_train_p, y_train_p)))
Con este algoritmo obtenemos 0,891, que no es un buen resultado, por lo que debemos continuar con las pruebas.
Ahora desarrollamos el algoritmo de Máquinas de Vectores de Soporte.
#Modelo de Máquinas de Vectores de Soporte
algoritmo = SVC()
algoritmo.fit(X_train_p, y_train_p)
Y_pred = algoritmo.predict(X_test_p)
print('Precisión Máquinas de Vectores de Soporte - Pétalo: {}'.format(algoritmo.score(X_train_p, y_train_p)))
La precisión de este algoritmo es de 0,958, lo que es un resultado mucho mejor que el obtenido con el anterior algoritmo.
Evaluemos el algoritmo de K Vecinos más Cercanos.
#Modelo de Vecinos más Cercanos
algoritmo = KNeighborsClassifier(n_neighbors=5)
algoritmo.fit(X_train_p, y_train_p)
Y_pred = algoritmo.predict(X_test_p)
print('Precisión Vecinos más Cercanos - Pétalo: {}'.format(algoritmo.score(X_train_p, y_train_p)))
Con este algoritmo se obtuvo una precisión de 0,975, que es un resultado bueno pero es mucho mejor el obtenido con el anterior algoritmo.
Finalizamos realizando las pruebas con el algoritmo de Árboles de Decisión Clasificación.
#Modelo de Árboles de Decisión Clasificación
algoritmo = DecisionTreeClassifier()
algoritmo.fit(X_train_p, y_train_p)
Y_pred = algoritmo.predict(X_test_p)
print('Precisión Árboles de Decisión Clasificación - Pétalo: {}'.format(algoritmo.score(X_train_p, y_train_p)))
La precisión de este algoritmo es de 1, lo cual es el mejor resultado de todos los algoritmos que evaluamos con estos datos.
Programa completo
A continuación se encuentra el código completo:
"""
Clasificar las plantas Iris
"""
########## LIBRERÍAS A UTILIZAR ##########
import numpy as np
import pandas as pd
########## IMPORTAMOS LOS DATOS ##########
#Importamos el dataset para iniciar el análisis
iris = pd.read_csv("Iris.csv")
#Visualizamos los primeros 5 datos del dataset
#print(iris.head())
#Eliminamos la primera columna ID
iris = iris.drop('Id',axis=1)
#print(iris.head())
########## ANALIZAMOS LOS DATOS ##########
#Análizamos los datos que tenemos disponibles
print('Información del dataset:')
print(iris.info())
print('Descripción del dataset:')
print(iris.describe())
print('Distribución de las especies de Iris:')
print(iris.groupby('Species').size())
########## VISUALIZAMOS LOS DATOS ##########
import matplotlib.pyplot as plt
#Grafico Sepal - Longitud vs Ancho
fig = iris[iris.Species == 'Iris-setosa'].plot(kind='scatter',
x='SepalLengthCm', y='SepalWidthCm', color='blue', label='Setosa')
iris[iris.Species == 'Iris-versicolor'].plot(kind='scatter',
x='SepalLengthCm', y='SepalWidthCm', color='green', label='Versicolor', ax=fig)
iris[iris.Species == 'Iris-virginica'].plot(kind='scatter',
x='SepalLengthCm', y='SepalWidthCm', color='red', label='Virginica', ax=fig)
fig.set_xlabel('Sépalo - Longitud')
fig.set_ylabel('Sépalo - Ancho')
fig.set_title('Sépalo - Longitud vs Ancho')
plt.show()
#Grafico Pétalo - Longitud vs Ancho
fig = iris[iris.Species == 'Iris-setosa'].plot(kind='scatter',
x='PetalLengthCm', y='PetalWidthCm', color='blue', label='Setosa')
iris[iris.Species == 'Iris-versicolor'].plot(kind='scatter',
x='PetalLengthCm', y='PetalWidthCm', color='green',
label='Versicolor', ax=fig)
iris[iris.Species == 'Iris-virginica'].plot(kind='scatter',
x='PetalLengthCm', y='PetalWidthCm', color='red', label='Virginica', ax=fig)
fig.set_xlabel('Pétalo - Longitud')
fig.set_ylabel('Pétalo - Ancho')
fig.set_title('Pétalo Longitud vs Ancho')
plt.show()
########## APLICACIÓN DE ALGORITMOS DE MACHINE LEARNING ##########
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
##################################################################
########## MODELO CON TODOS LOS DATOS
#Separo todos los datos con las características y las etiquetas o resultados
X = np.array(iris.drop(['Species'], 1))
y = np.array(iris['Species'])
#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
print('Son {} datos para entrenamiento y {} datos para prueba'.format(X_train.shape[0], X_test.shape[0]))
#Modelo de Regresión Logística
algoritmo = LogisticRegression()
algoritmo.fit(X_train, y_train)
Y_pred = algoritmo.predict(X_test)
print('Precisión Regresión Logística: {}'.format(algoritmo.score(X_train, y_train)))
#Modelo de Máquinas de Vectores de Soporte
algoritmo = SVC()
algoritmo.fit(X_train, y_train)
Y_pred = algoritmo.predict(X_test)
print('Precisión Máquinas de Vectores de Soporte: {}'.format(algoritmo.score(X_train, y_train)))
#Modelo de Vecinos más Cercanos
algoritmo = KNeighborsClassifier(n_neighbors=5)
algoritmo.fit(X_train, y_train)
Y_pred = algoritmo.predict(X_test)
print('Precisión Vecinos más Cercanos: {}'.format(algoritmo.score(X_train, y_train)))
#Modelo de Árboles de Decisión Clasificación
algoritmo = DecisionTreeClassifier()
algoritmo.fit(X_train, y_train)
Y_pred = algoritmo.predict(X_test)
print('Precisión Árboles de Decisión Clasificación: {}'.format(algoritmo.score(X_train, y_train)))
##################################################################
########## MODELO CON DATOS DE SÉPALO
#Separo todos los datos con las características y las etiquetas o resultados
sepalo = iris[['SepalLengthCm','SepalWidthCm','Species']]
X_sepalo = np.array(sepalo.drop(['Species'], 1))
y_sepalo = np.array(sepalo['Species'])
#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train_s, X_test_s, y_train_s, y_test_s = train_test_split(X_sepalo, y_sepalo, test_size=0.2)
print('Son {} datos sépalo para entrenamiento y {} datos sépalo para prueba'.format(X_train.shape[0], X_test.shape[0]))
#Modelo de Regresión Logística
algoritmo = LogisticRegression()
algoritmo.fit(X_train_s, y_train_s)
Y_pred = algoritmo.predict(X_test_s)
print('Precisión Regresión Logística - Sépalo: {}'.format(algoritmo.score(X_train_s, y_train_s)))
#Modelo de Máquinas de Vectores de Soporte
algoritmo = SVC()
algoritmo.fit(X_train_s, y_train_s)
Y_pred = algoritmo.predict(X_test_s)
print('Precisión Máquinas de Vectores de Soporte - Sépalo: {}'.format(algoritmo.score(X_train_s, y_train_s)))
#Modelo de Vecinos más Cercanos
algoritmo = KNeighborsClassifier(n_neighbors=5)
algoritmo.fit(X_train_s, y_train_s)
Y_pred = algoritmo.predict(X_test_s)
print('Precisión Vecinos más Cercanos - Sépalo: {}'.format(algoritmo.score(X_train_s, y_train_s)))
#Modelo de Árboles de Decisión Clasificación
algoritmo = DecisionTreeClassifier()
algoritmo.fit(X_train_s, y_train_s)
Y_pred = algoritmo.predict(X_test_s)
print('Precisión Árboles de Decisión Clasificación - Sépalo: {}'.format(algoritmo.score(X_train_s, y_train_s)))
print()
print()
##################################################################
########## MODELO CON DATOS DE PÉTALO
#Separo todos los datos con las características y las etiquetas o resultados
petalo = iris[['PetalLengthCm','PetalWidthCm','Species']]
X_petalo = np.array(petalo.drop(['Species'], 1))
y_petalo = np.array(petalo['Species'])
#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train_p, X_test_p, y_train_p, y_test_p = train_test_split(X_petalo, y_petalo, test_size=0.2)
print('Son {} datos pétalo para entrenamiento y {} datos pétalo para prueba'.format(X_train.shape[0], X_test.shape[0]))
#Modelo de Regresión Logística
algoritmo = LogisticRegression()
algoritmo.fit(X_train_p, y_train_p)
Y_pred = algoritmo.predict(X_test_p)
print('Precisión Regresión Logística - Pétalo: {}'.format(algoritmo.score(X_train_p, y_train_p)))
#Modelo de Máquinas de Vectores de Soporte
algoritmo = SVC()
algoritmo.fit(X_train_p, y_train_p)
Y_pred = algoritmo.predict(X_test_p)
print('Precisión Máquinas de Vectores de Soporte - Pétalo: {}'.format(algoritmo.score(X_train_p, y_train_p)))
#Modelo de Vecinos más Cercanos
algoritmo = KNeighborsClassifier(n_neighbors=5)
algoritmo.fit(X_train_p, y_train_p)
Y_pred = algoritmo.predict(X_test_p)
print('Precisión Vecinos más Cercanos - Pétalo: {}'.format(algoritmo.score(X_train_p, y_train_p)))
#Modelo de Árboles de Decisión Clasificación
algoritmo = DecisionTreeClassifier()
algoritmo.fit(X_train_p, y_train_p)
Y_pred = algoritmo.predict(X_test_p)
print('Precisión Árboles de Decisión Clasificación - Pétalo: {}'.format(algoritmo.score(X_train_p, y_train_p)))
Si te llamo la atención todo este contenido y te animaste a empezar a estudiar Inteligencia Artificial, he desarrollado un curso que te ayudará, de igual forma a iniciar tu camino dentro de está tecnología. Este curso te sentará las bases y te dará más claridad para poder seleccionar el enfoque o área que más te interese sobre la Inteligencia Artificial, de igual forma te ayudará tener más claridad en muchos conceptos que seguramente en estos momentos te parece confusos. Este curso es ideal si apenas estás empezando. Si quieres más información puedes ingresar a este enlace.
Muchas gracias por los aportes en PYTHON
Gracias a ti por comentar.
Segui todo tu codigo esta increible,, gracias enseñarnos.
Tienes algun codigo de entranamiento de Red Neuronal con Keras?.
Saludos..
Hola Manuel, muchas gracias por tu comentario. Por los momentos no tengo nada de redes neuronales pero si tengo planificado generar contenido al respecto. Saludos.
Magnifico, para el aprendizaje, muchas gracias, has compartido un compendio pedagógico muy claro, sencillo y directo.
Hola Reinan, muchas gracias por tu comentario y tus palabras. Saludos.
Hola! muchas gracias, excelente explicación. Mi pregunta es: luego que tengo definido mi modelo (en este caso el de arboles de decisión, por tener la mejor precisión) como aplico luego el modelo en un conjunto de datos de valores de sépalo y pétalo para determinar que tipo de iris es?
Hola Carol, solamente tienes que ingresarle los nuevos datos con el mismo orden y formato que hiciste en las pruebas. Saludos.
Veo un error, Para calcular el Score del algoritmo deberías haber usado los datos de test, asi: algoritmo.score(X_test, y_test) en lugar de algoritmo.score(X_train, y_train)
Hola Javier, puedes utilizar tanto test como train, inclusive es bueno utilizar ambas para determinar si hay un sobreajuste en el modelo. Recuerda que acá yo te doy las bases queda de tu parte que mejores el proyecto. Saludos.
Hola me sale un error al importar en esta parte
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
AttributeError: module ‘scipy’ has no attribute ‘_lib’
Hola Anderson, trata de actualizar la librería de repente ese sea el problema. Saludos.
Esta muy buena la información, somo seria podrías ayudarme con un clasificador de iris según datos ingresados al azar, yque este programa indique según una @data a que tipo de iris pertenece.
Hola Yordi, puedes utilizar como base este programa para realizar lo que me planteas acá. Saludos.
Muchas gracias por la información, fue de mucha utilidad y de fácil comprensión. Una apreciación, en la instrucción para regresión logística solo de sépalo del ejercicio del blog para: Ahora procedemos a separar los datos de entrenamiento y prueba para proceder a construir los modelos.
#Separo los datos de «train» en entrenamiento y prueba para probar los algoritmos
X_train_s, X_test_s, y_train_s, y_test_s = train_test_split(X_sepalo, y_sepalo, test_size=0.2)
print(‘Son {} datos sépalo para entrenamiento y {} datos sépalo para prueba’.format(X_train.shape[0], X_test.shape[0]))
En la línea de abajo, en la parte de: X_train.shape[0], X_test.shape[0])) creo que debería ser: X_train_s.shape[0], X_test_s.shape[0]))
Sino arroja error.
Hola Zamy, tienes razón. Muchas gracias por la corrección. Saludos.
Hola! Se podría entrenar con un perceptrón?
Hola Lourdes, si claro lo puedes entrenar. Saludos.
Esto esta genial , Muchas gracias ojalá mi profesor explicara así.
Hola José, muchas gracias por las palabras. Saludos.
Los scores del código son sobre los subset de entrenamiento; en realidad lo significativo es ver el desempeño del modelo entrenado con los subsets de test.
Ejemplo
print(
«Model score: %f»
% algoritmo.fit(X_train, y_train).score(X_test, y_test))
Un saludo y felicitaciones por el aporte.
Excelente. Muchas gracias! Fue muy fácil aprender a clasificar y con este dataset. Conoci como obtener otros dataset para seguir con el tema.