IA con Python - Aprendizaje supervisado: clasificación

En este capítulo, nos centraremos en la implementación del aprendizaje supervisado: clasificación.

La técnica o modelo de clasificación intenta obtener alguna conclusión a partir de los valores observados. En el problema de clasificación, tenemos la salida categorizada como “Negro” o “blanco” o “Docente” y “No docente”. Mientras construimos el modelo de clasificación, necesitamos tener un conjunto de datos de entrenamiento que contenga puntos de datos y las etiquetas correspondientes. Por ejemplo, si queremos comprobar si la imagen es de un coche o no. Para comprobar esto, crearemos un conjunto de datos de entrenamiento con las dos clases relacionadas con "coche" y "sin coche". Luego, necesitamos entrenar el modelo usando las muestras de entrenamiento. Los modelos de clasificación se utilizan principalmente en reconocimiento facial, identificación de spam, etc.

Pasos para construir un clasificador en Python

Para construir un clasificador en Python, usaremos Python 3 y Scikit-learn, que es una herramienta para el aprendizaje automático. Siga estos pasos para construir un clasificador en Python:

Paso 1: Importar Scikit-learn

Este sería el primer paso para construir un clasificador en Python. En este paso, instalaremos un paquete de Python llamado Scikit-learn, que es uno de los mejores módulos de aprendizaje automático en Python. El siguiente comando nos ayudará a importar el paquete:

Import Sklearn

Paso 2: importar el conjunto de datos de Scikit-learn

En este paso, podemos comenzar a trabajar con el conjunto de datos para nuestro modelo de aprendizaje automático. Aquí vamos a utilizarthe Base de datos de diagnóstico de cáncer de mama de Wisconsin. El conjunto de datos incluye diversa información sobre los tumores de cáncer de mama, así como etiquetas de clasificación demalignant o benign. El conjunto de datos tiene 569 instancias, o datos, sobre 569 tumores e incluye información sobre 30 atributos o características, como el radio del tumor, la textura, la suavidad y el área. Con la ayuda del siguiente comando, podemos importar el conjunto de datos de cáncer de mama de Scikit-learn:

from sklearn.datasets import load_breast_cancer

Ahora, el siguiente comando cargará el conjunto de datos.

data = load_breast_cancer()

A continuación se muestra una lista de claves importantes del diccionario:

Nombres de etiquetas de clasificación (target_names)
Las etiquetas reales (objetivo)
Los nombres de atributos / características (feature_names)
El atributo (datos)

Ahora, con la ayuda del siguiente comando, podemos crear nuevas variables para cada conjunto importante de información y asignar los datos. En otras palabras, podemos organizar los datos con los siguientes comandos:

label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']

Ahora, para que quede más claro, podemos imprimir las etiquetas de clase, la etiqueta de la primera instancia de datos, los nombres de nuestras características y el valor de la característica con la ayuda de los siguientes comandos:

print(label_names)

El comando anterior imprimirá los nombres de las clases que son malignos y benignos respectivamente. Se muestra como la salida a continuación:

['malignant' 'benign']

Ahora, el siguiente comando mostrará que están asignados a los valores binarios 0 y 1. Aquí 0 representa cáncer maligno y 1 representa cáncer benigno. Recibirá el siguiente resultado:

print(labels[0])
0

Los dos comandos que se dan a continuación producirán los nombres y valores de las funciones.

print(feature_names[0])
mean radius
print(features[0])
[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
  1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
  2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
  8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
  5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
  2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
  1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
  4.60100000e-01 1.18900000e-01]

De la salida anterior, podemos ver que la primera instancia de datos es un tumor maligno cuyo radio es 1.7990000e + 01.

Paso 3: organizar los datos en conjuntos

En este paso, dividiremos nuestros datos en dos partes, a saber, un conjunto de entrenamiento y un conjunto de prueba. Dividir los datos en estos conjuntos es muy importante porque tenemos que probar nuestro modelo en los datos invisibles. Para dividir los datos en conjuntos, sklearn tiene una función llamadatrain_test_split()función. Con la ayuda de los siguientes comandos, podemos dividir los datos en estos conjuntos:

