Por mucho que disfrutemos de esta superconductividad de datos, también invita al abuso. Los profesionales de datos deben estar capacitados para utilizar métodos estadísticos no solo para interpretar números, sino también para descubrir tales abusos y protegernos de ser engañados.

No muchos científicos de datos tienen una formación formal en estadística. También hay muy pocos libros y cursos buenos que enseñen estos métodos estadísticos desde una perspectiva de ciencia de datos.

A través de esta publicación, pretendo arrojar algo de luz sobre lo siguiente:

• ¿Qué es estadística?
• Estadística en relación con el aprendizaje de máquina.
• ¿Por qué debes profesionalizarte en estadística?
• ¿Qué curriculum debes seguir para dominar estos temas?
• ¿Cómo estudiar estadística para convertirse en un practicante en lugar de un examinador?
• Consejos prácticos y recursos de aprendizaje.

¿Qué es Estadística?

La estadística es un conjunto de métodos y herramientas matemáticas que nos permiten responder preguntas importantes sobre los datos. Se divide en dos categorías:

1. Estadística Descriptiva: este ofrece métodos para resumir datos transformando observaciones sin modificar en información significativa que sea fácil de interpretar y compartir.
2. Estadística Inferencial: este ofrece métodos para estudiar experimentos hechos en pequeños ejemplos de datos y eliminar las interferencias a toda la población (dominio entero).

Ahora, las estadísticas y el aprendizaje automático son dos áreas de estudio estrechamente ralacionadas. Las estadísticas es un pre-requisito importante para el aprendizaje automático aplicado, ya que nos ayuda a seleccionar, evaluar e interpretar modelos predictivos.

Estadísticas y Aprendizaje Automático

El núcleo principal del aprendizaje automático está centrado alrededor de las estadísticas. No puedes resolver problemas del mundo real con aprendizaje automático si no tienes un buen conocimiento de los fundamentos estadísticos.

Ciertamente hay factores que hacen el aprendizaje de estadística muy difícil. Hablo acerca de las ecuaciones matemáticas, notación griega, y conceptos meticulosamente definidos que hace difícil generar interés en el tema.

Podemos abordar estos problemas con explicaciones claras y simples, tutoriales a un ritmo adecuado, y proyectos prácticos para resolver problemas con métodos estadísticos aplicados.

Desde el análisis de datos exploratorio a el diseño de experimentos de pruebas de hipótesis, las estadísticas juegan un rol importante en resolución de problemas principales que abarcan todas las industrias y dominios.

Cualquiera que desee desarrollar una comprensión profunda del aprendizaje automático debe aprender cómo los métodos estadísticos forman la base de los algoritmos de regresión y clasificación, cómo las estadísticas nos permiten aprender de los datos y cómo nos ayudan a extraer significado de datos no etiquetados.

¿Por qué debes dominar la estadística?

Cada organización se esfuerza por convertirse en una organización basada en datos. Por eso estamos siendo testigos de un aumento en la demanda de cientifícos y analistas de datos.

Ahora, para resolver problemas, responder preguntas, y trazar una estrategia, necesitamos hacer sentido de los datos. Afortunadamente, las estadísticas ofrecen una colección de herramientas para producir esos resultados.

De los datos al conocimiento

De manera aislada, las observaciones sin modificar son solo datos. Utilizamos estadísticas descriptivas para transformar estas observaciones en información que tenga sentido.

Luego podemos utilizar estadísticas inferenciales para estudiar pequeñas muestras de datos y extrapolar nuestros hallazgos a toda la población.

Las estadísticas ayudan a responder preguntas como...

• ¿Qué características son las más importantes?
• ¿Cómo deberíamos diseñar el experimento para desarrollar nuestra estrategia de producto?
• ¿Qué métricas de rendimiento deberíamos medir?
• ¿Cuál es el resultado más común y esperado?
• ¿Cómo diferenciamos entre ruido y datos válidos?

Todas estas son preguntas comunes e importantes que los equipos de datos deben responder a diario.

Las respuestas nos ayudan a tomar decisiones de manera eficaz. Los métodos estadísticos no solo nos ayudan a establecer proyectos de modelado predictivo, sino también a interpretar los resultados.

Proyectos de estadística y aprendizaje automático

Casi todos los proyectos de aprendizaje automático consisten en las siguientes tareas, y las estadísticas desempeñan un papel central en todos ellos de una forma u otra. A continuación, se explica cómo:

Definición de un enunciado del problema

La parte más crucial del modelado predictivo es la definición real del problema que nos brinda el objetivo real que debemos perseguir.

Esto nos ayuda a decidir el tipo de problema con el que nos enfrentamos (es decir, regresión o clasificación). Y también nos ayuda a decidir la estructura y los tipos de entradas, salidas y métricas con respecto al objetivo.

Pero la formulación del problema no siempre es sencilla. Si eres nuevo en el aprendizaje automático, es posible que requieras una exploración significativa de las observaciones en el dominio. Dos conceptos principales que debes dominar aquí son el análisis exploratorio de datos (EDA) y la minería de datos.

Exploración inicial de datos

La exploración de datos implica obtener un conocimiento profundo tanto de las distribuciones de las variables como de las relaciones entre las variables de los datos.

En parte, la experiencia en un campo le ayuda a adquirir este dominio sobre un tipo específico de variable. Sin embargo, tanto los expertos como los recién llegados al campo se benefician al manejar realmente observaciones reales del campo.

Los conceptos importantes relacionados con las estadísticas se reducen al aprendizaje de las estadísticas descriptivas y la visualización de datos.

Limpieza de datos

A menudo, los puntos de datos que se ha recopilado de un experimento o un repositorio de datos no están en un estado perfecto. Es posible que los datos hayan sido sometidos a procesos o manipulaciones que dañaron su integridad. Esto afecta aún más a los procesos o modelos posteriores que utilizan los datos.

Algunos ejemplos comunes incluyen valores faltantes, corrupción de datos, errores de datos (debido a un sensor defectuoso) y datos sin formato (observaciones con diferentes escalas).

Si desea dominar los métodos de limpieza, debe aprender sobre la detección de valores atípicos y la imputación de valores faltantes.

Preparación de datos y configuración de canales de transformación

Si los datos contienen errores e inconsistencias, a menudo no se pueden utilizar directamente para el modelado.

Primero, es posible que los datos deban pasar por un conjunto de transformaciones para cambiar su forma o estructura y hacerlos más adecuados para el problema que ha definido o los algoritmos de aprendizaje que está utilizando.

Luego, puedes desarrollar un canal de dichas transformaciones que aplique a los datos para producir una entrada consistente y compatible para el modelo.

Debes dominar conceptos como el muestreo de datos y los métodos de selección de características, las transformaciones de datos, el escalado y la codificación.

Selección y evaluación de modelos

Un paso clave para resolver un problema predictivo es seleccionar y evaluar el método de aprendizaje. Las estadísticas de estimación le ayudan a puntuar las predicciones del modelo a partir de datos no vistos.

El diseño experimental es un subcampo de la estadística que impulsa el proceso de selección y evaluación de un modelo. Exige una buena comprensión de las pruebas de hipótesis estadísticas y las estadísticas de estimación.

Ajuste fino del modelo

Casi todos los algoritmos de aprendizaje automático tienen un conjunto de hiperparámetros que permiten personalizar el método de aprendizaje para el marco del problema elegido.

Este ajuste de hiperparámetros suele ser de naturaleza empírica, en lugar de analítica. Requiere grandes conjuntos de experimentos para evaluar el efecto de diferentes configuraciones de hiperparámetros en el rendimiento del modelo.

Plan de estudios de estadística para profesionales

Un buen plan de estudios de estadística para profesionales no solo debe cubrir la gran cantidad de métodos y herramientas que acabo de mencionar. También debe cubrir y explorar los problemas más comunes que enfrenta la industria.

La siguiente es una lista de habilidades ampliamente utilizadas que necesitará conocer para tener éxito en las entrevistas de ciencia de datos y aprendizaje automático y conseguir un trabajo en el campo.

Habilidades de estadística general

• Cómo definir preguntas que se puedan responder estadísticamente para una toma de decisiones eficaz.
• Calcular e interpretar estadísticas comunes y cómo utilizar técnicas de visualización de datos estándar para comunicar los hallazgos.
• Comprensión de cómo se aplica la estadística matemática al campo, conceptos como el teorema del límite central y la ley de los grandes números.
• Realizar inferencias a partir de estimaciones de ubicación y variabilidad (ANOVA).
• Cómo identificar la relación entre las variables objetivo y las variables independientes.
• Cómo diseñar experimentos de prueba de hipótesis estadísticas, pruebas A/B, etc.
• Cómo calcular e interpretar métricas de rendimiento como el valor p, alfa, errores tipo 1 y tipo 2, etc.

Conceptos estadísticos importantes

• Introducción: comprensión de los tipos de datos (rectangulares y no rectangulares), estimación de la ubicación, estimación de la variabilidad, distribuciones de datos, datos binarios y categóricos, correlación, relación entre diferentes tipos de variables.
• Distribución de estadísticas: números aleatorios, ley de los grandes números, teorema del límite central, error estándar, etc.
• Muestreo y distribuciones de datos: muestreo aleatorio, sesgo de muestreo, sesgo de selección, distribución de muestreo, arranque, intervalo de confianza, distribución normal, distribución t, distribución binomial, distribución de chi-cuadrado, distribución F, distribución de Poisson y exponencial.
• Experimentos estadísticos y pruebas de significancia: pruebas A/B, realización de pruebas de hipótesis (nula/alternativa), remuestreo, significancia estadística, intervalo de confianza, valor p, alfa, pruebas t, grado de libertad, ANOVA, valores críticos, covarianza y correlación, tamaño del efecto, potencia estadística.
• Métodos estadísticos no paramétricos: datos de rango, pruebas de normalidad, normalización de datos, correlación de rango, pruebas de significación de rango, prueba de independencia

Consejos prácticos de aprendizaje

La mayoría de las universidades han diseñado sus programas de estudio de estadística para poner a prueba la capacidad de memorización de los estudiantes. Solo comprueban si los estudiantes pueden resolver ecuaciones, definir terminologías e identificar gráficos que deriven ecuaciones, en lugar de centrarse en la aplicación de estos métodos para resolver problemas del mundo real.

Sin embargo, los aspirantes a profesionales deben seguir un proceso paso a paso de aprendizaje e implementación de métodos estadísticos en diferentes problemas utilizando código de Python ejecutable.

Veamos los dos enfoques principales para estudiar estadística un poco más en profundidad:

Enfoque descendente

Supongamos que le piden que diseñe un experimento para probar la eficiencia de dos versiones de una característica de un producto. Se supone que esta característica aumenta la participación de los usuarios en un portal en línea.

Con un enfoque descendente, primero aprenderá más sobre el problema. Luego, una vez que el objetivo esté claro, puede aprender a aplicar los métodos estadísticos adecuados.

Esto lo mantiene involucrado y ofrece una mejor experiencia de aprendizaje práctico.

Enfoque ascendente

Este enfoque es el que utilizan la mayoría de las universidades y cursos en línea para enseñar estadística. Se centra en aprender los conceptos teóricos con notación matemática, la historia de ese concepto y cómo implementarlo.

Para las personas como yo, que tienden a perder interés en el aprendizaje teórico, esta no es la forma correcta de aprender estadística aplicada. Lo vuelve demasiado metafórico, lo que hace que el tema sea árido y deprimente sin ningún vínculo directo con la resolución de problemas.

Como probablemente puedes deducir, recomiendo un enfoque descendente para estudiar estadística.

Veamos ahora algunos recursos específicos que recomiendo para comenzar por el camino correcto.

Recursos de aprendizaje

• Libro sobre estadística práctica (en inglés): este libro le enseñará estadística desde el punto de vista de la ciencia de datos. Debe leer al menos los primeros tres capítulos de este libro.

• Estadística y probabilidad | Khan Academy (en inglés): este curso te preparará bien para todas las preguntas relacionadas con la estadística y la probabilidad durante la entrevista. Un curso gratuito con una buena recopilación de videoconferencias y problemas prácticos.

• Estadística al desnudo: para las personas que temen a las matemáticas y prefieren entender ejemplos prácticos, este es un libro increíble que explica cómo se aplica la estadística en situaciones de la vida real.

• Métodos estadísticos para el aprendizaje automático (en inglés): este libro sirve como curso intensivo sobre métodos estadísticos para profesionales del aprendizaje automático. Idealmente, para aquellos con experiencia como desarrolladores.

A continuación…

Crearé una serie de tutoriales sobre cada uno de los temas mencionados anteriormente siguiendo un enfoque de código primero para que podamos comprender y visualizar el significado y la aplicación de estos conceptos.

Si me he olvidado de algún detalle o si quieres que cubra algún otro aspecto de las estadísticas, responde a esta historia y lo agregaré al plan de estudios.

Ciencia de datos con Harshit

Con este canal, planeo lanzar un par de series que cubran todo el espacio de la ciencia de datos. Aquí está el motivo por el cual deberías suscribirte al canal:

• Esta serie cubriría todos los tutoriales de calidad requeridos/exigidos sobre cada uno de los temas y subtemas, como los fundamentos de Python para la ciencia de datos.
• Explicación de las matemáticas y las derivaciones de por qué hacemos lo que hacemos en ML y Deep Learning.
• Podcasts con científicos e ingenieros de datos de Google, Microsoft, Amazon, etc., y directores ejecutivos de empresas impulsadas por big data.
• Proyectos e instrucciones para implementar los temas aprendidos hasta ahora. Obtén información sobre nuevas certificaciones, Bootcamp y recursos para aprobar esas certificaciones, como este Examen de Certificación de Desarrollador de TensorFlow de Google.

Si este tutorial te resultó útil, deberías consultar mis cursos de ciencia de datos y aprendizaje automático en Wiplane Academy. Son completos pero compactos y te ayudan a construir una base sólida de trabajo para exhibir.

¿Qué es el algoritmo de descenso de gradiente?

El descenso de gradiente es probablemente el algoritmo de aprendizaje automático más popular. En esencia, el algoritmo existe para minimizar los errores tanto como sea posible.

El objetivo del descenso de gradiente como algoritmo es minimizar la función de costo de un modelo. Podemos decir esto por los significados de las palabras 'Gradiente' y 'Descenso'.

Mientras que gradiente significa la brecha entre dos puntos definidos (esa es la función de costo en este contexto), el descenso se refiere al movimiento hacia abajo en general (es decir, minimizar la función de costo en este contexto).

Entonces, en el contexto del aprendizaje automático, Descenso de Gradiente (Gradient Descent en inglés) se refiere al intento iterativo de minimizar el error de predicción de un modelo de aprendizaje automático ajustando sus parámetros para producir el menor error posible.

Este error se conoce como la Función de Costo. La función de costo es un gráfico de la respuesta a la pregunta "¿En cuánto difiere el valor predicho del valor real?". Si bien la forma de evaluar las funciones de costo a menudo difiere para diferentes modelos de aprendizaje automático, en un modelo de regresión lineal simple, generalmente se refiere al error cuadrático medio del modelo.

Es importante tener en cuenta que para los modelos más simples como la regresión lineal, un gráfico de la función de costo suele tener forma de arco, lo que facilita determinar el punto mínimo.

Sin embargo, este no es siempre el caso. Para modelos más complejos (por ejemplo, redes neuronales), es posible que el gráfico no tenga forma de arco. Es posible que la función de costo tenga múltiples puntos mínimos como se muestra en la imagen a continuación.

¿Cómo funciona el descenso de gradiente?

En primer lugar, es importante tener en cuenta que, como la mayoría de los procesos de aprendizaje automático, el algoritmo de descenso de gradiente es un proceso iterativo.

Suponiendo que tiene la función de costo para un modelo de regresión lineal simple como j(w,b) donde j es una función de w y b, el algoritmo de descenso de gradiente funciona de tal manera que comienza con una conjetura aleatoria inicial para w y b. El algoritmo seguirá modificando los parámetros w y b en un intento de optimizar la función de costo, j.

