Scikit learn - Aprendizaje automático usando Python

En este blog, discutiremos Scikit learn en python. Antes de hablar de Scikit learn, es necesario comprender el concepto de aprendizaje automáticoy debe saber usar . Con el aprendizaje automático, no es necesario que recopile información de forma manual. ¡Solo necesita un algoritmo y la máquina hará el resto por usted! ¿No es esto emocionante? Scikit learn es uno de los atractivos donde podemos implementar el aprendizaje automático usando Python. Esoes una biblioteca gratuita de aprendizaje automático que contiene herramientas simples y eficientes para el análisis de datos y la minería.Lo llevaré a través de los siguientes temas, que servirán como fundamentos para los próximos blogs:

• • ¿Qué es el aprendizaje automático? ?
  • Descripción general de Scikit Learn
  • Instalación
  • Caso de uso -Regresión logística

¿Qué es el aprendizaje automático?

El aprendizaje automático es un tipo de inteligencia artificial que permite que las aplicaciones de software aprendan de los datos y sean más precisas en la predicción de resultados sin intervención humana. ¿Pero cómo sucede eso? Para eso, la máquina debe entrenarse con algunos datos y, en base a eso, detectará un patrón para crear un modelo.Este proceso de obtener conocimiento de los datos y proporcionar información valiosa tiene que ver con el aprendizaje automático. Consulte la siguiente imagen para comprender mejor su funcionamiento:

Usando los datos, el sistema aprende un algoritmo y luego lo usa para construir un modelo predictivo. Posteriormente, ajustamos el modelo o mejoramos la precisión del modelo utilizando los datos de retroalimentación. Usando estos datos de retroalimentación, ajustamos el modelo y predecimos la acción en el nuevo conjunto de datos. Lo haremosestar discutiendo un caso de uso de uno de los enfoques de algoritmo en el que entrenaremos y probaremos los datos que le ayudarán a tener una mejor idea de si se ajustarán bien a su problema particular o no.

A continuación, hay tres tipos de aprendizaje automático:

• • Aprendizaje supervisado : Este es un proceso de un algoritmo que aprende del conjunto de datos de entrenamiento. El aprendizaje supervisado es donde generas una función de mapeo entre la variable de entrada (X) y una variable de salida (Y) y usas un algoritmo para generar una función entre ellas. También se conoce como modelado predictivo, que se refiere a un proceso de realizar predicciones utilizando los datos. Algunos de los algoritmos incluyen Regresión lineal, Regresión logística, Árbol de decisión, Bosque aleatorio y clasificador Naive Bayes. Discutiremos más a fondo un caso de uso de aprendizaje supervisado donde entrenamos la máquina usando Regresión logística .
    
  • Aprendizaje sin supervisión : Este es un proceso en el que se entrena un modelo utilizando una información que no está etiquetada. Este proceso se puede utilizar para agrupar los datos de entrada en clases sobre la base de sus propiedades estadísticas. El aprendizaje no supervisado también se denomina cAnálisis brillante que significa la agrupación de objetos en función de la información encontrada en los datos que describen los objetos o su relación. El objetivo es que los objetos de un grupo sean similares entre sí pero diferentes de los objetos de otro grupo. Algunos de los algoritmos incluyen agrupamiento de K-medias, agrupamiento jerárquico, etc.
  • Aprendizaje reforzado: El aprendizaje por refuerzo es aprender interactuando con un espacio o un entorno.Un agente de RL aprende de las consecuencias de sus acciones, en lugar de aprender explícitamente. Selecciona sus acciones sobre la base de sus experiencias pasadas (explotación) y también por nuevas opciones (exploración).

Descripción general de Scikit Learn

Scikit learn es una biblioteca que se utiliza para realizar el aprendizaje automático en Python. Scikit learn es una biblioteca de código abierto con licencia BSD y reutilizable en varios contextos, lo que fomenta el uso académico y comercial. Proporciona una variedad de algoritmos de aprendizaje supervisados ​​y no supervisados ​​en Python.Scikit learn consiste en bibliotecas y algoritmos populares. Aparte de eso, también contiene los siguientes paquetes:

• NumPy
• Matplotlib
• SciPy (Python científico)

Para implementar Scikit learn, primero necesitamos importar los paquetes anteriores. Si no está familiarizado con estas bibliotecas, puede echar un vistazo a mis blogs anteriores en y . Puede descargar estos dos paquetes usando la línea de comando o si está usando PyCharm, puede instalarlo directamente yendo a su configuración de la misma manera que lo hace con otros paquetes.

A continuación, de manera similar, tienes que importar Sklearn.Scikit learn se basa en SciPy (Scientific Python) que debe instalarse antes de poder usar Scikit-learn. Puedes referirte a esto sitio web para descargar el mismo. Además, instale Scipy y el paquete de ruedas si no está presente, puede escribir el siguiente comando:

pip instalar scipy

Ya lo he descargado e instalado, puede consultar la captura de pantalla a continuación para cualquier confusión.

Después de importar las bibliotecas anteriores, profundicemos y comprendamos cómo se usa exactamente Scikit learn.

que es una variable de instancia en java

Scikit learn viene con conjuntos de datos de muestra, como iris y digitos . Puede importar los conjuntos de datos y jugar con ellos. Después de eso, debe importar SVM, que significa Support Vector Machine. SVM es una forma de aprendizaje automático que se utiliza para analizar datos.

Tomemos un ejemplo donde tomaremos digitos conjunto de datos y categorizará los números para nosotros, por ejemplo, 0 1 2 3 4 5 6 7 8 9. Consulte el código a continuación:

importar matplotlib.pyplot como plt desde sklearn importar conjuntos de datos desde sklearn importar svm digits = datasets.load_digits () print (digits.data)

Salida -

[[ 0. 0. 5. ..., 0. 0. 0.] [ 0. 0. 0. ..., 10. 0. 0.] [ 0. 0. 0. ..., 16. 9. 0.] ..., [ 0. 0. 1. ..., 6. 0. 0.] [ 0. 0. 2. ..., 12. 0. 0.] [ 0. 0. 10. ..., 12. 1. 0.]]

Aquí acabamos de importar las bibliotecas, SVM, conjuntos de datos e imprimir los datos. Es una gran variedad de datos de dígitos donde se almacenan los datos. Da acceso a las características que se pueden utilizar para clasificar el digitos muestras. A continuación, también puede probar otras operaciones como destino, imágenes, etc. Considere el siguiente ejemplo:

importar matplotlib.pyplot como plt desde sklearn importar conjuntos de datos desde sklearn importar svm digits = datasets.load_digits () print (digits.target) print (digits.images [0])

Salida –

[0 1 2 ..., 8 9 8] // destino de los datos [[0. 0. 5. 13. 9. 1. 0. 0.] // imagen de los datos [0. 0. 13. 15. 10. 15. 5. 0.] [0. 3. 15. 2. 0. 11. 8. 0.] [0. 4. 12. 0. 0. 8. 8. 0.] [0. 5. 8. 0. 0. 9. 8. 0.] [0. 4. 11. 0. 1. 12. 7. 0.] [0. 2. 14. 5. 10. 12. 0. 0. ] [0. 0. 6. 13. 10. 0. 0. 0.]]

Como puede ver arriba, se imprimen los dígitos de destino y la imagen de los dígitos. digits.target da la verdad fundamental para el dígito conjunto de datos, que es el número correspondiente a cada imagen de dígitos. A continuación, los datos son siempre una matriz 2D que tiene una forma (n_samples, n_features), aunque los datos originales pueden haber tenido una forma diferente. Pero en el caso de los dígitos, cada muestra original es una imagen de forma (8,8) y se puede acceder mediante digitos . imagen.

Aprender y predecir