from sklearn.model_selection import train_test_split

El comando anterior importará el train_test_splitfunción de sklearn y el siguiente comando dividirá los datos en datos de entrenamiento y de prueba. En el ejemplo que se muestra a continuación, estamos usando el 40% de los datos para realizar pruebas y los datos restantes se usarían para entrenar el modelo.

train, test, train_labels, test_labels = train_test_split(features,labels,test_size = 0.40, random_state = 42)

Paso 4: construcción del modelo

En este paso, estaremos construyendo nuestro modelo. Vamos a utilizar el algoritmo Naïve Bayes para construir el modelo. Los siguientes comandos se pueden usar para construir el modelo:

from sklearn.naive_bayes import GaussianNB

El comando anterior importará el módulo GaussianNB. Ahora, el siguiente comando te ayudará a inicializar el modelo.

gnb = GaussianNB()

Entrenaremos el modelo ajustándolo a los datos usando gnb.fit ().

model = gnb.fit(train, train_labels)

Paso 5: evaluación del modelo y su precisión

En este paso, vamos a evaluar el modelo haciendo predicciones sobre nuestros datos de prueba. Entonces también averiguaremos su precisión. Para hacer predicciones, usaremos la función predict (). El siguiente comando te ayudará a hacer esto:

preds = gnb.predict(test)
print(preds)

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

La serie anterior de 0 y 1 son los valores predichos para las clases de tumores: malignos y benignos.

Ahora, comparando las dos matrices a saber test_labels y preds, podemos averiguar la precisión de nuestro modelo. Vamos a utilizar elaccuracy_score()función para determinar la precisión. Considere el siguiente comando para esto:

from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965

El resultado muestra que el clasificador NaïveBayes tiene una precisión del 95,17%.

De esta forma, con la ayuda de los pasos anteriores podemos construir nuestro clasificador en Python.

Construyendo clasificador en Python

En esta sección, aprenderemos cómo construir un clasificador en Python.

Clasificador Naïve Bayes

Naïve Bayes es una técnica de clasificación utilizada para construir clasificadores usando el teorema de Bayes. El supuesto es que los predictores son independientes. En palabras simples, asume que la presencia de una característica particular en una clase no está relacionada con la presencia de ninguna otra característica. Para construir el clasificador Naïve Bayes, necesitamos usar la biblioteca de Python llamada scikit learn. Hay tres tipos de modelos Naïve Bayes llamadosGaussian, Multinomial and Bernoulli bajo el paquete scikit learn.

Para construir un modelo de clasificador de aprendizaje automático Naïve Bayes, necesitamos lo siguiente y menos

Conjunto de datos

Vamos a utilizar el conjunto de datos denominado Base de datos de diagnóstico de Wisconsin del cáncer de mama. El conjunto de datos incluye diversa información sobre los tumores de cáncer de mama, así como etiquetas de clasificación demalignant o benign. El conjunto de datos tiene 569 instancias, o datos, sobre 569 tumores e incluye información sobre 30 atributos o características, como el radio del tumor, la textura, la suavidad y el área. Podemos importar este conjunto de datos desde el paquete sklearn.

Modelo ingenuo de Bayes

Para construir el clasificador Naïve Bayes, necesitamos un modelo Naïve Bayes. Como se dijo anteriormente, hay tres tipos de modelos Naïve Bayes llamadosGaussian, Multinomial y Bernoullibajo el paquete scikit learn. Aquí, en el siguiente ejemplo vamos a utilizar el modelo Gaussiano Naïve Bayes.

Al utilizar lo anterior, vamos a crear un modelo de aprendizaje automático Naïve Bayes para usar la información del tumor para predecir si un tumor es maligno o benigno.

Para empezar, necesitamos instalar el módulo sklearn. Se puede hacer con la ayuda del siguiente comando:

Import Sklearn

Ahora, necesitamos importar el conjunto de datos denominado Base de datos de diagnóstico de Wisconsin del cáncer de mama.

from sklearn.datasets import load_breast_cancer