En la regresión lineal, la elección de los valores iniciales no importa mucho. Una opción común es cero.

La analogía perfecta para el algoritmo de descenso de gradiente que minimiza la función de costo j(w, b) y alcanza su mínimo local ajustando los parámetros w y b es caminar hasta el pie de una montaña o colina (como se muestra en la gráfica 3D de la función de costo de un modelo de regresión lineal simple mostrado anteriormente).

O bien, podemos imaginar que estamos tratando de llegar al punto más bajo de un campo de golf. En cualquier caso, darán pasos cortos, repetitivos hasta llegar al pie de la montaña o colina.

La fórmula de descenso de gradiente

Aquí está la fórmula para el descenso de gradiente: b = a - γ Δ f(a)

La ecuación anterior describe el accionar del algoritmo de descenso de gradiente.

Es decir, b es la siguiente posición del excursionista, mientras que representa la posición actual. El signo menos es para la parte de minimización del algoritmo de descenso de gradiente, ya que el objetivo es minimizar el error tanto como sea posible. γ en el medio es un factor conocido como tasa de aprendizaje, y el término Δf(a) es un término de gradiente que define la dirección del punto mínimo.

Como tal, esta fórmula indica la siguiente posición para el excursionista/la persona en el campo de golf (esa es la dirección del descenso más empinado).

Es importante notar que el término γΔ f(a) se resta de a porque el objetivo es moverse contra el gradiente, hacia el mínimo local.

¿Qué es la tasa de aprendizaje?

La tasa de aprendizaje es el determinante de cuán grandes son los pasos que toma el descenso del gradiente en la dirección del mínimo local. Determina la velocidad con la que el algoritmo se mueve hacia los valores óptimos de la función de coste.

Debido a esto, la elección de la tasa de aprendizaje, γ, es importante y tiene un impacto significativo en la efectividad del algoritmo.

Si la tasa de aprendizaje es demasiado grande como se muestra arriba, en un intento por encontrar el punto óptimo, se mueve desde el punto de la izquierda hasta el punto de la derecha (como la tasa de aprendizaje es muy grande, los "saltos" también lo son, por lo que es muy difícil que el algoritmo acierte en el punto óptimo).En ese caso, vemos que la función de costo ha empeorado.

Por otro lado, si la tasa de aprendizaje es demasiado pequeña, los descensos de gradiente funcionarán, aunque muy lentamente. Es decir, como los pasos son muy pequeños, es muy probable que el algoritmo acierte, aunque la optimización irá muy despacio.

Es por ello, importante elegir cuidadosamente la tasa de aprendizaje.

Cómo implementar el descenso de gradiente en la regresión lineal

import numpy as np
import matplotlib.pyplot as plt

class Linear_Regression:
	def __init__(self, X, Y):
		self.X = X
		self.Y = Y
		self.b = [0, 0]
	
	def update_coeffs(self, learning_rate):
		Y_pred = self.predict()
		Y = self.Y
		m = len(Y)
		self.b[0] = self.b[0] - (learning_rate * ((1/m) * np.sum(Y_pred - Y)))
		self.b[1] = self.b[1] - (learning_rate * ((1/m) * np.sum((Y_pred - Y) * self.X)))
        
	def predict(self, X=[]):
		Y_pred = np.array([])
		if not X: X = self.X
		b = self.b
		for x in X:
			Y_pred = np.append(Y_pred, b[0] + (b[1] * x))

		return Y_pred
	
	def get_current_accuracy(self, Y_pred):
		p, e = Y_pred, self.Y
		n = len(Y_pred)
		return 1-sum(
			[
				abs(p[i]-e[i])/e[i]
				for i in range(n)
				if e[i] != 0]
		)/n
	#def predict(self, b, yi):

	def compute_cost(self, Y_pred):
		m = len(self.Y)
		J = (1 / 2*m) * (np.sum(Y_pred - self.Y)**2)
		return J

	def plot_best_fit(self, Y_pred, fig):
				f = plt.figure(fig)
				plt.scatter(self.X, self.Y, color='b')
				plt.plot(self.X, Y_pred, color='g')
				f.show()


def main():
	X = np.array([i for i in range(11)])
	Y = np.array([2*i for i in range(11)])

	regressor = Linear_Regression(X, Y)

	iterations = 0
	steps = 100
	learning_rate = 0.01
	costs = []
	
	#original best-fit line
	Y_pred = regressor.predict()
	regressor.plot_best_fit(Y_pred, 'Initial Best Fit Line')
	

	while 1:
		Y_pred = regressor.predict()
		cost = regressor.compute_cost(Y_pred)
		costs.append(cost)
		regressor.update_coeffs(learning_rate)
		
		iterations += 1
		if iterations % steps == 0:
			print(iterations, "epochs elapsed")
			print("Current accuracy is :",
				regressor.get_current_accuracy(Y_pred))

			stop = input("Do you want to stop (y/*)??")
			if stop == "y":
				break

	#final best-fit line
	regressor.plot_best_fit(Y_pred, 'Final Best Fit Line')

	#plot to verify cost function decreases
	h = plt.figure('Verification')
	plt.plot(range(iterations), costs, color='b')
	h.show()

	# if user wants to predict using the regressor:
	regressor.predict([i for i in range(10)])

if __name__ == '__main__':
	main()

En esencia, puedes ver que el bloque de código entrena un algoritmo de descenso de gradiente para un modelo de aprendizaje automático de regresión lineal usando 0.01  como tasa de aprendizaje, basándose en 100 pasos.

Al ejecutar el código, tenemos lo siguiente:

Conclusión

En conclusión, es importante tener en cuenta que el algoritmo de descenso de gradiente es especialmente importante en los dominios de inteligencia artificial y aprendizaje automático, ya que los modelos deben optimizarse para la precisión.
En este artículo, aprendimos qué es el algoritmo de descenso de gradiente, cómo funciona, su fórmula, qué tasa de aprendizaje es y la importancia de elegir la tasa de aprendizaje correcta. También vimos una ilustración de código de cómo funciona Gradient Descent.
Finalmente, compartí mis escritos sobre inteligencia artificial, aprendizaje automático y Microsoft Azure en Twitter si disfrutaste este artículo y quieres ver más.

Q-learning es un algoritmo de aprendizaje basado en valores en el aprendizaje por refuerzo. En este artículo, aprenderemos sobre Q-Learning y sus detalles:

• ¿Qué es Q-Learning?
• Matemáticas detrás de Q-Learning

Q-Learning — Una visión general simplificada

Digamos que un robot tiene que cruzar un laberinto y llegar al punto final. Hay minas, y el robot sólo puede moverse una casilla a la vez. Si el robot pisa una mina, el robot muere. El robot tiene que llegar al punto final en el menor tiempo posible.

El sistema de puntuación/recompensa es el siguiente:

1. El robot pierde 1 punto en cada paso. Esto se hace para que el robot tome el camino más corto y llegue a la meta lo más rápido posible.
2. Si el robot pisa una mina, la pérdida de puntos es de 100 y el juego termina.
3. Si el robot obtiene poder ⚡️, gana 1 punto.
4. Si el robot alcanza la meta, el robot obtiene 100 puntos.

Ahora, la pregunta obvia es: ¿Cómo entrenamos a un robot para llegar a la meta final con el camino más corto sin pisar una mina?

Entonces, ¿cómo resolvemos esto?

Introducción a Q-Table

Q-Table es sólo un nombre elegante para una simple tabla de búsqueda donde calculamos las máximas recompensas futuras esperadas por acción en cada estado. Básicamente, esta tabla nos guiará a la mejor acción en cada estado.

Habrá cuatro números de acciones en cada mosaico sin bordes. Cuando un robot está en un estado puede moverse hacia arriba, hacia abajo, hacia la derecha o la izquierda.

Por lo tanto, modelemos este entorno en nuestra Q-Table.

En la Q-Table, las columnas son las acciones y las filas son los estados.

Cada puntuación de la Q-Table será la máxima recompensa futura esperada que el robot recibirá si toma esa acción en ese estado. Se trata de un proceso iterativo, ya que necesitamos mejorar la Q-Table en cada iteración.

Pero las preguntas son:

• ¿Cómo calculamos los valores de la Q-Table?
• ¿Los valores están disponibles o predefinidos?

Para aprender cada valor de la Q-Table, utilizamos el algoritmo Q-Learning.

Matemáticas: el algoritmo Q-Learning

Q-function

La Q-function utiliza la ecuación de Bellman y toma dos entradas: estado (s) y acción (a).

Usando la función anterior, obtenemos los valores de Q para las celdas de la tabla.

Cuando empezamos, todos los valores de la Q-Table son ceros.

Hay un proceso iterativo de actualización de los valores. A medida que comenzamos a explorar el entorno, la Q-function nos da mejores y mejores aproximaciones, actualizando continuamente los Q-values de la tabla.

Ahora, vamos a entender cómo se lleva a cabo la actualización.

Introducción al proceso del algoritmo Q-Learning

Cada una de las cajas de colores es un paso. Vamos a entender cada uno de estos pasos en detalle.

Paso 1: Inicializar la Q-Table

Primero construiremos una Q-Table. Hay n columnas, donde n= número de acciones. Hay m filas, donde m= número de estados. Inicializaremos los valores en 0.

En nuestro ejemplo de robot, tenemos cuatro acciones (a=4) y cinco estados (s=5). Así que vamos a construir una tabla con cuatro columnas y cinco filas.

Pasos 2 y 3: elegir y realizar una acción

Esta combinación de pasos se realiza por un tiempo indefinido. Esto significa que este paso se ejecuta hasta el momento en que detenemos el entrenamiento, o el bucle de entrenamiento se detiene como se define en el código.

Elegiremos una acción (a) en el estado (s) basado en la Q-Table. Pero, como se mencionó anteriormente, cuando el episodio comienza inicialmente, cada valor de Q es 0.

Así que ahora entra en juego el concepto de compensación de exploración y explotación.

Vamos a utilizar algo llamado la estrategia codiciosa de Épsilon.

Al principio, las tasas de épsilon serán más altas. El robot explorará el entorno y elegirá acciones al azar. La lógica detrás de esto es que el robot no sabe nada sobre el medio ambiente.

A medida que el robot explora el entorno, la velocidad de épsilon disminuye y el robot comienza a explotar el entorno.

Durante el proceso de exploración, el robot adquiere progresivamente más confianza en la estimación de los Q-values.

Para el ejemplo del robot, hay cuatro acciones para elegir: arriba, abajo, izquierda y derecha. Comenzamos el entrenamiento ahora — nuestro robot no sabe nada sobre el medio ambiente. Así que el robot elige una acción al azar, la derecha.

Ahora podemos actualizar los Q-values para estar en el comienzo y mover a la derecha usando la ecuación de Bellman.

Pasos 4 y 5: evaluar

Ahora hemos tomado una acción y observado un resultado y recompensa.Necesitamos actualizar la función Q(s,a).

En el caso del juego del robot, para reiterar la estructura de puntuación/recompensa es:

• power = +1
• mine = -100
• end = +100

Repetiremos esto una y otra vez hasta que el aprendizaje se detenga. De esta manera se actualizará la Q-Table.

Vamos a recapitular

• Q-Learning es un algoritmo de aprendizaje por refuerzo basado en valores que se utiliza para encontrar la política óptima de selección de acciones utilizando una función Q.
• Nuestro objetivo es maximizar la función de valor Q.
• La Q-Table nos ayuda a encontrar la mejor acción para cada estado.
• Ayuda a maximizar la recompensa esperada seleccionando la mejor de todas las acciones posibles.
• Q(estado, acción) devuelve la recompensa futura esperada de esa acción en ese estado.
• Esta función se puede estimar usando Q-Learning, que actualiza iterativamente Q(s,a) usando la ecuación de Bellman.
• Inicialmente, exploramos el entorno y actualizamos la Q-Table. Cuando la Q-Table esté lista, el agente comenzará a explotar el entorno y comenzará a tomar mejores medidas.

Si usted tiene alguna pregunta, por favor hágamelo saber en un comentario en Twitter.

Introducción

Este artículo tratará acerca del tema estadístico de error cuadrático medio y describirá la relación de este método con la regresión lineal, la regresión más básica en el contexto del aprendizaje automático (machine learning).

El ejemplo consiste de puntos en el eje cartesiano. Definiremos una función matemática que nos dará la línea recta que pasa en medio de todos los puntos del eje cartesiano.

De esta manera, aprenderemos la conexión entre estos dos métodos y cómo los resultados de su conexión aparecen juntos.

Explicación General

Contexto

El error cuadrático(MSE) mide el promedio de los errores elevados al cuadrado.

El hecho que el MSE es casi siempre estrictamente positivo(y no zero) es debido a la aleatoriedad o a que el estimador carece de información con la que pueda producir una mejor estimación.

La estructura del artículo

• Obtén una idea del ECM y su visualización gráfica.
• La parte matemática que contiene manipulaciones algebraicas y una derivación de una función de dos variables encontrando su mínimo.
• Esta sección es para quienes desean comprender el proceso de cómo obtenemos las fórmulas matemáticas finales. Puedes saltarte esta parte si tu interés no es este.
• Una explicación del rol de cada variable en la fórmula.
• Ejemplos.

Ideas Generales:

Supongamos que tenemos siete puntos, nuestro objetivo es encontrar la línea que minimiza la suma de las distancias elevadas al cuadrado de estos puntos.

Tratemos de comprender esto.

Tomemos un ejemplo y tracemos una línea en medio de siete puntos aleatorios.

Podrías estar preguntándote ¿Qué significa esta gráfica?

• Los puntos púrpuras son los siete puntos aleatorios en la gráfica. Cada punto posee una coordenada X y una coordenada Y.
• La línea azul es nuestra línea de predicción. Es una línea que pasa a través de todos los puntos y que se ajusta a ellos de la mejor manera posible, de este modo esta línea contiene todos los puntos.
• La línea roja entre cada punto púrpura y la línea de predicción son los errores. Cada error es la distancia desde el punto hasta su punto estimado.

Puede que ahora recuerdes esta ecuación en tus días de escuela, y=Mx+B, donde M es la pendiente de la recta, y  B es su intercepto.

Queremos encontrar la pendiente M y él interceptó B  que  minimiza el error cuadrático.

Definamos la ecuación matemática que nos proporcionará el error cuadrático medio para todos nuestros puntos.

Analicemos el significado de esta ecuación.

• Sigma representa la suma de la secuencia de números desde i=1 hasta n. Imaginemos esto cómo un arreglo de puntos, donde en el proceso se pasa a través de todos los puntos, desde el primero (i=1) hasta el último (i=n).
• Por cada punto, tomamos la coordinada y del punto, y la coordenada  y’. Sustraemos la coordenada y, de nuestra coordenada  y’ (es decir los valores estimados) y calculamos el cuadrado del resultado.
• La tercera parte es tomar la suma de todos los valores  (y-y’)², es decir, la diferencia entre los valores reales y estimados elevados al cuadrado.
• Finalmente procedemos a dividir esas diferencias al cuadrado por n y así obtenemos la media.

Nuestro objetivo es minimizar esta media. Lo que nos proveerá con la mejor línea que pasa a través de los puntos.

Del concepto a las ecuaciones matemáticas

Esta parte es para las personas que quieren comprender cómo obtenemos las ecuaciones matemáticas.

Cómo vimos anteriormente, tenemos la ecuación y=mx+b.

Tomemos cada punto en la gráfica, y luego haremos nuestro propio cálculo (y-y’)².
¿Pero cómo calculamos y? No tenemos qué porque es parte de los datos.

Recordemos la definición algebraica, de (y-y’)². A partir de aquí, obtenemos el desglose de la ecuación del error cuadrático medio (MSE):

Reescribimos la ecuación y simplificamos.

Comenzamos operando los paréntesis en la ecuación. Nótese la distinción anaranjada y morado de las ecuaciones.