A continuación, en Scikit learn, hemos utilizado un conjunto de datos (muestra de 10 clases posibles, dígitos del cero al nueve) y necesitamos predecir los dígitos cuando se da una imagen. Para predecir la clase, necesitamos un estimador lo que ayuda a predecir las clases a las que pertenecen las muestras invisibles. En Scikit learn, tenemos un estimador para clasificación que es un objeto de Python que implementa los métodos encajar (x, y) y predecir (T). Consideremos el siguiente ejemplo:

importar matplotlib.pyplot como plt de sklearn importar conjuntos de datos de sklearn importar svm digits = datasets.load_digits () // dataset clf = svm.SVC (gamma = 0.001, C = 100) print (len (digits.data)) x, y = digits.data [: - 1], digits.target [: - 1] // entrena los datos clf.fit (x, y) print ('Prediction:', clf.predict (digits.data [-1]) ) // predice los datos plt.imshow (digits.images [-1], cmap = plt.cm.gray_r, interpolation = 'más cercano') plt.show ()

Salida -

1796
Predicción: [8]

En el ejemplo anterior, primero encontramos la longitud y cargamos 1796 ejemplos. A continuación, hemos utilizado estos datos como datos de aprendizaje, donde necesitamos probar el último elemento y el primer elemento negativo. Además, debemos verificar si la máquina ha predicho los datos correctos o no. Para eso, usamos Matplotlib donde mostramos la imagen de dígitos.Entonces, para concluir, tiene datos de dígitos, obtuvo el objetivo, lo ajusta y lo predice y, por lo tanto, ¡está listo para comenzar! Es realmente rápido y fácil, ¿no?

También puede visualizar las etiquetas de destino con una imagen, solo consulte el siguiente código:

importar matplotlib.pyplot como plt desde sklearn importar conjuntos de datos desde sklearn importar svm digits = datasets.load_digits () # Unir las imágenes y etiquetas de destino en una lista images_and_labels = list (zip (digits.images, digits.target)) # para cada elemento en la lista de índice, (imagen, etiqueta) en enumerar (imágenes_y_etiquetas [: 8]): # inicializar una subparcela de 2X4 en la posición i + 1-th plt.subplot (2, 4, index + 1) # Mostrar imágenes en todas las subtramas plt.imshow (imagen, cmap = plt.cm.gray_r, interpolation = 'más cercano') # Agregar un título a cada subparcela plt.title ('Entrenamiento:' + str (etiqueta)) # Mostrar la trama plt. show()

Salida–

Como puede ver en el código anterior, hemos utilizado la función 'zip' para unir las imágenes y las etiquetas de destino en una lista y luego guardarla en una variable, digamos images_and_labels. Después de eso, hemos indexado los primeros ocho elementos en una cuadrícula de 2 por 4 en cada posición. Después de eso, acabamos de mostrar las imágenes con la ayuda de Matplotlib y agregamos el título como 'entrenamiento'.

Caso de uso – Predicción mediante regresión logística

Planteamiento del problema – Una empresa automovilística ha lanzado al mercado un nuevo SUV. Utilizando los datos anteriores sobre las ventas de sus SUV, quieren predecir la categoría de personas que podrían estar interesadas en comprarlo.

Para esto, veamos un conjunto de datos donde tengo UserId, sexo, edad, salario estimado y comprado como columnas. Este es solo un conjunto de datos de muestra, puede descargar el conjunto de datos completo desde Aquí . Una vez que importamos los datos en pyCharm, se parece a esto.

Ahora comprendamos estos datos. Como puede ver en el conjunto de datos anterior, tenemos categorías como id, género, edad, etc. Ahora, basándonos en estas categorías, vamos a entrenar nuestra máquina y predecir el no. de compras. Así que aquí tenemos variables independientes como 'edad', 'salario esperado' y variable dependiente como 'comprado'. Ahora aplicaremos el aprendizaje supervisado, es decir algoritmo de regresión logística para conocer el número de compra utilizando los datos existentes.

Primero, obtengamos una descripción general de la regresión logística.