Ahora, el siguiente comando cargará el conjunto de datos.

data = load_breast_cancer()

Los datos se pueden organizar de la siguiente manera:

label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']

print(label_names)

El comando anterior imprimirá los nombres de las clases que son malignos y benignos respectivamente. Se muestra como la salida a continuación:

['malignant' 'benign']

Ahora, el comando dado a continuación mostrará que están asignados a los valores binarios 0 y 1. Aquí 0 representa cáncer maligno y 1 representa cáncer benigno. Se muestra como la salida a continuación:

print(labels[0])
0

Los siguientes dos comandos producirán los nombres y valores de las funciones.

print(feature_names[0])
mean radius
print(features[0])

[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
  1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
  2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
  8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
  5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
  2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
  1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
  4.60100000e-01 1.18900000e-01]

De la salida anterior, podemos ver que la primera instancia de datos es un tumor maligno cuyo radio principal es 1.7990000e + 01.

Para probar nuestro modelo en datos invisibles, necesitamos dividir nuestros datos en datos de entrenamiento y de prueba. Se puede hacer con la ayuda del siguiente código:

from sklearn.model_selection import train_test_split

El comando anterior importará el train_test_splitfunción de sklearn y el siguiente comando dividirá los datos en datos de entrenamiento y de prueba. En el siguiente ejemplo, estamos usando el 40% de los datos para las pruebas y los datos de recordatorio se usarían para entrenar el modelo.

train, test, train_labels, test_labels = 
train_test_split(features,labels,test_size = 0.40, random_state = 42)

Ahora, estamos construyendo el modelo con los siguientes comandos:

from sklearn.naive_bayes import GaussianNB

El comando anterior importará el GaussianNBmódulo. Ahora, con el comando que se proporciona a continuación, necesitamos inicializar el modelo.

gnb = GaussianNB()

Entrenaremos el modelo ajustándolo a los datos usando gnb.fit().

model = gnb.fit(train, train_labels)

Ahora, evalúe el modelo haciendo una predicción sobre los datos de prueba y se puede hacer de la siguiente manera:

preds = gnb.predict(test)
print(preds)

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

La serie anterior de 0 y 1 son los valores predichos para las clases de tumores, es decir, maligno y benigno.

from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965

El resultado muestra que el clasificador de NaïveBayes tiene una precisión del 95,17%.

Ese era un clasificador de aprendizaje automático basado en el modelo gaussiano Naïve Bayse.

Máquinas de vectores de soporte (SVM)

Básicamente, Support vector machine (SVM) es un algoritmo de aprendizaje automático supervisado que se puede usar tanto para regresión como para clasificación. El concepto principal de SVM es trazar cada elemento de datos como un punto en un espacio n-dimensional con el valor de cada característica siendo el valor de una coordenada particular. Aquí n serían las características que tendríamos. A continuación se muestra una representación gráfica simple para comprender el concepto de SVM:

En el diagrama anterior, tenemos dos características. Por lo tanto, primero debemos trazar estas dos variables en un espacio bidimensional donde cada punto tiene dos coordenadas, llamadas vectores de soporte. La línea divide los datos en dos grupos clasificados diferentes. Esta línea sería el clasificador.

Aquí, vamos a construir un clasificador SVM usando scikit-learn e iris dataset. La biblioteca Scikitlearn tiene lasklearn.svmmódulo y proporciona sklearn.svm.svc para la clasificación. A continuación se muestra el clasificador SVM para predecir la clase de planta de iris en función de 4 características.

Conjunto de datos

Usaremos el conjunto de datos de iris que contiene 3 clases de 50 instancias cada una, donde cada clase se refiere a un tipo de planta de iris. Cada instancia tiene las cuatro características a saber, longitud del sépalo, ancho del sépalo, longitud del pétalo y ancho del pétalo. A continuación se muestra el clasificador SVM para predecir la clase de planta de iris en función de 4 características.

Núcleo