Ahora, apliquemos otra manipulación. Juntaremos cada parte de la ecuación. Tomaremos todas la y, así como todas las (-2ymx) etc. En otras palabras, agrupación de términos.

En este punto, podemos tomar la media de todos los valores elevados al cuadrado de y, xy, x, x².

Definamos para cada uno, un nuevo carácter que representará la media de todos los valores al cuadrado.

Veamos un ejemplo, tomemos todos los valores y, y luego dividamos por n (n representa el número de elementos), entonces obtendremos la media, y la llamaremos Y promedio.

Si multiplicamos ambos lados de la ecuación por n, obtendremos:

Esto nos llevará a la siguiente ecuación:

Tenemos una ecuación de tres dimensiones. Queremos encontrar los valores M y B(recordar la ecuación de la recta) que minimizan la función.

Debido a que es un problema de minimización, entramos al mundo del cálculo diferencial, la forma de minimizar una ecuación consiste en igualar a cero y luego derivar. Sin embargo, en este caso tenemos que tomar una derivada parcial. Tomamos la derivada parcial con respecto a M y la derivada parcial con respecto a B de nuestro MSE.

Ya que estamos buscando un punto mínimo, tomaremos las derivadas parciales, igualándolas a cero.

Tomemos las dos ecuaciones que acabamos de obtener, separando la variable b de ambas, y luego sustrayendo la primera ecuación de la segunda.

Pasamos a sustraer la primera ecuación de la segunda.

Nos deshacemos de los denominadores en la ecuación.

Y aquí estamos, esta es la ecuación para encontrar M, tomamos esta para escribir la ecuación B.

Ecuaciones para la pendiente y él interceptó y.

Estas serán las ecuaciones matemáticas que nos ayudarán a encontrar la pendiente y él interceptó.

Hablemos un poco más acerca de estas ecuaciones:

Ejemplos

Muchas Gracias a Khan Academy por los ejemplos.

Ejemplo #1

Tomemos 3 puntos, (1,2), (2,1), (4,3).

Encontremos M y B para la ecuación y=mx+b.

Luego de haber calculado las partes relevantes de nuestras ecuaciones pendientes e intercepto, sustituyamos algunos valores en las ecuaciones  veamos cómo obtenemos una pendiente y un intercepto y.

Tomemos estos resultados y definámoslos cómo una sola ecuación y=mx+b.

Ahora dibujemos la línea y veamos cómo esta pasa a través de los puntos a la vez que minimiza sus distancias elevadas al cuadrado.

Ejemplo #2

Tomemos 4 puntos, (-2,-3), (-1,-1), (1,2), (4,3).

Vamos a encontrar M y B para la ecuación y = mx + b.

Lo mismo que antes, sustituyamos estos valores en las ecuaciones para encontrar  M y B.

Definiendo estos resultados cómo una sola ecuación.

Ahora graficamos la línea y vemos cómo esta pasa a través de los puntos a la vez que minimiza sus distancias elevadas al cuadrado.

En Conclusión

Cómo puedes ver, la idea es simple. Solo es necesario comprender las partes principales y cómo trabajar con ellas.

Puedes trabajar con las fórmulas para encontrar la línea en otra gráfica, y así efectuar un cálculo simple, obteniendo los resultados para la pendiente y él interceptó.

Este artículo ha hecho más énfasis en el error cuadrático medio y  los aspectos matemáticos de la línea de regresión que minimiza el MSE. No tanto así en el aspecto intuitivo y de aplicación práctica que se encuentran fuera del alcance del artículo.

No obstante, la regresión lineal suele ser de las primeras lecciones en aprendizaje automático e inteligencia artificial, por lo tanto es muy importante conocer su aspecto matemático.

Muchas Gracias por tu atención.

Scikit-learn es uno de los open-source y bibliotecas de aprendizaje automático más populares en Python.

La biblioteca scikit-learn contiene muchas herramientas eficientes para aprendizaje automático y modelado estadístico, incluyendo clasificación, regresión, agrupación, y reducción de dimensionalidad.

Varios científicos de datos, ingenieros de aprendizaje automático e investigadores dependen de esta biblioteca para sus proyectos. Personalmente, me encanta usar scikit-learn porque ofrece muchísima flexibilidad, siendo además fácil de comprender debido a una documentación que ofrece una multitud de ejemplos.

En este artículo, estaré feliz de compartir contigo las cinco nuevas características en scikit-learn 0.24.

Instalemos la última versión de la biblioteca Scikit-Learn.

Primero que nada, asegúrate de instalar la última versión (con pip):

pip install --upgrade scikit-learn

Si estás usando Anaconda, emplea el siguiente comando:

conda install -c conda-forge scikit-learn

Nota:Esta versión soporta las versiones de Python 3.6 hasta 3.9.

Ahora, veamos las nuevas características.

Error Porcentual Absoluto Medio.

Esta nueva versión de scikit-learn introduce una nueva métrica de evaluación para un problema de regresión llamado Error Porcentual Absoluto Medio, conocido en inglés como "Mean Absolute Percentage Error" (MAPE). Anteriormente teníamos que calcularlo así.

np.mean(np.abs((y_test — preds)/y_test))

Ahora simplemente llamas a la función mean_absolute_percentage_error   a partir del módulo de sklearn.metrics.

Con esto puedes evaluar que tan bien funciona tu modelo.

Por ejemplo:

from sklearn.metrics import mean_absolute_percentage_error
y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]

print(mean_absolute_percentage_error(y_true, y_pred))

0.3273809523809524

Nota: Recuerda que la función en sí, no expresa su resultado cómo un porcentaje en el rango [0, 100]. En su lugar, el resultado se representa en un rango de  [0, 1].  El mejor valor posible es 0.0.

OneHotEncoder resuelve la insuficiencia de datos.

OneHot Encoder , a grosso modo consiste en reemplazar una variable categórica por una variable binaria (0,1) mediante una transformación. Este puede resolver la falta de datos en caso de presentarse en una hoja de datos, puesto que trata cualquier valor faltante cómo una categoría. Veamos un ejemplo para entender más a detalle de qué se trata.

Primero importa pandas, numpy y scikit-learn:

import pandas as pd 
import numpy as np
from sklearn.preprocessing import OneHotEncoder

Crea un simple marco de datos con variables categóricas que posean valores faltantes:

# intialise data of lists.
datos = {'nivel_educacion':['primaria', 'segundaria', 'pregrado', np.nan,'master',np.nan]}
  
# Create DataFrame
df = pd.DataFrame(datos)
  
# imprime el resultado.
print(df)

Cómo puedes ver, tenemos dos valores nulos en nuestra columna de educación.

A continuación creamos la instancia de OneHotEncoder:

ohe = OneHotEncoder()

Luego ajustamos y transformamos nuestros datos:

ohe.fit_transform(df).toarray()

Nuestra columna de educación ha sido transformada y todos los valores nulos han sido incluidos en una nueva categoría (Observa la última columna en el arreglo).

Nuevo método para selección de variables.

SequentialFeatureSelector es un nuevo método de selección de caracteristicas en scikit-learn. Existen dos formas de selección de variables, las definiciones técnicas son las siguientes: forward selection y backward selection.

Forward Selection (selección hacia adelante)

En palabras simples, el método de Forward Selection interactivamente encuentra la nueva característica y luego la añade al conjunto de características previamente seleccionadas.

Es decir, que comenzamos con cero características y luego encontramos una característica que maximiza la puntuación de validación cruzada de un estimador. La característica seleccionada es añadida al conjunto de variables y el proceso es repetido hasta lograr el número deseado de variables seleccionadas.

Backward Selection (selección hacia atrás)

Esta segunda selección sigue la misma idea que la anterior, pero en una dirección diferente. Aquí empieza con todas las características y luego remueve una característica del conjunto hasta que alcanzar el número deseado de características seleccionadas.

Ejemplos:

Importa los paquetes más importantes:

from sklearn.feature_selection import SequentialFeatureSelector
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris

Utiliza un conjunto de datos  que forma parte de los ejemplos que proporciona scikit-learn. Define los nombres de sus variables:

X, y = load_iris(return_X_y=True, as_frame=True)
feature_names = X.columns

Crea la instancia de un estimador (En este caso por K-Nearest Neighbors):

knn = KNeighborsClassifier(n_neighbors=3)

Crea la instancia responsable de seleccionar las variables (SequentialFeatureSelector), fijando el número de variables a seleccionar igual a 2, y la dirección “backward”:

sfs = SequentialFeatureSelector(knn, n_features_to_select=2,direction='backward')

Finalmente ajusta las variables seleccionadas:

sfs.fit(X,y)

Para mostrar las variables necesitaremos:

print("Features selected by backward sequential selection: "f{feature_names[sfs.get_support()].tolist()}")

Nuevos métodos para ajustar Hiperparámetros.

Cuando se trata de ajustar Hiperparámetros, GridSearchCV y RandomizedSearchCv en Scikit-learn han sido la primera elección en Data Science.

Sin embargo, en esta nueva versión, tenemos dos nuevas clases para ajustar Hiperparámetros; HalvingGridSearchCV y HalvingRandomSearchCV.

HalvingGridSearchCV y HalvingRandomSearchCV usan un nuevo algorithmo llamado successive halving, para encontrar los hiperparámetros óptimos.  

¿Cómo funciona el algorithmo successive halving?

En la primera iteración, se entrena una combinación de hiperparámetros en un subconjunto de observaciones, (datos de entrenamiento).

Luego en la próxima iteración, se selecciona solamente la combinación de hiperparámetros que tuvieron un buen desempeño en la primera iteración. De este modelo serán entrenados nuevamente solo que en número de observación más extenso.

Por último, se repite este proceso de selección en cada iteración hasta que selecciona la mejor combinación de hiperparámetros en la última iteración.

Nota: Todas estas clases de Scikit-learn son todavía experimentales:

Ejemplo:

Importamos los paquetes importantes:

from sklearn.datasets import make_classification
from sklearn.ensemble import RandomForestClassifier
from sklearn.experimental import enable_halving_search_cv  
from sklearn.model_selection import HalvingRandomSearchCV
from scipy.stats import randint

Ya que estas clases son todavía experimentales, para usarlas, importamos explícitamente, es decir, usamos import enable_halving_search_cv.

Creamos un conjunto de datos para clasificación usando el método make_classification:

X, y = make_classification(n_samples=1000)

Creamos la instancia del estimador. Usando un clasificador basado en bosques aleatorios, es decir, Random Forest Classifier:

clf = RandomForestClassifier(n_estimators=20)

Creamos la distribución del parámetro para el ajuste:

param_dist = {"max_depth": [3, None],
              "max_features": randint(1, 11),
              "min_samples_split": randint(2, 11),
              "bootstrap": [True, False],
              "criterion": ["gini", "entropy"]}

Definiendo con rsh la instancia de clase HalvingGridSearchCV con nuestro RandomForestClassifier(estimator=clf) como estimador, obtendremos la lista de distribuciones de nuestros parámetros:

rsh = HalvingRandomSearchCV(
    estimator=clf,
    param_distributions=param_dist,
    cv = 5,
    factor=2,
    min_resources = 20)

Hay dos parámetros muy importantes en HalvingRandomSearchCV a tomar en cuenta.

1. factor — Determina la proporción de la combinación de hiperparámetros que son seleccionados para cada iteración subsecuente. Por ejemplo, factor=3 significa que solo un tercio de los candidatos son seleccionados para la nueva iteración.
2. min_resources  es el total de recursos (número de observaciones) asignadas en la primera iteración para cada combinación de hiperparámetros.

Finalmente, podemos ajustar los parámetros del objeto de búsqueda (rsh) que hemos creado en nuestro conjunto de datos.

rsh.fit(X,y)

Podemos ver los resultados luego de haber entrenado nuestros datos:

1. El número de iteraciones

print(rsh.n_iterations_ )

que es 6.

2. El número de parámetros candidatos a ser evaluados en cada iteración.

print(rsh.n_candidates_ )

Los cuales son [50, 25, 13, 7, 4, 2].

3. El número de recursos a utilizados en cada iteración:

print(rsh.n_resources_)

que es [20, 40, 80, 160, 320, 640].

4. Los parámetros que proporcionan los mejores resultados:

print(rsh.best_params_)

Resultando:

{‘bootstrap’: False,
‘criterion’: ‘entropy’,
‘max_depth’: None,
‘max_features’: 5,
‘min_samples_split’: 2}

Nuevo meta-estimador de entrenamiento automático para aprendizaje semi-supervisado.

Scikit-learn 0.24 ha introducido una nueva implementación de auto-entrenamiento para aprendizaje semi-supervisado llamado SelfTrainingClassifier. Puedes utilizar el clasificador de autoaprendizaje con cualquier clasificador supervisado que retorne estimaciones de probabilidad para cada clase.

Esto significa que cualquier clasificador supervisado puede funcionar como un clasificador semi-supervisado, con el propósito de facilitar el aprendizaje de observaciones de datos no etiquetados, (datos no etiquetados).

Nota: Los valores no etiquetados en la columna de destino devén tener un valor de -1.

Entendamos más cómo funciona.

Una vez importados los elementos importantes, definimos una semilla aleatoria con Numpy,  luego procedemos a llamar a nuestro conjunto de datos anterior.  Finalmente, empleamos nuestro clasificador semi-supervisado con los valores no etiquetados (datos no etiquetados).

import numpy as np
from sklearn import datasets
from sklearn.semi_supervised import SelfTrainingClassifier
from sklearn.svm import SVC
rng = np.random.RandomState(42)
iris = datasets.load_iris()
random_unlabeled_points = rng.rand(iris.target.shape[0]) < 0.3
iris.target[random_unlabeled_points] = -1

Cómo puedes ver, los valores no etiquetados en el arreglo se expresan con valor de -1.

Creando una instancia del estimador supervisado:

svc = SVC(probability=True, gamma="auto")

Por otra parte, creando una instancia del nuevo SelfTrainingClassifier, añadiendo svc como nuestro estimador:

self_training_model = SelfTrainingClassifier(base_estimator=svc)

Finalmente, ajustamos nuestro modelo y sus correspondientes valores no etiquetados:

self_training_model.fit(iris.data, iris.target)

Resultado:

SelfTrainingClassifier(base_estimator=SVC(gamma=’auto’, probability=True))

Reflexiones finales acerca de Scikit-Learn 0.24

Cómo mencioné, scikit-learn permanece cómo uno de los  de los open-source y bibliotecas de aprendizaje automático más populares en Python. Posee todas las herramientas necesarias para construir un proyecto de aprendizaje automático de extremo a extremo.

También puedes implementar las nuevas funciones presentadas en este artículo en tu propio proyecto de aprendizaje automático.

Felicitaciones ?? llegaste al final de este artículo. Espero que hayas aprendido algo nuevo que te ayude en tu proyecto de aprendizaje automático o ciencia de datos.

¡Feliz aprendizaje!

En esta publicación, explico "el truco" detrás de NBC y les daré un ejemplo que podemos usar para resolver un problema de clasificación.

En las próximas secciones, hablaré sobre las matemáticas detrás de NBC. Siéntete libre de omitir esas secciones y pasar a la parte de implementación si no estás interesado en las matemáticas.

En la sección de implementación, te mostraré un algoritmo NBC simple. Luego lo usaremos para resolver un problema de clasificación. La tarea será determinar si cierto pasajero del Titanic sobrevivió al accidente o no.

Probabilidad condicional

Antes de hablar sobre el algoritmo en sí, hablemos de las matemáticas detrás de él. Necesitamos entender qué es la probabilidad condicional y cómo podemos usar el teorema de Bayes para calcularla.

Piense en un dado equilibrado con seis lados. ¿Cuál es la probabilidad de obtener un seis al lanzar el dado? Eso es fácil, es 1/6. Tenemos seis resultados posibles e igualmente probables, pero solo nos interesa uno de ellos. Entonces, 1/6 lo es.

Pero, ¿qué pasa si te digo que ya lancé el dado y el resultado es un número par? ¿Cuál es la probabilidad de que tengamos un seis ahora?

Esta vez, los posibles resultados son solo tres porque solo hay tres números pares en el dado. Todavía estamos interesados en solo uno de esos resultados, por lo que ahora la probabilidad es mayor: 1/3. ¿Cuál es la diferencia entre ambos casos?

En el primer caso, no teníamos información previa sobre el resultado. Por lo tanto, necesitábamos considerar todos los resultados posibles.

En el segundo caso, se nos dijo que el resultado era un número par, por lo que podíamos reducir el espacio de posibles resultados a solo los tres números pares que aparecen en un dado normal de seis caras.

En general, al calcular la probabilidad de un evento A, dada la ocurrencia de otro evento B, decimos que estamos calculando la probabilidad condicional de A dado B, o simplemente la probabilidad de A dado B. Lo denotamos P(A|B).

Por ejemplo, la probabilidad de obtener un seis dado que el número que tenemos es par: P(Seis|Par) = 1/3. Aquí, denotamos con Seis el evento de obtener un seis y con Par el evento de obtener un número par.

Pero, ¿cómo calculamos las probabilidades condicionales? ¿Existe una fórmula?

Cómo calcular probabilidades condicionales y el teorema de Bayes

Ahora, te daré un par de fórmulas para calcular probabilidades condicionales. Prometo que no serán difíciles y son importantes si deseas comprender la ideas detrás de los algoritmos de aprendizaje automático de los que hablaremos más adelante.

La probabilidad de un evento A dada la ocurrencia de otro evento B se puede calcular de la siguiente manera:

P(A|B) = P(A,B)/P(B)

Donde P(A,B) denota la probabilidad de A y B ocurriendo al mismo tiempo, y P(B) denota la probabilidad de B.

Observa que necesitamos P(B) > 0 porque no tiene sentido hablar de la probabilidad de A dado B si la ocurrencia de B no es posible.

También podemos calcular la probabilidad de un evento A, dada la ocurrencia de múltiples eventos B1, B2, ..., Bn:

P(A|B1,B2,...,Bn) = P(A,B1,B2,...,Bn)/P(B1,B2,...,Bn)

Hay otra forma de calcular probabilidades condicionales. Esta forma es el llamado Teorema de Bayes.

P(A|B) = P(B|A)P(A)/P(B)

P(A|B1,B2,...,Bn) = P(B1,B2,...,Bn|A)P(A)/P(B1,B2,...,Bn)

Observa que estamos calculando la probabilidad del evento A dado el evento B, invirtiendo el orden de ocurrencia de los eventos.

Ahora suponemos que ha ocurrido el evento A y queremos calcular la probabilidad del evento B (o eventos B1, B2, ..., Bn en el segundo y más general ejemplo).

Un dato importante que se puede derivar de este Teorema es la fórmula para calcular P(B1,B2,...,Bn,A). Eso se llama la regla de la cadena para las probabilidades.

P(B1,B2,...,Bn,A) = P(B1 | B2, B3, ..., Bn, A)P(B2,B3,...,Bn,A)
= P(B1 | B2, B3, ..., Bn, A)P(B2 | B3, B4, ..., Bn, A)P(B3, B4, ..., Bn, A)
= P(B1 | B2, B3, ..., Bn, A)P(B2 | B3, B4, ..., Bn, A)...P(Bn | A)P(A)

Esa es una fórmula fea, ¿no? Pero bajo algunas condiciones podemos hacer una solución y evitarlo.

Hablemos del último concepto que necesitamos saber para entender los algoritmos.

Independencia

El último concepto del que vamos a hablar es el de independencia. Decimos que los eventos A y B son independientes si

P(A|B) = P(A)

Eso significa que la probabilidad del evento A no se ve afectada por la ocurrencia del evento B. Una consecuencia directa es que P(A,B) = P(A)P(B).

En términos sencillos, esto significa que la probabilidad de la ocurrencia de A y B al mismo tiempo es igual al producto de las probabilidades de los eventos A y B que ocurren por separado.

Si A y B son independientes, también se sostiene que:

P(A,B|C) = P(A|C)P(B|C)

¡Ahora estamos listos para hablar sobre los clasificadores Naive Bayes!

Clasificadores Naive Bayes

Supongamos que tenemos un vector X de n características (features) y queremos determinar la clase de ese vector a partir de un conjunto de k clases y1, y2, ..., yk. Por ejemplo, si queremos determinar si lloverá hoy o no.

Tenemos dos clases posibles (k = 2): lluvia, no lluvia, y la longitud del vector de características podría ser 3 (n = 3).

La primera característica podría ser si está nublado o soleado, la segunda característica podría ser si la humedad es alta o baja, y la tercera característica sería si la temperatura es alta, media o baja.

Entonces, estos podrían ser posibles vectores de características.

<Nublado, H_Alta, T_Baja>
<Soleado, H_Baja, T_Media>
<Nublado, H_Baja, T_Alta>

Nuestra tarea es determinar si lloverá o no, dadas las características meteorológicas.

Después de conocer las probabilidades condicionales, parece natural abordar el problema tratando de calcular la probabilidad de que llueva dadas las características:

R = P(Llueve | Nublado, H_Alta, T_Baja)
NR = P(NoLlueve | Nublado, H_Alta, T_Baja)

Si R > NR respondemos que va a llover, de lo contrario decimos que no.

En general, si tenemos k clases y1, y2, ..., yk, y un vector de n características X = <X1, X2, ..., Xn>, queremos encontrar la clase yi que maximiza

P(yi | X1, X2, ..., Xn) = P(X1, X2,..., Xn, yi)/P(X1, X2, ..., Xn)

Observa que el denominador es constante y no depende de la clase yi. Entonces, podemos ignorarlo y enfocarnos en el numerador.

En una sección anterior, vimos cómo calcular P(X1, X2,..., Xn, yi) descomponiéndolo en un producto de probabilidades condicionales (la fórmula fea):

P(X1, X2,..., Xn, yi) = P(X1 | X2,..., Xn, yi)P(X2 | X3,..., Xn, yi)...P(Xn | yi)P(yi)

Suponiendo que todas las características Xi son independientes y usando el teorema de Bayes, podemos calcular la probabilidad condicional de la siguiente manera:

P(yi | X1, X2,..., Xn) = P(X1, X2,..., Xn | yi)P(yi)/P(X1, X2, ..., Xn)
= P(X1 | yi)P(X2 | yi)...P(Xn | yi)P(yi)/P(X1, X2, ..., Xn)

Y solo tenemos que centrarnos en el numerador.

Al encontrar la clase yi que maximiza la expresión anterior, estamos clasificando el vector de entrada. Pero, ¿cómo podemos obtener todas esas probabilidades?

Cómo calcular las probabilidades

Al resolver este tipo de problemas necesitamos tener un conjunto de ejemplos previamente clasificados.

Por ejemplo, en el problema de adivinar si lloverá o no, necesitamos tener varios ejemplos de vectores de características y sus clasificaciones que se obtendrían de pronósticos meteorológicos anteriores.

Entonces, tendríamos algo como esto:

...
<Nublado, H_Alta, T_Baja> -> Llueve
<Soleado, H_Baja, T_Media> -> No Llueve
<Nublado, H_Baja, T_Alta> -> No Llueve
...

Supongamos que necesitamos clasificar un nuevo vector <Nublado, H_Baja, T_Alta>. Necesitamos calcular:

P(Llueve | Nublado, H_Baja, T_Baja) = P(Nublado | H_Baja, T_Baja, Llueve)P(H_Baja | T_Baja, Llueve)P(T_Baja | Llueve)P(Llueve)/P(Nublado, H_Baja, T_Baja)

Obtenemos la expresión anterior aplicando la definición de probabilidad condicional y la regla de la cadena. Recuerda que solo necesitamos enfocarnos en el numerador por lo que podamos eliminar el denominador.

También necesitamos calcular la probabilidad para NoLlueve, pero podemos hacerlo de una forma similar.

Podemos encontrar P(Llueve) = # Llueve/Total. Eso significa contar las entradas en el conjunto de datos que se clasifican con Llueve y dividir ese número por el tamaño del conjunto de datos.

Para calcular P(Nublado | H_Baja, T_Baja, Llueve) necesitamos contar todas las entradas que tienen las características H_Baja, T_Baja y Nublado. Esas entradas también deben clasificarse como Llueve. Luego, ese número se divide por la cantidad total de datos. Calculamos el resto de factores de la fórmula de forma similar.

Hacer esos cálculos para todas las clases posibles es muy costoso y lento. Por tanto, necesitamos hacer suposiciones sobre el problema que simplifiquen los cálculos.

Los clasificadores Naive Bayes asumen que todas las características son independientes entre sí. Entonces podemos reescribir nuestra fórmula aplicando el teorema de Bayes y asumiendo la independencia entre cada par de características:

P(Llueve | Nublado, H_Baja, T_Baja) = P(Nublado | Llueve)P(H_Baja | Llueve)P(T_Baja | Llueve)P(Llueve)/P(Nublado, H_Baja, T_Baja)

Ahora calculamos P(Nublado | Llueve) contando el número de entradas que están clasificadas como Llueve y estaban Nublado.

El algoritmo se llama Naive (que significa ingenuo en inglés) debido a esta suposición de independencia. Hay dependencias entre las características (features) la mayor parte del tiempo. No podemos decir que en la vida real no existe una dependencia entre la humedad y la temperatura, por ejemplo. Los clasificadores Naive Bayes también se denominan Bayes Indepentientes o Bayes Simples.

La fórmula general sería:

P(yi | X1, X2, ..., Xn) = P(X1 | yi)P(X2 | yi)...P(Xn | yi)P(yi)/P(X1, X2, ..., Xn)

Recuerda que puedes deshacerte del denominador. Solo calculamos el numerador y respondemos la clase que lo maximiza.

Ahora, implementemos nuestro NBC y usémoslo en un problema.

¡Programemos!

Les mostraré una implementación de un NBC simple y luego lo veremos en la práctica.

El problema que vamos a resolver es determinar si un pasajero del Titanic sobrevivió o no, dadas algunas características como su género y su edad.

Aquí puedes ver la implementación de un NBC muy simple:

class NaiveBayesClassifier:
    
    def __init__(self, X, y):
        
        '''
        X e y denotan las características y las etiquetas de destino respectivamente
        '''
        self.X, self.y = X, y 
        
        self.N = len(self.X) # Tamaño del conjunto de entrenamiento

        self.dim = len(self.X[0]) # Dimensión del vector de características

        self.attrs = [[] for _ in range(self.dim)] # Aquí almacenaremos las columnas del conjunto de entrenamiento.

        self.output_dom = {} # Clases de salida con el número de ocurrencias en el conjunto de entrenamiento. En este caso solo tenemos 2 clases

        self.data = [] # To store every row [Xi, yi]
        
        
        for i in range(len(self.X)):
            for j in range(self.dim):
                # si nunca hemos visto este valor para este atributo antes, 
                # luego lo agregamos a la matriz attrs en la posición correspondiente
                if not self.X[i][j] in self.attrs[j]:
                    self.attrs[j].append(self.X[i][j])
                    
            # si nunca hemos visto esta clase de salida antes,
            # luego lo agregamos a output_dom y contamos una ocurrencia por ahora
            if not self.y[i] in self.output_dom.keys():
                self.output_dom[self.y[i]] = 1
            # de lo contrario, incrementamos la ocurrencia de esta salida en el conjunto de entrenamiento en 1
            else:
                self.output_dom[self.y[i]] += 1
            # almacenar la fila
            self.data.append([self.X[i], self.y[i]])
            
            

    def classify(self, entry):

        solve = None # Resultado final
        max_arg = -1 # máximo parcial

        for y in self.output_dom.keys():

            prob = self.output_dom[y]/self.N # P(y)

            for i in range(self.dim):
                cases = [x for x in self.data if x[0][i] == entry[i] and x[1] == y] # all rows with Xi = xi
                n = len(cases)
                prob *= n/self.N # P *= P(Xi = xi)
                
            # si tenemos una probabilidad mayor para esta salida que el máximo parcial ...
            if prob > max_arg:
                max_arg = prob
                solve = y

        return solve

Aquí, asumimos que cada característica tiene un dominio discreto. Eso significa que toman un valor de un conjunto finito de valores posibles.

Lo mismo ocurre con las clases. Ten en cuenta que almacenamos algunos datos en el método __init__ por lo que no es necesario repetir algunas operaciones. La clasificación de una nueva entrada se lleva a cabo en el método classify.

Este es un ejemplo simple de implementación. En las aplicaciones del mundo real, no necesitas (y es mejor si no creas) tu propia implementación. Por ejemplo, la biblioteca sklearn en Python contiene varias buenas implementaciones de NBC.

¡Observa lo fácil que es implementarlo!

Ahora, apliquemos nuestro nuevo clasificador para resolver un problema. Tenemos un conjunto de datos con la descripción de 887 pasajeros en el Titanic. También podemos ver si un pasajero determinado sobrevivió a la tragedia o no.

Entonces, nuestra tarea es determinar si otro pasajero que no está incluido en el conjunto de entrenamiento lo hizo o no.

En este ejemplo, usaré la biblioteca de pandas para leer y procesar los datos. No utilizo ninguna otra herramienta.

Los datos se almacenan en un archivo llamado titanic.csv, por lo que el primer paso es leer los datos y obtener una descripción general.

import pandas as pd

data = pd.read_csv('titanic.csv')

print(data.head())

La salida es:

Survived  Pclass                                               Name  \
0         0       3                             Mr. Owen Harris Braund   
1         1       1  Mrs. John Bradley (Florence Briggs Thayer) Cum...   
2         1       3                              Miss. Laina Heikkinen   
3         1       1        Mrs. Jacques Heath (Lily May Peel) Futrelle   
4         0       3                            Mr. William Henry Allen   

      Sex   Age  Siblings/Spouses Aboard  Parents/Children Aboard     Fare  
0    male  22.0                        1                        0   7.2500  
1  female  38.0                        1                        0  71.2833  
2  female  26.0                        0                        0   7.9250  
3  female  35.0                        1                        0  53.1000  
4    male  35.0                        0                        0   8.0500  

Observa que tenemos el nombre de cada pasajero. No usaremos esa característica para nuestro clasificador porque no es significativa para nuestro problema. También eliminaremos la característica Fare (tarifa en inglés) porque es continua y nuestras funciones deben ser discretas.

Hay clasificadores Naive Bayes que admiten caracterísitcas (features) continuas. Por ejemplo, el clasificador Naive Bayes Gausseano.

y = list(map(lambda v: 'yes' if v == 1 else 'no', data['Survived'].values)) # valores objetivo como cadena

# No usaremos el campo 'Nombre'(Name) ni 'Tarifa' (Fare)

X = data[['Pclass', 'Sex', 'Age', 'Siblings/Spouses Aboard', 'Parents/Children Aboard']].values # valores de características

Luego, necesitamos separar nuestro conjunto de datos en un conjunto de entrenamiento y un conjunto de validación. El último se utiliza para validar qué tan bien está funcionando nuestro algoritmo.

print(len(y)) # >> 887

# Tomaremos 600 ejemplos para entrenar y el resto para el proceso de validación.
y_train = y[:600]
y_val = y[600:]

X_train = X[:600]
X_val = X[600:]

Creamos nuestro NBC con el conjunto de entrenamiento y luego clasificamos cada entrada en el conjunto de validación.

Medimos la precisión de nuestro algoritmo dividiendo el número de entradas que clasificó correctamente por el número total de entradas en el conjunto de validación.

## Crear la instancia de Naive Bayes Classifier con los datos de entrenamiento

nbc = NaiveBayesClassifier(X_train, y_train)


total_cases = len(y_val) # tamaño del conjunto de validación

# Ejemplos bien clasificados y ejemplos mal clasificados
good = 0
bad = 0

for i in range(total_cases):
    predict = nbc.classify(X_val[i])
#     print(y_val[i] + ' --------------- ' + predict)
    if y_val[i] == predict:
        good += 1
    else:
        bad += 1

print('TOTAL EXAMPLES:', total_cases)
print('RIGHT:', good)
print('WRONG:', bad)
print('ACCURACY:', good/total_cases)

La salida:

TOTAL EXAMPLES: 287
RIGHT: 200
WRONG: 87
ACCURACY: 0.6968641114982579

No es genial pero es algo. Podemos obtener una mejora de aproximadamente un 10% en la precisión si eliminamos otras funciones como hermanos / cónyuges a bordo y padres / hijos a bordo.

Puedes ver un cuaderno con el código y el conjunto de datos aquí.

Conclusiones

Hoy en día, tenemos redes neuronales y otros algoritmos de ML complejos y costosos por todas partes.

Los NBC son algoritmos muy sencillos que nos permiten conseguir buenos resultados en algunos problemas de clasificación sin necesidad de muchos recursos. También escalan muy bien, lo que significa que podemos agregar muchas más funciones y el algoritmo seguirá siendo rápido y confiable.

Incluso en el caso de que los NBC no fueran adecuados para el problema que estábamos tratando de resolver, podrían ser muy útiles como referencia.

Primero podríamos intentar resolver el problema usando un NBC con unas pocas líneas de código y poco esfuerzo. Luego podríamos intentar lograr mejores resultados con algoritmos más complejos y costosos.

Este proceso puede ahorrarnos mucho tiempo y nos da una retroalimentación inmediata sobre si los algoritmos complejos realmente valen la pena para nuestra tarea.

En este artículo, leíste sobre las probabilidades condicionales, la independencia y el teorema de Bayes. Esos son los conceptos matemáticos detrás de los clasificadores Naive Bayes.

Después de eso, vimos una implementación simple de un NBC y resolvimos el problema de determinar si un pasajero del Titanic sobrevivió al accidente.

Espero que este artículo te haya resultado útil. Puedes leer sobre temas relacionados con la informática en mi blog personal y siguiéndome en Twitter.

Traducido del artículo de Jose J. Rodríguez - How Naive Bayes Classifiers Work – with Python Code Examples

En el aprendizaje supervisado, tienes datos etiquetados, por lo que tienes salidas para las que sabes con certeza cuáles son los valores correctos para sus entradas. Es como saber los precios de los automóviles en función de características como marca, modelo, estilo, transmisión y otros atributos.

Con el aprendizaje semi-supervisado, tienes un gran conjunto de datos donde algunos de los datos están etiquetados pero la mayoría no.

Esto cubre una gran cantidad de datos del mundo real porque puede resultar costoso conseguir que un experto etiquete cada uno de los datos. Puedes solucionar este problema utilizando una combinación de aprendizaje supervisado y no supervisado.

El aprendizaje no supervisado significa que tienes un conjunto de datos sin ninguna etiqueta. No sabes si hay patrones ocultos en los datos, así que dejas que el algoritmo encuentre todo lo que pueda.

Ahí es donde entran en juego los algoritmos de agrupamiento. Es uno de los métodos que puedes utilizar en un problema de aprendizaje no supervisado.

¿Qué son los algoritmos de agrupamiento?

El agrupamiento es una tarea de aprendizaje automático no supervisada. Es posible que también lo hayas escuchado como análisis de agrupación debido a la forma en que funciona este método.

El uso de un algoritmo de agrupamiento significa que le darás al algoritmo una gran cantidad de datos de entrada sin etiquetas y te permitirá encontrar cualquier agrupación en los datos que se pueda.

Esas agrupaciones se denominan agrupaciones. Una agrupación es un grupo de datos que son similares entre sí en función de su relación con los datos circundantes. El agrupamiento se utiliza para cosas tales como la ingeniería de características o el descubrimiento de patrones.

Cuando empiezas con datos de los que no sabes nada, el agrupamiento puede ser un buen punto de partida para obtener información.

Tipos de algoritmos de agrupamiento

Existen diferentes tipos de algoritmos de agrupamiento que manejan todo tipo de datos únicos.

Basado en densidad

En el agrupamiento basado en densidad, los datos se agrupan por áreas de altas concentraciones de puntos de datos rodeadas por áreas de bajas concentraciones de puntos de datos. Básicamente, el algoritmo encuentra los lugares que son densos en puntos de datos y los llama grupos.

Lo bueno de esto es que los grupos pueden tener cualquier forma. No estás limitado a condiciones esperadas.

Los algoritmos de agrupamiento de este tipo no tienen en cuenta los valores atípicos en los grupos, por lo que se ignoran.

Basado en la distribución

Con un enfoque de agrupamiento basado en la distribución, se considera que todos los puntos de datos forman parte de un grupo según la probabilidad de que un punto pertenezca a un grupo determinado.‌‌

Funciona así: hay un punto central y, a medida que aumenta la distancia de un punto de datos desde el centro, la probabilidad de que forme parte de ese grupo disminuye.

‌‌Si no estás seguro de cuál podría ser la distribución de tus datos, deberías considerar un tipo diferente de algoritmo.

Basado en Centroides

El agrupamiento basado en centroides es la que probablemente has escuchado más. Es algo sensible a los parámetros iniciales que le das, pero es rápida y eficiente.

Estos tipos de algoritmos separan puntos de datos en función de múltiples centroides en los datos. Cada punto de datos se asigna a un grupo en función de su distancia al cuadrado del centroide. Este es el tipo de agrupación más utilizado.

Basado en Jerarquías

El agrupamiento basado en jerarquías se utiliza normalmente en datos jerárquicos, como los que obtendrías de la base de datos de una empresa o de taxonomías. Construye un árbol de grupos para que todo esté organizado de arriba hacia abajo.

Esto es más restrictivo que los otros tipos de agrupamiento, pero es perfecto para tipos específicos de conjuntos de datos.

Cuando usar agrupamiento

Cuando tienes un conjunto de datos sin etiquetar, es muy probable que utilices algún tipo de algoritmo de aprendizaje sin supervisión.

Hay muchas técnicas diferentes de aprendizaje no supervisado, como redes neuronales, aprendizaje por refuerzo y agrupamiento. El tipo específico de algoritmo que quieres utilizar dependerá de cómo se vean tus datos.

Es posible que quieras utilizar agrupamiento cuando intentas detectar anomalías para encontrar valores atípicos en tus datos. El agrupamiento ayuda a encontrar esos grupos y muestra los límites que determinarían si un punto de datos es un valor atípico o no.

Si no estás seguro de qué características usar para tu modelo de aprendizaje automático, el agrupamiento descubre patrones que puedes usar para descubrir qué se destaca en los datos.

El agrupamiento es especialmente útil para explorar datos de los que no sabes nada. Puede llevar algún tiempo averiguar qué tipo de algoritmo de agrupamiento funciona mejor, pero cuando lo hagas, obtendrás información invaluable sobre tus datos. Es posible que encuentres conexiones en las que nunca hubieras pensado.

Algunas aplicaciones del mundo real del agrupamiento incluyen la detección de fraudes en seguros, la categorización de libros en una biblioteca y la segmentación de clientes en mercadeo. También se puede utilizar en problemas más grandes, como análisis de terremotos o planificación urbana.

Los Ocho Mejores Algoritmos de Agrupamiento

Ahora que tienes algunos antecedentes sobre cómo funcionan los algoritmos de agrupamiento y los diferentes tipos disponibles, podemos hablar sobre los algoritmos que verás comúnmente en la práctica.

Implementaremos estos algoritmos en un conjunto de datos de ejemplo de la biblioteca sklearn en Python.

Usaremos el conjunto de datos make_classification de la biblioteca sklearn para demostrar cómo los diferentes algoritmos de agrupamiento no son adecuados para todos los problemas de agrupamiento.

Puedes encontrar el código para todos los siguientes ejemplos aquí.

Algoritmo de agrupamiento K-means

El agrupamiento de K-means es el algoritmo de agrupamiento más utilizado. Es un algoritmo basado en centroides y es el algoritmo de aprendizaje no supervisado más simple.

Este algoritmo intenta minimizar la varianza de los puntos de datos dentro de un grupo. También es la forma en que la mayoría de las personas se familiarizan con el aprendizaje automático sin supervisión.

K-means se usa mejor en conjuntos de datos más pequeños porque itera sobre todos los puntos de datos. Eso significa que tomará más tiempo clasificar los puntos de datos si hay una gran cantidad de ellos en el conjunto de datos.

Dado que así es como k-means agrupa los puntos de datos, no se escala bien.

Implementación:

from numpy import unique
from numpy import where
from matplotlib import pyplot
from sklearn.datasets import make_classification
from sklearn.cluster import KMeans

# inicializar el conjunto de datos con el que trabajaremos
training_data, _ = make_classification(
    n_samples=1000,
    n_features=2,
    n_informative=2,
    n_redundant=0,
    n_clusters_per_class=1,
    random_state=4
)

# definir el modelo
kmeans_model = KMeans(n_clusters=2)

# Entrenar el modelo
kmeans_model.fit(training_data)

# asignar cada punto de datos a un grupo
kmeans_result = kmeans_model.predict(training_data)

# obtener todos los grupos únicos
kmeans_clusters = unique(kmeans_result)

# graficar los grupos KMeans
for kmeans_cluster in kmeans_clusters:
    # get data points that fall in this cluster
    index = where(kmeans_result == kmeans_cluster)
    # make the plot
    pyplot.scatter(training_data[index, 0], training_data[index, 1])
    print(index)

# mostrar el gráfico K-means
pyplot.show()

Algoritmo de agrupamiento DBSCAN

DBSCAN significa agrupamiento espacial basado en densidad de aplicaciones con ruido. Es un algoritmo de agrupamiento basado en densidad, a diferencia de k-means.

Este es un buen algoritmo para encontrar esquemas en un conjunto de datos. Encuentra grupos de forma arbitraria en función de la densidad de puntos de datos en diferentes regiones. Separa las regiones por áreas de baja densidad para poder detectar valores atípicos entre los grupos de alta densidad.

Este algoritmo es mejor que el k-means cuando se trata de trabajar con datos que tienen formas extrañas.

DBSCAN utiliza dos parámetros para determinar cómo se definen los grupos: minPts (el número mínimo de puntos de datos que deben agruparse para que un área se considere de alta densidad) y eps (la distancia utilizada para determinar si un punto de datos está en la misma área que otros puntos de datos).

La elección de los parámetros iniciales adecuados es fundamental para que este algoritmo funcione.

Implementación:

from numpy import unique
from numpy import where
from matplotlib import pyplot
from sklearn.datasets import make_classification
from sklearn.cluster import DBSCAN

# inicializar el conjunto de datos con el que trabajaremos
training_data, _ = make_classification(
    n_samples=1000,
    n_features=2,
    n_informative=2,
    n_redundant=0,
    n_clusters_per_class=1,
    random_state=4
)

# definir el modelo
dbscan_model = DBSCAN(eps=0.25, min_samples=9)

# entrenar el modelo
dbscan_model.fit(training_data)

# asignar cada punto de datos a un grupo
dbscan_result = dbscan_model.fit_predict(training_data)

# obtener todos los grupos únicos
dbscan_clusters = unique(dbscan_result)

# graficar el DBSCAN de grupos
for dbscan_cluster in dbscan_clusters:
    # obtener todos los puntos de datos que caen en este grupo
    index = where(dbscan_result == dbscan_cluster)
    # hacer el gráfico
    pyplot.scatter(training_data[index, 0], training_data[index, 1])

# mostrar el gráfico DBSCAN
pyplot.show()

Algoritmo de Mezcla Gaussiana

Uno de los problemas con k-means es que los datos deben seguir un formato circular. La forma en que k-means calcula la distancia entre puntos de datos tiene que ver con una ruta circular, por lo que los datos no circulares no se agrupan correctamente.

Este es un problema que corrigen los modelos de mezcla Gaussianos. No necesitas datos con forma circular para que funcione bien.

El modelo de mezcla Gaussiana utiliza múltiples distribuciones Gaussianas para ajustar datos que tienen formas arbitrarias.

Hay varios modelos Gaussianos únicos que actúan como capas ocultas en este modelo híbrido. Entonces, el modelo calcula la probabilidad de que un punto de datos pertenezca a una distribución Gaussiana específica y ese es el grupo en el que se ubicará.

Implementación:

from numpy import unique
from numpy import where
from matplotlib import pyplot
from sklearn.datasets import make_classification
from sklearn.mixture import GaussianMixture

# inicializar el conjunto de datos con el que trabajaremos
training_data, _ = make_classification(
    n_samples=1000,
    n_features=2,
    n_informative=2,
    n_redundant=0,
    n_clusters_per_class=1,
    random_state=4
)

# definir el modelo
gaussian_model = GaussianMixture(n_components=2)

# entrenar el modelo
gaussian_model.fit(training_data)

# asignar cada punto de datos a un grupo
gaussian_result = gaussian_model.predict(training_data)

# obtener todos los grupos únicos
gaussian_clusters = unique(gaussian_result)

# graficar los grupos de Mezcla Gaussiana
for gaussian_cluster in gaussian_clusters:
    # obtener todos los puntos de datos que caen en este grupo
    index = where(gaussian_result == gaussian_cluster)
    # hacer el gráfico
    pyplot.scatter(training_data[index, 0], training_data[index, 1])

# mostrar el gráfico de Mezcla Gaussiana
pyplot.show()

Algoritmo BIRCH

El algoritmo de Equilibrio Iterativo de Reducción y Agrupación mediante Jerarquías o Balance Iterative Reducing and Clustering using Hierarchies (BIRCH) por sus siglas en inglés, funciona mejor en  grandes conjuntos de datos que el algoritmo k-means.

Divide los datos en pequeños resúmenes que se agrupan en lugar de los puntos de datos originales. Los resúmenes contienen tanta información sobre la distribución de los puntos de datos como sea posible.

Este algoritmo se usa comúnmente con otros algoritmos de agrupamiento porque las otras técnicas de agrupamiento se pueden usar en los resúmenes generados por BIRCH.

La principal desventaja del algoritmo BIRCH es que solo funciona con datos numéricos. No puedes usar BIRCH para valores categóricos a menos que realices algunas transformaciones de datos.

Implementación:

from numpy import unique
from numpy import where
from matplotlib import pyplot
from sklearn.datasets import make_classification
from sklearn.cluster import Birch

# inicializar el conjunto de datos con el que trabajaremos
training_data, _ = make_classification(
    n_samples=1000,
    n_features=2,
    n_informative=2,
    n_redundant=0,
    n_clusters_per_class=1,
    random_state=4
)

# defnir el modelo
birch_model = Birch(threshold=0.03, n_clusters=2)

# entrenar el modelo
birch_model.fit(training_data)

# asignar cada punto de datos a un grupo
birch_result = birch_model.predict(training_data)

# obtener todos los grupos únicos
birch_clusters = unique(birch_result)

# graficar los grupos BIRCH
for birch_cluster in birch_clusters:
    # obtener todos los puntos de datos que caen en este grupo
    index = where(birch_result == birch_cluster)
    # hacer el gráfico
    pyplot.scatter(training_data[index, 0], training_data[index, 1])

# mostrar el gráfico BIRCH
pyplot.show()

Algoritmo de agrupamiento por Propagación de Afinidad

Este algoritmo de agrupamiento es completamente diferente de los demás en la forma en que agrupa los datos.

Cada punto de datos se comunica con todos los demás puntos de datos para que los demás sepan qué tan similares son y eso comienza a revelar los grupos en los datos. No tienes que decirle a este algoritmo cuántos grupos esperar en los parámetros de inicialización.

A medida que se envían mensajes entre puntos de datos, se encuentran conjuntos de datos llamados ejemplares que representan los grupos.

Se encuentra un ejemplar después de que los puntos de datos se hayan transmitido mensajes entre sí y formen un consenso sobre qué punto de datos representa mejor un grupo.

Cuando no estás seguro de cuántos grupos esperar, como en un problema de visión por computadora, este es un gran algoritmo para comenzar.

Implementación:‌

from numpy import unique
from numpy import where
from matplotlib import pyplot
from sklearn.datasets import make_classification
from sklearn.cluster import AffinityPropagation

# inicializar el conjunto de datos con el que trabajaremos
training_data, _ = make_classification(
    n_samples=1000,
    n_features=2,
    n_informative=2,
    n_redundant=0,
    n_clusters_per_class=1,
    random_state=4
)

# definir el modelo
affinity_model = AffinityPropagation(damping=0.7)

# entrenar el modelo
affinity_model.fit(training_data)

# asignar cada punto de datos a un grupo
affinity_result = affinity_model.predict(training_data)

# obtener todos los grupos únicos
affinity_clusters = unique(affinity_result)

# graficar los grupos
for affinity_cluster in affinity_clusters:
    # obtener todos los puntos de datos que caen en este grupo
    index = where(affinity_result == affinity_cluster)
    # hacer el gráfico
    pyplot.scatter(training_data[index, 0], training_data[index, 1])

# mostrar el gráfico
pyplot.show()

Algoritmo de agrupamiento de Desplazamiento Medio

Este es otro algoritmo que es particularmente útil para manejar imágenes y procesamiento de visión por computadora.

El desplazamiento medio es similar al algoritmo BIRCH porque también encuentra grupos sin que se establezca un número inicial de grupos.

Este es un algoritmo de agrupamiento jerárquico, pero la desventaja es que no escala bien cuando se trabaja con grandes conjuntos de datos.

Funciona iterando sobre todos los puntos de datos y los desplaza hacia la moda. La moda en este contexto es el área de alta densidad de puntos de datos en una región.

Es por eso que es posible que escuches que se hace referencia a este algoritmo como el algoritmo de búsqueda de moda. Cada punto de datos pasará por este proceso iterativo y los moverá más cerca de donde están otros puntos de datos hasta que todos los puntos de datos hayan sido asignados a un grupo.

Implementation:

from numpy import unique
from numpy import where
from matplotlib import pyplot
from sklearn.datasets import make_classification
from sklearn.cluster import MeanShift

# inicializar el conjunto de datos con el que trabajaremos
training_data, _ = make_classification(
    n_samples=1000,
    n_features=2,
    n_informative=2,
    n_redundant=0,
    n_clusters_per_class=1,
    random_state=4
)

# definir el modelo
mean_model = MeanShift()

# asignar cada punto de datos a un grupo
mean_result = mean_model.fit_predict(training_data)

# obtener todos los grupos únicos
mean_clusters = unique(mean_result)

# graficar los grupos de Deszplazamiento Medio
for mean_cluster in mean_clusters:
    # obtener todos los puntos de datos que caen en este grupo
    index = where(mean_result == mean_cluster)
    # hacer el gráfico
    pyplot.scatter(training_data[index, 0], training_data[index, 1])

# mostrar el gráfico de Deszplazamiento Medio
pyplot.show()

Algoritmo OPTICS

OPTICS significa Ordenar Puntos para Identificar la Estructura de Agrupamiento ú Ordering Points to Identify the Clustering Structure por sus siglas en inglés. Es un algoritmo basado en densidad similar a DBSCAN, pero es mejor porque puede encontrar agrupaciones significativas en datos que varían en densidad. Lo hace ordenando los puntos de datos de modo que los puntos más cercanos sean vecinos en el ordenamiento.

Esto facilita la detección de diferentes grupos de densidad. El algoritmo OPTICS solo procesa cada punto de datos una vez, similar a DBSCAN (aunque se ejecuta más lento que DBSCAN). También hay una distancia especial almacenada para cada punto de datos que indica que un punto pertenece a un grupo específico.

Implementación:

from numpy import unique
from numpy import where
from matplotlib import pyplot
from sklearn.datasets import make_classification
from sklearn.cluster import OPTICS

# inicializar el conjunto de datos con el que trabajaremos
training_data, _ = make_classification(
    n_samples=1000,
    n_features=2,
    n_informative=2,
    n_redundant=0,
    n_clusters_per_class=1,
    random_state=4
)

# definir el modelo
optics_model = OPTICS(eps=0.75, min_samples=10)

# asignar cada punto de datos a un grupo
optics_result = optics_model.fit_predict(training_data)

# obtener todos los grupos únicos
optics_clusters = unique(optics_result)

# graficar los grupos OPTICS
for optics_cluster in optics_clusters:
    # obtener todos los puntos de datos que caen en este grupo
    index = where(optics_result == optics_cluster)
    # hacer el gráfico
    pyplot.scatter(training_data[index, 0], training_data[index, 1])

# mostrar el gráfico OPTICS
pyplot.show()

Algoritmo de agrupamiento de Jerarquía Aglomerativa

Este es el tipo más común de algoritmo de agrupamiento jerárquico. Se utiliza para agrupar objetos en grupos en función de su similitud entre sí.

Esta es una forma de agrupamiento de abajo hacia arriba, donde cada punto de datos se asigna a su propio grupo. Luego, esos grupos se unen.

En cada iteración, los grupos similares se fusionan hasta que todos los puntos de datos forman parte de un gran grupo raíz.

La agrupación aglomerativa es mejor para encontrar agrupaciones pequeñas. El resultado final parece un dendrograma para que puedas visualizar fácilmente los grupos cuando el algoritmo termina.

Implementación:

from numpy import unique
from numpy import where
from matplotlib import pyplot
from sklearn.datasets import make_classification
from sklearn.cluster import AgglomerativeClustering

# inicializar el conjunto de datos con el que trabajaremos
training_data, _ = make_classification(
    n_samples=1000,
    n_features=2,
    n_informative=2,
    n_redundant=0,
    n_clusters_per_class=1,
    random_state=4
)

# definir el modelo
agglomerative_model = AgglomerativeClustering(n_clusters=2)

# asignar cada punto de datos a un grupo
agglomerative_result = agglomerative_model.fit_predict(training_data)

# obtener todos los grupos únicos
agglomerative_clusters = unique(agglomerative_result)

# graficar los grupos
for agglomerative_cluster in agglomerative_clusters:
    # obtener todos los puntos de datos que caen en este grupo
    index = where(agglomerative_result == agglomerative_cluster)
    # hacer el gráfico
    pyplot.scatter(training_data[index, 0], training_data[index, 1])

# mostrar el gráfico de Jerarquía Aglomerativa
pyplot.show()

Otros tipos de algoritmos de agrupamiento

Hemos cubierto ocho de los principales algoritmos de agrupamiento, pero hay muchos más disponibles. Hay algunos algoritmos de agrupamiento ajustados de manera muy específica que manejan tus datos de manera rápida y precisa. Estos son algunos de los otros que podrían ser de tu interés.

Hay otro algoritmo jerárquico que es lo opuesto al enfoque aglomerativo. Comienza con una estrategia de agrupación de arriba hacia abajo. Por lo tanto, comenzará con un gran grupo raíz y dividirá los grupos individuales a partir de ahí.

Esto se conoce como algoritmo de agrupamiento Jerárquico Divisivo. Hay investigaciones que muestran que esto crea jerarquías más precisas que el agrupamiento aglomerativo, pero es mucho más complejo.

El K-means en Mini Lotes es similar a K-means, excepto que utiliza pequeños fragmentos aleatorios de datos de un tamaño fijo para que puedan almacenarse en la memoria. Esto lo ayuda a ejecutarse más rápido que el K-means para que converja en una solución en menos tiempo.

El inconveniente de este algoritmo es que el aumento de velocidad le costará algo de calidad a los grupos.

El último algoritmo que cubriremos brevemente es el Agrupamiento Espectral. Este algoritmo es completamente diferente a los otros que hemos visto.

Funciona aprovechando la teoría de grafos. Este algoritmo no hace ninguna conjetura inicial sobre los grupos que se encuentran en el conjunto de datos. Trata los puntos de datos como nodos en un gráfico y los grupos se encuentran a base de comunidades de nodos que se conectan por los bordes.

Otros pensamientos

Ten cuidado con los problemas de escalado con los algoritmos de agrupamiento. Tu conjunto de datos podría tener millones de puntos de datos y, dado que los algoritmos de agrupamiento funcionan calculando las similitudes entre todos los pares de puntos de datos, es posible que termines con un algoritmo que no se escala bien.

Conclusión

Los algoritmos de agrupamiento son una excelente manera de aprender cosas nuevas a partir de datos antiguos. A veces te sorprenderán los grupos resultantes que obtendrás y podrían ayudarte a entender un problema.

Una de las cosas más interesantes de utilizar el agrupamiento para el aprendizaje no supervisado es que puedes utilizar los resultados en un problema de aprendizaje supervisado.

¡Los grupos podrían ser tus nuevas características que uses en un conjunto de datos completamente diferente! Puedes utilizar el agrupamiento en casi cualquier problema de aprendizaje automático sin supervisión, pero asegúrate de saber cómo analizar los resultados para garantizar la precisión.

Traducido del artículo de Milecia McGregor - 8 Clustering Algorithms in Machine Learning that All Data Scientists Should Know

El algoritmo sutil, pero poderoso que optimiza parámetros

La optimización de parámetros es el objetivo final de todo algoritmo de aprendizaje automático. Quieres obtener el valor óptimo de la pendiente y el intercepto para encontrar la línea que mejor se ajuste en los problemas de regresión lineal. También quieres obtener el valor óptimo para los parámetros de una curva sigmoidea en problemas de regresión logística. ¿Y si te dijera que el Descenso de Gradiente lo hace todo?

Traducido del artículo de Nishit Jain - An overview of the Gradient Descent algorithm

Introducción a NumPy

NumPy  es una biblioteca de Python utilizada para realizar cálculos numéricos con grandes conjuntos de datos. El nombre significa numérico y es una biblioteca popular utilizada por los científicos de datos, especialmente para problemas de aprendizaje automático.

NumPy  es útil al preprocesar los datos antes de entrenarlos utilizando un algoritmo de aprendizaje automático.

Trabajar con arreglos n-dimensionales es más fácil en Numpy en comparacion con las listas de Python. Los arreglos Numpy son también más rápidos que las listas de Python, ya que, a diferencia de, los arreglos de Numpy se almacenan en un lugar continuo en la memoria. Esto permite que el procesador realice cálculos de manera eficiente

En este artículo, Veremos los conceptos básicos para trabajar con NumPy incluyendo operaciones con arreglos, transformación de matrices, generación de valores aleatorios, etcétera.

Instalación

Se proporcionan instrucciones claras de instalación en el sitio web oficial de Numpy, Así que  no las repetiré en este artículo. Encuentra las instrucciones aquí.

Trabajando con Numpy

Importando NumPy

Para comenzar a usar Numpy en su script, tienes que importarlo.

import numpy as np

Convirtiendo arreglos en arreglos NumPy

Puedes convertir tus listas de Python existentes en arreglos Numpy usando el método  np.array(), así:

arreglo = [1,2,3]
np.array(arreglo)

Esto también aplica para arreglos multi-dimensionales. NumPy realizará un seguimiento de la forma (dimensiones) del arreglo .

arreglo_anidado = [[1,2],[3,4],[5,6]]
np.array(arreglo_anidado)

Función NumPy arrange

Al trabajar con datos, a menudo te encontrarás con casos de uso donde necesites generar datos.

NumPy tiene un método  “arrange()” con el que puedes generar un rango de valores entre 2 números. La función arrange toma el inicio, el final y un parámetro de distancia opcional.

print(np.arrange(0,10)) # Sin parametro de distancia
OUTPUT:[0 1 2 3 4 5 6 7 8 9]

print(np.arrange(0,10,2)) # con parametro de distancia
OUTPUT: [0 2 4 6 8]

Ceros y unos

Tú también puedes generar un arreglo o matriz de ceros y unos usando Numpy (créeme, lo necesitarás). Así es como funciona.

print(np.zeros(3))
OUTPUT: [0. 0. 0.]

print(np.ones(3))
OUTPUT: [1. 1. 1.]

Ambas  funciones también admiten n-dimensionales. Puedes agregar la forma como una tupla con filas y columnas.

print(np.zeros((4,5)))
OUTPUT:
[
 [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.]
]

print(np.ones((4,5)))
OUTPUT:
[
 [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.]
]

Matriz de identidad

También puedes generar una matriz de identidad usando una función incorporada en Numpy llamada “eye”.

np.eye(5)
OUTPUT:
[[1., 0., 0., 0., 0.]
[0., 1., 0., 0., 0.]
[0., 0., 1., 0., 0.]
[0., 0., 0., 1., 0.]
[0., 0., 0., 0., 1.]]

Función NumPy linspace

NumPy tiene el método linspace que genera puntos uniformemente espaciados entre dos números.

print(np.linspace(0,10,3))
OUTPUT:[ 0.  5. 10.]

En el ejemplo de arriba, el primer y segundo parámetro son los puntos inicial y final, mientras que el tercer parámetro es el número de puntos que necesitas entre el inicio y el final.

Aquí está el mismo rango con 20 puntos.

print(np.linspace(0,10,20))
OUTPUT:[ 0. 0.52631579  1.05263158  1.57894737  2.10526316  2.63157895   3.15789474  3.68421053  4.21052632  4.73684211  5.26315789  5.78947368   6.31578947  6.84210526  7.36842105  7.89473684  8.42105263  8.94736842   9.47368421 10.]

Generación de Números Aleatorios

Cuando trabajes en problemas de aprendizaje automático, a menudo necesitarás generar números aleatorios. NumPy también tiene funciones integradas para eso.

Pero antes de comenzar a generar números aleatorios, veamos dos tipos principales de distribuciones.

Distribución Normal

En una  distribución normal estándar, los valores alcanzan su punto máximo.

La distribución normal es un concepto muy importante en estadística, ya que se ve en muchos fenómenos naturales. También se le llama "curva de campana".

Distribución Uniforme

Si los valores de la distribución tienen la probabilidad como una constante, se llama distribución uniforme.

Por ejemplo, el lanzamiento de una moneda tiene una distribución uniforme, ya que la probabilidad de obtener cara o cruz en un lanzamiento de moneda es la misma.

Ahora que sabes cómo funcionan las dos distribuciones principales, generemos algunos números aleatorios.

• Para generar números aleatorios en una distribución uniforme, usa la función rand () de np.random:

print(np.random.rand(10)) # arreglo
OUTPUT: [0.46015141 0.89326339 0.22589334 0.29874476 0.5664353  0.39257603  0.77672998 0.35768031 0.95087408 0.34418542]

print(np.random.rand(3,4)) # matriz 3x4
OUTPUT:[[0.63775985 0.91746663 0.41667645 0.28272243]  [0.14919547 0.72895922 0.87147748 0.94037953]  [0.5545835  0.30870297 0.49341904 0.27852723]]

• Para generar números aleatorios en una distribución normal, use la función randn () np.random:

print(np.random.randn(10))
OUTPUT:[-1.02087155 -0.75207769 -0.22696798  0.86739858  0.07367362 -0.41932541   0.86303979  0.13739312  0.13214285  1.23089936]

print(np.random.randn(3,4))
OUTPUT: [[ 1.61013773  1.37400445  0.55494053  0.23133522]  [ 0.31290971 -0.30866402  0.33093618  0.34868954]  [-0.11659865 -1.22311073  0.36676476  0.40819545]]

• Para generar enteros aleatorios entre un valor inferior y superior, use la función randint () de np.random:

print(np.random.randint(1,100,10))
OUTPUT:[64 37 62 27  4 33 23 52 70  7]

print(np.random.randint(1,100,(2,3)))
OUTPUT:[[92 42 38]  [87 69 38]]

Se utiliza un valor inicial (semilla) si desea que sus números aleatorios sean los mismos durante cada cálculo. Así es como se establece un valor inicial en NumPy.

• Para establecer un valor inicial en NumPy, haz lo siguiente:

np.random.seed(42)
print(np.random.rand(4))
OUTPUT:[0.37454012, 0.95071431, 0.73199394, 0.59865848]

Siempre que uses un número de semilla, siempre obtendrás el mismo arreglo generado sin ningún cambio.

Remodelación de Arreglos

Como científico de datos, trabajarás para reorganizar los conjuntos de datos para diferentes tipos de cálculos. En esta sección, veremos cómo trabajar con las formas de arreglos.

• Para obtener la forma de un arreglo, use la propiedad de shape

arreglo = np.random.rand(2,2)
print(arreglo)
print(arreglo.shape)
OUTPUT:[
[0.19890857 0.00806693]
[0.48199837 0.55373954]
]
(2, 2)

• Para reorganizar un arreglo, use la función  reshape().

print(arreglo.reshape(1,4))
OUTPUT: [[0.19890857 0.00806693 0.48199837 0.55373954]]
print(arreglo.reshape(4,1))
OUTPUT:[
[0.19890857]
[0.00806693]
[0.48199837]
[0.55373954]
]

Para reorganizar permanentemente un arreglo, debe asignar el arreglo reorganizado a la variable "arreglo"

Además, la reorganización solo funciona si la estructura existente tiene sentido. No puede reorganizar una matriz de 2x2 en una matriz de 3x1.

Datos de Corte

Veamos como obtener datos de arreglos. Los arreglos Numpy trabajan de manera similar a las listas en Python durante las oraciones de recuperación de datos.  

• Para cortar un arreglo, haz esto:

miarreglo = np.arange(0,11)
print(miarreglo)
OUTPUT:[ 0  1  2  3  4  5  6  7  8  9 10]

cortado = miarreglo[0:5]
print(cortado)
OUTPUT: [0 1 2 3 4]

cortado[:] = 99
print(cortado)
OUTPUT: [99 99 99 99 99]

print(miarreglo)
OUTPUT:[99 99 99 99 99  5  6  7  8  9 10]

Si observas el ejemplo anterior, aunque asignamos el segmento de "miarreglo" a la variable "cortado", el cambio del valor de "cortado" afecta al arreglo original. Esto se debe a que el "la parte cortada" solo apuntaba al arreglo original.

Para hacer una sección independiente de una arreglo, use la función copy ().

 cortado = miarreglo.copy()[0:5]

• Cortar arreglos multidimensionales funciona de manera similar a los arreglos unidimensionales

mi_arreglo = np.random.randint(1,30,(3,3))
print(mi_arreglo)
OUTPUT: [
[21  1 20]
[22 16 27]
[24 14 22]
]

print(mi_arreglo[0]) # imprime una sola fila
OUTPUT: [21  1 20]

print(mi_arreglo[0][0]) # imprime un solo valor o fila 0, columna 0
OUTPUT: 21

print(mi_arreglo[0,0]) #forma alternativa de imprimir valor de la  fila0,colu0
OUTPUT: 21

Cálculos con Arreglos

Ahora veamos los cálculos con arreglos. NumPy es conocido por su velocidad al realizar cálculos complejos en grandes arreglos multidimensionales

Intentemos con algunas operaciones básicas.

nuevo_arreglo = np.arange(1,11)
print(nuevo_arreglo)
OUTPUT: [ 1  2  3  4  5  6  7  8  9 10]

• Suma

print(nuevo_arreglo + 5)
OUTPUT: [ 6  7  8  9 10 11 12 13 14 15]

• Resta

print(nuevo_arreglo - 5)
OUTPUT: [-4 -3 -2 -1  0  1  2  3  4  5]

• Suma de Arreglos

print(nuevo_arreglo + nuevo_arreglo)
OUTPUT: [ 2  4  6  8 10 12 14 16 18 20]

• División de Arreglos

print(nuevo_arreglo / nuevo_arreglo)
OUTPUT:[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

Para errores por dividir en cero, Numpy convertirá el valor a NaN (no es un número).

También hay algunos métodos de cálculo integrados disponibles en NumPy para calcular valores como la media, la desviación estándar, la varianza y otros.

• Suma — np.sum()
• Raíz cuadrada — np.sqrt()
• Media — np.mean()
• Varianza — np.var()
• Desviación estándar — np.std()

Mientras trabajas con arreglos 2d, a menudo necesitarás calcular la suma, la media, la varianza, etc., por filas o columnas. Puedes utilizar el parámetro de eje opcional para especificar si desea elegir una fila o una columna.

arreglo2d = np.arange(25).reshape(5,5)
print(arreglo2d)
OUTPUT: [
[ 0  1  2  3  4]
[ 5  6  7  8  9]
[10 11 12 13 14]
[15 16 17 18 19]
[20 21 22 23 24]
]

print(arreglo2d.sum())
OUTPUT: 300

print(arreglo2d.sum(axis=0))  # suma de columnas
OUTPUT: [50 55 60 65 70]

print(arreglo2d.sum(axis=1)) #suma de filas
OUTPUT: [ 10  35  60  85 110]

Operaciones condicionales

También puedes hacer un filtrado condicional con NumPy usando la notación de corchetes. Aquí hay un ejemplo:

arr = np.arange(0,10)
OUTPUT: [0,2,3,4,5,6,7,8,9]

print(arr > 4)
OUTPUT: [False False False False False  True  True  True  True  True]

print(arr[arr > 4])
OUTPUT: [5 6 7 8 9]

Resumen

Cuando se trata de trabajar con grandes conjuntos de datos, NumPy es una herramienta poderosa para tener en su kit de herramientas. Es capaz de manejar cálculos numéricos avanzados y operaciones complejas de arreglos de n dimensiones.

Te recomiendo que aprendas NumPy si planeas comenzar una carrera en el aprendizaje automático.

Aquí hay un cuaderno de colab de google si deseas probar estos ejemplos.

Consigue un resumen de mis artículos  y vídeos enviados a tu correo electrónico todos los lunes por la mañana. También puedes Conectarte conmigo aquí.

Traducido del artículo de Manish Shivanandhan - Python NumPy Crash Course – How to Build N-Dimensional Arrays for Machine Learning

PNL maneja cosas como respuestas de texto, descifrar el significado de las palabras dentro de un contexto y mantener conversaciones con nosotros. Ayuda a las computadoras a comprender el lenguaje humano para que podamos comunicarnos de diferentes maneras.

Desde los bots de chat hasta las solicitudes de empleo y la clasificación de tu correo electrónico en diferentes carpetas, PNL se utiliza en todas partes a nuestro alrededor.

En esencia, el procesamiento del lenguaje natural es una combinación de informática y lingüística. La lingüística nos brinda las reglas que debemos usar para entrenar nuestros modelos de aprendizaje automático y obtener los resultados que buscamos.

Hay muchas razones por las que el procesamiento del lenguaje natural se ha convertido en una parte importante del aprendizaje automático. Ayuda a las máquinas a detectar el sentimiento de los comentarios de un cliente, puede ayudar a clasificar los tickets de soporte para cualquier proyecto en el que estés trabajando y puede leer y comprender el texto de manera coherente.

Y dado que opera con un conjunto de reglas lingüísticas, no tiene los mismos prejuicios que los humanos.

Dado que PNL es un área de estudio tan grande, hay una serie de herramientas que puedes utilizar para analizar datos para tus propósitos específicos.

Existe el enfoque basado en reglas en el que se configuran muchas declaraciones si-entonces (if-then) para manejar cómo se interpreta el texto. Por lo general, un lingüista será responsable de esta tarea y lo que producen es muy fácil de entender para la gente.

Esto puede ser bueno para empezar, pero se vuelve muy complejo a medida que comienzas a trabajar con grandes conjuntos de datos.

Otro enfoque es utilizar aprendizaje automático donde no es necesario definir reglas. Esto es excelente cuando intentas analizar grandes cantidades de datos de forma rápida y precisa.

Elegir el algoritmo correcto para que el enfoque de aprendizaje automático funcione es importante en términos de eficiencia y precisión. Existen algoritmos comunes como Naïve Bayes y Support Vector Machines. Luego están los algoritmos más específicos como Google BERT

¿Qué es BERT?

BERT es una biblioteca de código abierto creada en 2018 en Google. Es una técnica nueva para PNL y adopta un enfoque de modelos de entrenamiento completamente diferente al de cualquier otra técnica.

BERT es un acrónimo de Representaciones de codificador bidireccional de Transformer. Eso significa que, a diferencia de la mayoría de las técnicas que analizan oraciones de izquierda a derecha o de derecha a izquierda, BERT va en ambas direcciones usando el codificador Transformer. Su objetivo es generar un modelo de lenguaje.

Esto le da una precisión y un rendimiento increíbles en conjuntos de datos más pequeños, lo que resuelve un gran problema en el procesamiento del lenguaje natural.

Si bien hay una gran cantidad de datos basados en texto disponibles, muy pocos de ellos se han etiquetado para usar en el entrenamiento de un modelo de aprendizaje automático. Dado que la mayoría de los enfoques para los problemas de PNL aprovechan el aprendizaje profundo (deep learning), necesita grandes cantidades de datos para entrenar.

Realmente se ven las grandes mejoras en un modelo cuando se ha entrenado con millones de datos. Para ayudar a solucionar este problema de no tener suficientes datos etiquetados, los investigadores encontraron formas de entrenar modelos de representación de lenguaje de propósito general a través del entrenamiento previo usando textos de Internet.

Estos modelos de representación previamente entrenados se pueden ajustar para que funcionen con conjuntos de datos específicos que son más pequeños que los que se usan comúnmente en el aprendizaje profundo. Estos conjuntos de datos más pequeños pueden ser para problemas como el análisis de opiniones o la detección de spam. Esta es la forma en que se abordan la mayoría de los problemas de PNL porque proporciona resultados más precisos que comenzar con un conjunto de datos más pequeño.

Es por eso que BERT es un gran descubrimiento. Proporciona una forma de pre-entrenar con mayor precisión tus modelos con menos datos. El enfoque bidireccional que utiliza significa que obtiene más contexto para una palabra que si solo estuviera entrenando en una dirección. Con este contexto adicional, puede aprovechar otra técnica llamada LM enmascarada.

En qué se diferencia de otros algoritmos de aprendizaje automático

El LM enmascarado enmascara al azar el 15% de las palabras en una oración con un símbolo o token [MASK] y luego trata de predecirlas basándose en las palabras que rodean a la palabra enmascarada. Así es como BERT puede ver las palabras de izquierda a derecha y de derecha a izquierda.

Esto es completamente diferente de cualquier otro modelo de lenguaje existente porque mira las palabras antes y después de una palabra enmascarada, al mismo tiempo. Gran parte de la precisión que tiene BERT se puede atribuir a esto.

Para que BERT funcione con tu conjunto de datos, debes agregar un poco de metadatos. Deberá haber incrustaciones de tokens (token embeddings) para marcar el principio y el final de las oraciones. Deberá tener incrustaciones de segmentos (segment embeddings) para poder distinguir diferentes oraciones. Por último, necesitará incrustaciones posicionales (positional embeddings) para indicar la posición de las palabras en una oración.

Se verá similar a esto.

[CLS] the [MASK] has blue spots [SEP] it rolls [MASK] the parking lot [SEP]

Con los metadatos agregados a tus puntos de datos (data points), LM enmascarado está listo para funcionar.

Una vez que ha terminado de predecir palabras, BERT aprovecha la predicción de la siguiente oración. Esto analiza la relación entre dos oraciones. Hace esto para comprender mejor el contexto de todo el conjunto de datos al tomar un par de oraciones y predecir si la segunda oración es la siguiente en función del texto original.

Para que la predicción de la siguiente oración funcione en la técnica BERT, la segunda oración se envía a través del modelo basado en Transformer.

Hay cuatro versiones diferentes de BERT previamente entrenadas según la escala de datos con la que estés trabajando. Puedes aprender más sobre ellos aquí: https://github.com/google-research/bert#bert

El inconveniente de este enfoque es que la función de pérdida solo considera las predicciones de palabras enmascaradas y no las predicciones de las demás. Eso significa que la técnica BERT converge más lentamente que las otras técnicas de derecha a izquierda o de izquierda a derecha.

BERT se puede aplicar a cualquier problema de PNL que se te ocurra, incluida la predicción de intenciones, las aplicaciones de respuesta a preguntas y la clasificación de texto.

Ejemplo de Código

Preparándote

Ahora veremos un ejemplo de BERT en acción. Lo primero que deberás hacer es clonar el repositorio de Bert.

git clone https://github.com/google-research/bert.git

Ahora necesita descargar los archivos de modelo BERT previamente entrenados desde la página BERT en GitHub. A lo largo del resto de este tutorial, me referiré al directorio de este repositorio como directorio raíz.

Estos archivos te brindan los hiperparámetros, pesos y otras cosas que necesitas con la información que Bert aprendió durante el entrenamiento previo. Usaré el modelo BERT-Base, Uncased, pero encontrarás varias otras opciones en diferentes idiomas en la página de GitHub.

Algunas de las razones por las que elegirías el modelo BERT-Base, Uncased es si no tienes acceso a una TPU de Google, en cuyo caso normalmente elegirías un modelo Base.

Si cree que el texto que estás tratando de analizar distingue entre mayúsculas y minúsculas (esa distinción le da un significado contextual real), entonces optarías por un modelo de tipo Cased.

Si la distinción entre mayúsculas y minúsculas no es importante o aún no está muy seguro, entonces un modelo de tipo Uncased sería una opción válida.

Trabajaremos con algunas reseñas de Yelp como nuestro conjunto de datos. Recuerda, BERT espera los datos en un formato determinado utilizando esas incrustaciones de tokens y otros. Necesitaremos agregarlos a un archivo .tsv. Este archivo será similar a un .csv, pero tendrá cuatro columnas y ninguna fila de encabezado.

Así es como se verán las cuatro columnas.

• Columna 0: ID de la fila
• Columna 1: Etiqueta de la fila (debe ser un número entero)
• Columna 2: Una columna de la misma letra para todas las filas (no se usa para nada, pero BERT lo espera)
• Columna 3: El texto que queremos clasificar

Deberás crear una carpeta llamada datos en el directorio donde clonaste BERT y agregar tres archivos allí: train.tsv, dev.tsv, test.tsv.

En los archivos train.tsv y dev.tsv, tendremos las cuatro columnas de las que hablamos anteriormente. En el archivo test.tsv, solo tendremos el ID de fila y el texto que queremos clasificar como columnas. Estos serán los archivos de datos que usaremos para entrenar y probar nuestro modelo.

Preparando los datos

Primero necesitamos obtener los datos con los que trabajaremos. Puedes descargar las reseñas de Yelp aquí: https://course.fast.ai/datasets#nlp Estará en la sección NLP y querrás la versión Polarity.

La razón por la que trabajaremos con esta versión es porque los datos ya tienen una polaridad, lo que significa que ya tienen un sentimiento asociado. Guarda este archivo en el directorio de datos.

Ahora estamos listos para comenzar a escribir código. Crea un nuevo archivo en el directorio raíz llamado pre_processing.py y agrega el siguiente código.

import pandas as pd
# esto es para extraer los datos de ese archivo .tgz
import tarfile
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split

# obtener todos los datos de ese .tgz
yelp_reviews = tarfile.open('data/yelp_review_polarity_csv.tgz')
yelp_reviews.extractall('data')
yelp_reviews.close()

# comprueba cómo se ven los datos antes de empezar
# mira el conjunto de datos de entrenamiento
train_df = pd.read_csv('data/yelp_review_polarity_csv/train.csv', header=None)
print(train_df.head())

# mira el conjunto de datos de prueba
test_df = pd.read_csv('data/yelp_review_polarity_csv/test.csv', header=None)
print(test_df.head())

En este código, hemos importado algunos paquetes de Python y descomprimimos los datos para ver cómo se ven. Notarás que los valores asociados con las reseñas son 1 y 2, siendo 1 una mala reseña y 2 una buena reseña. Necesitamos convertir estos valores a etiquetas más estándar, es decir 0 y 1. Puedes hacerlo con el siguiente código.

train_df[0] = (train_df[0] == 2).astype(int)
test_df[0] = (test_df[0] == 2).astype(int)

Siempre que realizes cambios a tus datos, es importante comprobar si todo salió bien. Entonces lo haremos con los siguientes comandos.

print(train_df.head())
print(test_df.head())

Cuando veas que tus valores de polaridad han cambiado para ser lo que esperabas. Ahora los datos deberían tener unos y ceros.

Dado que hemos limpiado los datos iniciales, es hora de preparar las cosas para BERT. Tendremos que hacer que nuestros datos se ajusten a los formatos de columna de los que hablamos anteriormente. Comencemos con los datos de entrenamiento.

Los datos de entrenamiento tendrán las cuatro columnas: ID de fila, etiqueta de fila, letra única, texto que queremos clasificar.

BERT espera dos archivos para entrenamiento llamados train y dev. Crearemos esos archivos dividiendo el archivo de entrenamiento inicial en dos archivos después de formatear nuestros datos con los siguientes comandos.

bert_df = pd.DataFrame({
    'id': range(len(train_df)),
    'label': train_df[0],
    'alpha': ['q']*train_df.shape[0],
    'text': train_df[1].replace(r'\n', ' ', regex=True)
})

train_bert_df, dev_bert_df = train_test_split(bert_df, test_size=0.01)

Con la variable bert_df, hemos formateado los datos para que sean los que espera BERT. Puedes elegir cualquier otra letra para el valor alpha si lo deseas. El método train_test_split que importamos al principio se encarga de dividir los datos de entrenamiento en los dos archivos que necesitamos.

Observa cómo se formatearon los datos con este comando.

print(train_bert_df.head())

Ahora necesitamos formatear los datos de prueba. Esto se verá diferente de cómo manejamos los datos de entrenamiento. BERT solo espera dos columnas para los datos de prueba: ID de fila, texto que queremos clasificar. No necesitamos hacer nada más con los datos de prueba una vez que los tengamos en este formato y lo haremos con el siguiente comando.

test_bert_df = pd.DataFrame({
    'id': range(len(test_df)),
    'text': test_df[1].replace(r'\n', ' ', regex=True)
})

Es similar a lo que hicimos con los datos de entrenamiento, solo que sin dos de las columnas. Echa un vistazo a los datos de prueba recién formateados.

test_bert_df.head()

Si todo se ve bien, puede guardar estas variables como los archivos .tsv con los que trabajará BERT.

train_bert_df.to_csv('data/train.tsv', sep='\t', index=False, header=False)
dev_bert_df.to_csv('data/dev.tsv', sep='\t', index=False, header=False)
test_bert_df.to_csv('data/test.tsv', sep='\t', index=False, header=False)

Entrenando el modelo

Una nota rápida antes de comenzar a entrenar el modelo: BERT puede consumir muchos recursos en las computadoras portátiles. Puede causar errores de memoria porque no hay suficiente RAM o algún otro hardware no es lo suficientemente potente. Podrías intentar hacer que training_batch_size sea más pequeño, pero eso hará que el entrenamiento del modelo sea realmente lento.

Agrega una carpeta al directorio raíz llamada model_output. Ahí es donde se guardará nuestro modelo una vez finalizado el entrenamiento. Ahora abre una terminal y ve al directorio raíz de este proyecto. Una vez que estés en el directorio correcto, ejecuta el siguiente comando y comenzará a entrenar tu modelo.

python run_classifier.py --task_name=cola --do_train=true --do_eval=true --data_dir=./data/ --vocab_file=./uncased_L-12_H-768_A-12/vocab.txt --bert_config_file=./uncased_L-12_H-768_A-12/bert_config.json --init_checkpoint=./uncased_L-12_H768_A-12/bert_model.ckpt.index --max_seq_length=128 --train_batch_size=32 --learning_rate=2e-5 --num_train_epochs=3.0 --output_dir=./model_output --do_lower_case=False

Deberías ver algunos resultados desplazándose a través de tu terminal. Una vez que esto termine de ejecutarse, tendrás un modelo entrenado que está listo para hacer predicciones.

Haciendo una predicción

Si echas un vistazo al directorio model_output, notarás que hay un montón de archivos model.ckpt. Estos archivos tienen los pesos del modelo entrenado en diferentes puntos durante el entrenamiento, por lo que deseas encontrar el que tenga el número más alto. Ese será el modelo entrenado final que querrás usar.

Ahora ejecutaremos run_classifier.py nuevamente con opciones ligeramente diferentes. En particular, cambiaremos el valor init_checkpoint al punto de control del modelo más alto y estableceremos un nuevo valor --do_predict en verdadero. Aquí está el comando que necesitas ejecutar en tu terminal.

python run_classifier.py --task_name=cola --do_predict=true --data_dir=./data --vocab_file=./uncased_L-12_H-768-A-12/bert_config.json --init_checkpoint=./model_output/model.ckpt-<highest checkpoint number> --max_seq_length=128 --output_dir=./model_output

Una vez que el comando termine de ejecutarse, debería ver un nuevo archivo llamado test_results.tsv. ¡Esto tendrá tus resultados predichos basados en el modelo que entrenaste!

Acabas de utilizar BERT para analizar algunos datos reales y, con suerte, todo esto tiene sentido.

Otros pensamientos

Sentí que era necesario pasar por el proceso de limpieza de datos aquí en caso de que alguien no lo haya pasado antes. A veces, el aprendizaje automático parece mágico, pero realmente se trata de tomarse el tiempo para que tus datos estén en las condiciones adecuadas para entrenar con un algoritmo.

BERT todavía es relativamente nuevo desde que se lanzó en 2018, pero hasta ahora ha demostrado ser más preciso que los modelos existentes, incluso si es más lento.

Traducido del artículo de Milecia McGregor - Google BERT NLP Machine Learning Tutorial

Los algoritmos basados en árboles tienden a usar la media para características (features) continuas o el modo para características categóricas cuando hacen predicciones sobre muestras de entrenamiento en las regiones a las que pertenecen. También producen predicciones con alta precisión, estabilidad y facilidad de interpretación.

Ejemplos de algoritmos basados en árboles

Hay diferentes algoritmos basados en árboles que puedes usar, como por ejemplo

• Árboles de Decisiones (Decision Trees)
• Bosques Aleatorios (Random Forest)
• Aumento de Gradiente (Gradient Boosting)
• Bagging (Agregación Bootstrap  "Bootstrap Aggregation")

Por lo tanto, todo científico de datos debería aprender estos algoritmos y usarlos en sus proyectos de aprendizaje automático.

En este artículo, aprenderás sobre el algoritmo de bosques aleatorios (random forest). Después de completar este artículo, podrás dominar el uso del algoritmo de bosque aleatorio para resolver y crear modelos predictivos para problemas de clasificación con scikit-learn.

¿Qué es el algoritmo de bosques aleatorios?

Bosque aleatorio es uno de los algoritmos de aprendizaje supervisado basados en árboles más populares. También es el más flexible y fácil de usar.

El algoritmo se puede utilizar para resolver problemas de clasificación y regresión. El bosque aleatorio tiende a combinar cientos de árboles de decisión y luego entrena cada árbol de decisión en una muestra diferente de las observaciones.

Las predicciones finales del bosque aleatorio se realizan promediando las predicciones de cada árbol individual.

Los beneficios son numerosos. Los árboles de decisión individuales tienden a sobre ajustarse (overfit) a los datos de entrenamiento, pero el bosque aleatorio puede mitigar ese problema al promediar los resultados de predicción de diferentes árboles. Esto le da al algoritmo de bosques aleatorios una mayor precisión predictiva que un solo árbol de decisión.

El algoritmo de bosque aleatorio también puede ayudarte a encontrar características que son importantes en tu conjunto de datos. Esto se debe al algoritmo de Boruta, que selecciona características importantes en un conjunto de datos.

El bosque aleatorio se ha utilizado en una variedad de aplicaciones, por ejemplo, para proporcionar recomendaciones de diferentes productos a los clientes en el comercio electrónico.

En medicina, el algoritmo puede ser utilizado para identificar la enfermedad del paciente a través del análisis de su historial médico.

También en el sector bancario, puede ser utilizado para determinar fácilmente si el cliente es fraudulento o legítimo.

¿Cómo funciona el algoritmo de bosques aleatorios?

El algoritmo funciona completando los siguientes pasos:

Paso 1: El algoritmo selecciona muestras en forma aleatoria de la base de datos proporcionada.

Paso 2: El algoritmo creará un árbol de decisión para cada muestra seleccionada. Luego obtendrá un resultado de predicción de cada árbol creado.

Paso 3: A continuación, se realizará la votación para cada resultado previsto. Para un problema de clasificación, usará la moda, y para un problema de regresión, usará la media.

Paso 4: Y finalmente, el algoritmo seleccionará el resultado de predicción más votado como predicción final.

Algoritmo de bosques aleatorios en la práctica

Ahora que conoces el funcionamiento del algoritmo de bosque aleatorio, creemos un clasificador.

Construiremos un clasificador utilizando el conjunto de datos de diabetes de los indios Pima. El conjunto de datos de diabetes de los indios Pima implica predecir la aparición de la diabetes en un plazo de 5 años según los detalles médicos proporcionados. Este es un problema de clasificación binaria.

Nuestro objetivo es analizar y crear un modelo sobre aquel conjunto de datos para predecir si un paciente en particular tiene riesgo de desarrollar diabetes, dados otros factores independientes.

Comenzaremos importando paquetes importantes que usaremos para cargar el conjunto de datos y crear un clasificador de bosque aleatorio. Usaremos la biblioteca scikit-learn para cargar y usar el algoritmo de bosque aleatorio.

# importar paquetes importantes
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

%matplotlib inline

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import StandardScaler, MinMaxScaler
import pandas_profiling

from matplotlib import rcParams
import warnings

warnings.filterwarnings("ignore")

# tamaño de la figura en pulgadas
rcParams["figure.figsize"] = 10, 6
np.random.seed(42)

Conjunto de datos

Luego, carga el conjunto de datos desde el directorio de datos:

# Cargar conjunto de datos
data = pd.read_csv("../data/pima_indians_diabetes.csv")

Ahora podemos observar la muestra del conjunto de datos.

# mostrar muestra del conjunto de datos
data.sample(5)

Como puedes ver, en nuestro conjunto de datos tenemos deferentes características con valores numéricos.

Entendamos la lista de características que tenemos en este conjunto de datos.

# mostrar columnas
data.columns

En este conjunto de datos, hay 8 características  de entrada y 1 característica de salida / destino. Se cree que los valores que faltan están codificados con valor cero. El significado de los nombres de las características es el siguiente (desde la primera hasta la última):

• Número de embarazos.
• Concentración de glucosa en plasma a 2 horas en una prueba oral de tolerancia a la glucosa.
• Presión arterial diastólica (mm Hg).
• Espesor del pliegue cutáneo del tríceps (mm).
• Insulina sérica de 2 horas (mu U / ml).
• Índice de masa corporal (peso en kg / (altura en m) ^ 2).
• Función del pedigrí de la diabetes.
• Edad (años).
• Variable de clase (0 o 1).

Luego, dividimos el conjunto de datos en características independientes y característica  de destino. Nuestra característica de destino para este conjunto de datos se llama class.

# dividir los datos en características de entrada y de destino

X = data.drop("class", axis=1)
y = data["class"]

Preprocesamiento del Conjunto de Datos

Antes de crear un modelo, necesitamos estandarizar nuestras características independientes usando el método standardScaler de scikit-learn.

# estandarizar el conjunto de datos
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

Dividiendo el conjunto de datos en datos de entrenamiento y prueba

Ahora dividimos nuestro conjunto de datos procesados en datos de prueba y entrenamiento. Los datos de prueba serán el 10% de todo el conjunto de datos procesados.

# dividir en conjunto de entrenamiento (train) y 
#conjunto de prueba (test)
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, stratify=y, test_size=0.10, random_state=42
)

Construyendo el Clasificador de bosque aleatorio

Ahora es el momento de crear nuestro clasificador de bosque aleatorio y luego entrenarlo en el conjunto de entrenamiento. También pasaremos el número de árboles (100) del bosque que queremos usar mediante el parámetro llamado n_estimators.

# crear el clasificador
classifier = RandomForestClassifier(n_estimators=100)

# Entrenar el modelo usando el conjunto de entranamiento
classifier.fit(X_train, y_train)

El resultado anterior muestra diferentes valores de parámetros del clasificador de bosque aleatorio utilizado durante el proceso de entrenamiento en los datos de entrenamiento.

Después del entrenamiento, podemos realizar predicciones sobre los datos de la prueba.

# predicción en el conjunto de prueba
y_pred = classifier.predict(X_test)

Luego, verificamos la precisión utilizando los valores reales y los predichos de los datos de prueba.

# Calcular la precisión del modelo
print("Precisión:", accuracy_score(y_test, y_pred))

Precisión: 0.8051948051948052

Nuestra precisión es de alrededor del 80,5%, lo cual es bueno. Pero siempre podemos hacerlo mejor.

Identificar características importantes

Como dije antes, también podemos verificar las características importantes usando la variable feature_importances_ del algoritmo de bosque aleatorio en scikit-learn.

# verificar características importantes
feature_importances_df = pd.DataFrame(
    {"feature": list(X.columns), "importance": classifier.feature_importances_}
).sort_values("importance", ascending=False)

# Mostrar
feature_importances_df

La figura anterior muestra la importancia relativa de las características y su contribución al modelo. También podemos visualizar estas características y sus puntuaciones utilizando las bibliotecas seaborn y matplotlib.

# visualizarcaracterísticas importantes

# Crear un diagrama de barras
sns.barplot(x=feature_importances_df.feature, y=feature_importances_df.importance)
# agregar estiquestas

plt.xlabel("Feature Importance Score")
plt.ylabel("Features")
plt.title("Visualizing Important Features")
plt.xticks(
    rotation=45, horizontalalignment="right", fontweight="light", fontsize="x-large"
)
plt.show()

En la figura anterior, puedes ver que la variable triceps_skinfold_thickness tiene poca importancia y no contribuye mucho a la predicción.

Esto significa que podemos eliminar esta variable y entrenar nuestro clasificador  nuevamente y luego ver si puede mejorar su rendimiento en los datos de prueba.

# cargar datos con características seleccionadas
X = data.drop(["class", "triceps_skinfold_thickness"], axis=1)
y = data["class"]

# estandarizar el conjunto de datos
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# dividir en conjunto de entrenamiento y de prueba
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, stratify=y, test_size=0.10, random_state=42
)