Regresión logística - La regresión logística produce resultados en un formato binario que se utiliza para predecir el resultado de una variable dependiente categórica. Se usa más ampliamente cuando la variable dependiente es binaria, es decir, el número de categorías disponibles es dos, por ejemplo, las salidas habituales de la regresión logística son:

uso de paquetes en java

• Si y no
• Verdadero y falso
• Alto y bajo
• Pasa y no pasa

Ahora, para comenzar con el código, primero importaremos estas bibliotecas: Numpy, Matplotlib y Pandas. Es bastante fácil importar pandas en Pycharm siguiendo los pasos a continuación:

Configuración -> Agregar paquete -> Pandas -> Instalar

Después de esto, importaremos el conjunto de datos y la variable dependiente separada (comprada) y la variable independiente (edad, salario) por:

dataset = pd.read_csv ('Social_Network_Ads.csv') X = dataset.iloc [:, [2, 3]]. valores y = dataset.iloc [:, 4] .values ​​print (X) print (y)

El siguiente paso sería entrenar y probar los datos. Una estrategia común es tomar todos los datos etiquetados y dividirlos en subconjuntos de entrenamiento y prueba, que generalmente se toma con una proporción de 70-80% para el subconjunto de entrenamiento y 20-30% para el subconjunto de prueba. Por lo tanto, hemos creado conjuntos de prueba y entrenamiento mediante validación cruzada.

from sklearn.cross_validation import train_test_split X_train, X_test, y_train, y_test = train_test_split (X, y, test_size = 0.25, random_state = 0)

También podemos escalar los valores de entrada para un mejor rendimiento usando StandarScaler como se muestra a continuación:

de sklearn.preprocessing import StandardScaler sc = StandardScaler () X_train = sc.fit_transform (X_train) X_test = sc.transform (X_test)

Ahora crearemos nuestro modelo de Regresión logística.

from sklearn.linear_model import LogisticRegression classifier = LogisticRegression (random_state = 0) classifier.fit (X_train, y_train)

Podemos usar esto y predecir los resultados de nuestro conjunto de pruebas.

y_pred = classifier.predict(X_test)

Ahora, podemos verificar cuántas predicciones fueron precisas y cuántas no estaban usando matriz de confusión . Definamos Y como instancias positivas y N como instancias negativas. Los cuatro resultados se formulan en una matriz de confusión 2 * 2, como se representa a continuación:

de sklearn.metrics importar confusion_matrix cm = confusion_matrix (y_test, y_pred) print (cm)

Salida–

[[65 3] [ 8 24]]

A continuación, basándonos en nuestra matriz de confusión, podemos calcular la precisión. Entonces, en nuestro ejemplo anterior, la precisión sería:

= TP + TN / FN + FP

= 65+24 / 65 +3+ 8 + 24

=89%

¡Lo hemos hecho manualmente! Ahora veamos cómo la máquina calcula lo mismo para nosotros, para eso tenemos una función incorporada 'precision_score' que calcula la precisión y la imprime, como se muestra a continuación:

cómo escribir un método de cuerda

from sklearn.metrics import precision_score // importa la función precision_score print (precision_score (y_test, y_pred) * 100) // imprime la precisión

Salida -

89.0

¡Viva! Por lo tanto, hemos implementado con éxito la regresión logística utilizando Scikit learn con una precisión del 89%.

haga clic aquí para obtener la fuente completa de la predicción anterior usando la biblioteca de aprendizaje de Python Scikit.

Con esto, hemos cubierto solo uno de los muchos algoritmos populares que Python tiene para ofrecer.Hemos cubierto todos los conceptos básicos de Scikit aprende la biblioteca,para que puedas empezar a practicar ahora. Cuanto más practiques, más aprenderás. ¡Estén atentos para más blogs de tutoriales de Python!

Tienes una pregunta para nosotros? Menciónelo en la sección de comentarios de este blog “Scikit learn” y nos comunicaremos con usted lo antes posible. Para obtener un conocimiento profundo de Python junto con sus diversas aplicaciones, puede para capacitación en vivo en línea con soporte 24/7 y acceso de por vida.