Es una técnica utilizada por SVM. Básicamente, estas son las funciones que toman el espacio de entrada de baja dimensión y lo transforman en un espacio de mayor dimensión. Convierte un problema no separable en un problema separable. La función del núcleo puede ser cualquiera entre lineal, polinomial, rbf y sigmoide. En este ejemplo, usaremos el kernel lineal.

Ahora importemos los siguientes paquetes:

import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as plt

Ahora, cargue los datos de entrada -

iris = datasets.load_iris()

Estamos tomando las dos primeras características:

X = iris.data[:, :2]
y = iris.target

Trazaremos los límites de la máquina del vector de soporte con los datos originales. Estamos creando una malla para trazar.

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
h = (x_max / x_min)/100
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
X_plot = np.c_[xx.ravel(), yy.ravel()]

Necesitamos dar el valor del parámetro de regularización.

C = 1.0

Necesitamos crear el objeto clasificador SVM.

Svc_classifier = svm_classifier.SVC(kernel='linear', 
C=C, decision_function_shape = 'ovr').fit(X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize = (15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap = plt.cm.tab10, alpha = 0.3)
plt.scatter(X[:, 0], X[:, 1], c = y, cmap = plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('SVC with linear kernel')

Regresión logística

Básicamente, el modelo de regresión logística es uno de los miembros de la familia de algoritmos de clasificación supervisada. La regresión logística mide la relación entre las variables dependientes y las independientes mediante la estimación de probabilidades mediante una función logística.

Aquí, si hablamos de variables dependientes e independientes, entonces la variable dependiente es la variable de la clase objetivo que vamos a predecir y, por otro lado, las variables independientes son las características que usaremos para predecir la clase objetivo.

En regresión logística, estimar las probabilidades significa predecir la probabilidad de ocurrencia del evento. Por ejemplo, al propietario de la tienda le gustaría predecir que el cliente que ingresó a la tienda comprará la estación de juegos (por ejemplo) o no. Habría muchas características del cliente (género, edad, etc.) que el comerciante observaría para predecir la probabilidad de que ocurra, es decir, comprar una estación de juegos o no. La función logística es la curva sigmoidea que se utiliza para construir la función con varios parámetros.

Prerrequisitos

Antes de construir el clasificador usando regresión logística, necesitamos instalar el paquete Tkinter en nuestro sistema. Se puede instalar desdehttps://docs.python.org/2/library/tkinter.html.

Ahora, con la ayuda del código que se proporciona a continuación, podemos crear un clasificador mediante regresión logística:

Primero, importaremos algunos paquetes:

import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt

Ahora, necesitamos definir los datos de muestra que se pueden hacer de la siguiente manera:

X = np.array([[2, 4.8], [2.9, 4.7], [2.5, 5], [3.2, 5.5], [6, 5], [7.6, 4],
              [3.2, 0.9], [2.9, 1.9],[2.4, 3.5], [0.5, 3.4], [1, 4], [0.9, 5.9]])
y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3])

A continuación, necesitamos crear el clasificador de regresión logística, que se puede hacer de la siguiente manera:

Classifier_LR = linear_model.LogisticRegression(solver = 'liblinear', C = 75)

Por último, pero no menos importante, necesitamos entrenar a este clasificador:

Classifier_LR.fit(X, y)

Ahora bien, ¿cómo podemos visualizar el resultado? Se puede hacer creando una función llamada Logistic_visualize () -

Def Logistic_visualize(Classifier_LR, X, y):
   min_x, max_x = X[:, 0].min() - 1.0, X[:, 0].max() + 1.0
   min_y, max_y = X[:, 1].min() - 1.0, X[:, 1].max() + 1.0

En la línea anterior, definimos los valores mínimo y máximo X e Y que se utilizarán en la cuadrícula de malla. Además, definiremos el tamaño del paso para trazar la cuadrícula de malla.

mesh_step_size = 0.02

Definamos la cuadrícula de malla de los valores X e Y de la siguiente manera:

x_vals, y_vals = np.meshgrid(np.arange(min_x, max_x, mesh_step_size),
                 np.arange(min_y, max_y, mesh_step_size))

Con la ayuda del siguiente código, podemos ejecutar el clasificador en la cuadrícula de malla:

output = classifier.predict(np.c_[x_vals.ravel(), y_vals.ravel()])
output = output.reshape(x_vals.shape)
plt.figure()
plt.pcolormesh(x_vals, y_vals, output, cmap = plt.cm.gray)
 
plt.scatter(X[:, 0], X[:, 1], c = y, s = 75, edgecolors = 'black', 
linewidth=1, cmap = plt.cm.Paired)

La siguiente línea de código especificará los límites de la trama

plt.xlim(x_vals.min(), x_vals.max())
plt.ylim(y_vals.min(), y_vals.max())
plt.xticks((np.arange(int(X[:, 0].min() - 1), int(X[:, 0].max() + 1), 1.0)))
plt.yticks((np.arange(int(X[:, 1].min() - 1), int(X[:, 1].max() + 1), 1.0)))
plt.show()

Ahora, después de ejecutar el código, obtendremos el siguiente resultado, clasificador de regresión logística:

Clasificador de árbol de decisión

Un árbol de decisión es básicamente un diagrama de flujo de árbol binario en el que cada nodo divide un grupo de observaciones de acuerdo con alguna variable característica.

Aquí, estamos construyendo un clasificador de árbol de decisión para predecir hombres o mujeres. Tomaremos un conjunto de datos muy pequeño con 19 muestras. Estas muestras constarían de dos características: "altura" y "longitud del cabello".

Requisito previo

Para construir el siguiente clasificador, necesitamos instalar pydotplus y graphviz. Básicamente, graphviz es una herramienta para dibujar gráficos usando archivos de puntos ypydotpluses un módulo del lenguaje Dot de Graphviz. Se puede instalar con el administrador de paquetes o pip.

Ahora, podemos construir el clasificador del árbol de decisiones con la ayuda del siguiente código de Python:

Para empezar, importemos algunas bibliotecas importantes de la siguiente manera:

import pydotplus
from sklearn import tree
from sklearn.datasets import load_iris
from sklearn.metrics import classification_report
from sklearn import cross_validation
import collections

Ahora, debemos proporcionar el conjunto de datos de la siguiente manera:

X = [[165,19],[175,32],[136,35],[174,65],[141,28],[176,15],[131,32],
[166,6],[128,32],[179,10],[136,34],[186,2],[126,25],[176,28],[112,38],
[169,9],[171,36],[116,25],[196,25]]

Y = ['Man','Woman','Woman','Man','Woman','Man','Woman','Man','Woman',
'Man','Woman','Man','Woman','Woman','Woman','Man','Woman','Woman','Man']
data_feature_names = ['height','length of hair']

X_train, X_test, Y_train, Y_test = cross_validation.train_test_split
(X, Y, test_size=0.40, random_state=5)

Después de proporcionar el conjunto de datos, debemos ajustar el modelo, lo que se puede hacer de la siguiente manera:

clf = tree.DecisionTreeClassifier()
clf = clf.fit(X,Y)

La predicción se puede hacer con la ayuda del siguiente código de Python:

prediction = clf.predict([[133,37]])
print(prediction)

Podemos visualizar el árbol de decisiones con la ayuda del siguiente código Python:

dot_data = tree.export_graphviz(clf,feature_names = data_feature_names,
            out_file = None,filled = True,rounded = True)
graph = pydotplus.graph_from_dot_data(dot_data)
colors = ('orange', 'yellow')
edges = collections.defaultdict(list)

for edge in graph.get_edge_list():
edges[edge.get_source()].append(int(edge.get_destination()))

for edge in edges: edges[edge].sort()

for i in range(2):dest = graph.get_node(str(edges[edge][i]))[0]
dest.set_fillcolor(colors[i])
graph.write_png('Decisiontree16.png')

Dará la predicción para el código anterior como [‘Woman’] y cree el siguiente árbol de decisiones:

Podemos cambiar los valores de las características en la predicción para probarlo.

Clasificador de bosque aleatorio