Entrenaremos el algoritmo con las características procesadas seleccionadas de nuestro conjunto de datos, realizaremos predicciones y luego calcularemos la precisión del modelo.

# crear clasificador
clf = RandomForestClassifier(n_estimators=100)

# Entrenar el modelo usando el conjunto de entrenamiento
clf.fit(X_train, y_train)

# predicción en el conjunto de prueba
y_pred = clf.predict(X_test)

# Calcular la precisión del modelo,
print("Precisión:", accuracy_score(y_test, y_pred))

Precisión: 0.8181818181818182

Ahora, la precisión del modelo ha aumentado del 80,5% al 81,8% después de que eliminamos la característica menos importante llamada triceps_skinfold_thickness.

Esto sugiere que es muy importante verificar las características importantes y ver si puedes eliminar las menos importantes para aumentar el rendimiento de su modelo.

En resumen

Los algoritmos basados en árboles son realmente importantes para que los aprenda todo científico de datos. En este artículo, has aprendido los conceptos básicos de los algoritmos basados en árboles y cómo crear un modelo de clasificación utilizando el algoritmo de bosque aleatorio.

¡Felicitaciones, has llegado al final de este artículo!

Si aprendiste algo nuevo o disfrutaste leyendo este artículo, compártelo para que otros puedan verlo. Hasta entonces, ¡nos vemos en el próximo post! También me pueden contactar en Twitter @Davis_McDavid

Traducido del artículo de Davis David - Random Forest Classifier Tutorial: How to Use Tree-Based Algorithms for Machine Learning