Como sabemos, los métodos de conjunto son los métodos que combinan modelos de aprendizaje automático en un modelo de aprendizaje automático más potente. Random Forest, una colección de árboles de decisión, es uno de ellos. Es mejor que el árbol de decisión único porque, si bien conserva los poderes predictivos, puede reducir el ajuste excesivo al promediar los resultados. Aquí, vamos a implementar el modelo de bosque aleatorio en el conjunto de datos de cáncer de scikit learn.

Importar los paquetes necesarios -

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
import matplotlib.pyplot as plt
import numpy as np

Ahora, necesitamos proporcionar el conjunto de datos que se puede hacer de la siguiente manera y menos

cancer = load_breast_cancer()
X_train, X_test, y_train,
y_test = train_test_split(cancer.data, cancer.target, random_state = 0)

Después de proporcionar el conjunto de datos, debemos ajustar el modelo, lo que se puede hacer de la siguiente manera:

forest = RandomForestClassifier(n_estimators = 50, random_state = 0)
forest.fit(X_train,y_train)

Ahora, obtenga la precisión del subconjunto de entrenamiento y de prueba: si aumentamos el número de estimadores, la precisión del subconjunto de prueba también aumentaría.

print('Accuracy on the training subset:(:.3f)',format(forest.score(X_train,y_train)))
print('Accuracy on the training subset:(:.3f)',format(forest.score(X_test,y_test)))

Salida

Accuracy on the training subset:(:.3f) 1.0
Accuracy on the training subset:(:.3f) 0.965034965034965

Ahora, como el árbol de decisiones, el bosque aleatorio tiene la feature_importancemódulo que proporcionará una mejor vista del peso de la característica que el árbol de decisiones. Se puede trazar y visualizar de la siguiente manera:

n_features = cancer.data.shape[1]
plt.barh(range(n_features),forest.feature_importances_, align='center')
plt.yticks(np.arange(n_features),cancer.feature_names)
plt.xlabel('Feature Importance')
plt.ylabel('Feature')
plt.show()

Rendimiento de un clasificador

Después de implementar un algoritmo de aprendizaje automático, debemos averiguar qué tan efectivo es el modelo. Los criterios para medir la eficacia pueden basarse en conjuntos de datos y métricas. Para evaluar diferentes algoritmos de aprendizaje automático, podemos utilizar diferentes métricas de rendimiento. Por ejemplo, supongamos que si se usa un clasificador para distinguir entre imágenes de diferentes objetos, podemos usar las métricas de rendimiento de clasificación como precisión promedio, AUC, etc. En uno u otro sentido, la métrica que elegimos para evaluar nuestro modelo de aprendizaje automático es muy importante porque la elección de las métricas influye en cómo se mide y se compara el rendimiento de un algoritmo de aprendizaje automático. A continuación se muestran algunas de las métricas:

Matriz de confusión

Básicamente se utiliza para problemas de clasificación donde la salida puede ser de dos o más tipos de clases. Es la forma más sencilla de medir el rendimiento de un clasificador. Una matriz de confusión es básicamente una tabla con dos dimensiones, a saber, "Actual" y "Previsto". Ambas dimensiones tienen "Positivos verdaderos (TP)", "Negativos verdaderos (TN)", "Positivos falsos (FP)", "Negativos falsos (FN)".

En la matriz de confusión anterior, 1 es para clase positiva y 0 es para clase negativa.

Los siguientes son los términos asociados con la matriz de confusión:

True Positives − Los TP son los casos en los que la clase real de punto de datos fue 1 y la predicción también es 1.
True Negatives − Los TN son los casos en los que la clase real del punto de datos fue 0 y la predicción también es 0.
False Positives − Los FP son los casos en los que la clase real de punto de datos fue 0 y la predicción también es 1.
False Negatives − Los FN son los casos en los que la clase real del punto de datos fue 1 y la predicción también es 0.

Exactitud

La matriz de confusión en sí misma no es una medida de desempeño como tal, pero casi todas las matrices de desempeño se basan en la matriz de confusión. Uno de ellos es la precisión. En los problemas de clasificación, se puede definir como el número de predicciones correctas realizadas por el modelo sobre todo tipo de predicciones realizadas. La fórmula para calcular la precisión es la siguiente:

$$ Precisión = \ frac {TP + TN} {TP + FP + FN + TN} $$

Precisión

Se utiliza principalmente en la recuperación de documentos. Puede definirse como cuántos de los documentos devueltos son correctos. A continuación se muestra la fórmula para calcular la precisión:

$$ Precisión = \ frac {TP} {TP + FP} $$

Recuerdo o sensibilidad

Puede definirse como cuántos de los aspectos positivos devuelve el modelo. A continuación se muestra la fórmula para calcular la recuperación / sensibilidad del modelo:

$$ Recall = \ frac {TP} {TP + FN} $$

Especificidad

Puede definirse como cuántos de los negativos devuelve el modelo. Es exactamente lo opuesto a recordar. A continuación se muestra la fórmula para calcular la especificidad del modelo:

$$ Especificidad = \ frac {TN} {TN + FP} $$

Problema de desequilibrio de clases

El desequilibrio de clases es el escenario en el que el número de observaciones que pertenecen a una clase es significativamente menor que las que pertenecen a las otras clases. Por ejemplo, este problema es prominente en el escenario donde necesitamos identificar enfermedades raras, transacciones fraudulentas en bancos, etc.

Ejemplo de clases desequilibradas

Consideremos un ejemplo de conjunto de datos de detección de fraude para comprender el concepto de clase desequilibrada:

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

Solución

Balancing the classes’actúa como una solución a las clases desequilibradas. El objetivo principal de equilibrar las clases es aumentar la frecuencia de la clase minoritaria o disminuir la frecuencia de la clase mayoritaria. Los siguientes son los enfoques para resolver el problema de las clases de desequilibrios:

Re-muestreo

El remuestreo es una serie de métodos que se utilizan para reconstruir los conjuntos de datos de muestra, tanto de entrenamiento como de prueba. Se realiza un nuevo muestreo para mejorar la precisión del modelo. A continuación se presentan algunas técnicas de remuestreo:

Random Under-Sampling- Esta técnica tiene como objetivo equilibrar la distribución de clases eliminando aleatoriamente los ejemplos de clases mayoritarias. Esto se hace hasta que se equilibren las instancias de las clases mayoritaria y minoritaria.

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

En este caso, tomamos muestras del 10% sin reemplazo de instancias sin fraude y luego las combinamos con las instancias de fraude:

Observaciones no fraudulentas después de un muestreo aleatorio = 10% de 4950 = 495

Total de observaciones después de combinarlas con observaciones fraudulentas = 50 + 495 = 545

Por lo tanto, ahora, la tasa de eventos para un nuevo conjunto de datos después de un muestreo insuficiente = 9%

La principal ventaja de esta técnica es que puede reducir el tiempo de ejecución y mejorar el almacenamiento. Pero, por otro lado, puede descartar información útil al tiempo que reduce la cantidad de muestras de datos de entrenamiento.

Random Over-Sampling - Esta técnica tiene como objetivo equilibrar la distribución de clases aumentando el número de instancias en la clase minoritaria al replicarlas.

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

En caso de que estemos replicando 50 observaciones fraudulentas 30 veces, las observaciones fraudulentas después de replicar las observaciones de la clase minoritaria serían 1500. Y luego las observaciones totales en los nuevos datos después del sobremuestreo serían 4950 + 1500 = 6450. Por lo tanto, la tasa de eventos para el nuevo conjunto de datos sería 1500/6450 = 23%.

La principal ventaja de este método es que no se perderá información útil. Pero, por otro lado, tiene mayores posibilidades de sobreajuste porque replica los eventos de las clases minoritarias.

Técnicas de conjunto

Esta metodología se utiliza básicamente para modificar los algoritmos de clasificación existentes para hacerlos apropiados para conjuntos de datos desequilibrados. En este enfoque, construimos varios clasificadores de dos etapas a partir de los datos originales y luego agregamos sus predicciones. El clasificador de bosque aleatorio es un ejemplo de clasificador basado en conjuntos.

↰ Previous page Next page ↱