Descripción Detallada del Proyecto ML-From-Scratch

Resumen del Proyecto

ML-From-Scratch es un proyecto que implementa modelos y algoritmos fundamentales de aprendizaje automático desde cero utilizando Python. El objetivo de este proyecto no es producir los algoritmos más optimizados y computacionalmente eficientes, sino mostrar el funcionamiento interno de los algoritmos de una manera transparente y fácil de entender.

Autor del Proyecto

El autor del proyecto, Erik Linder-Norén, es un ingeniero de aprendizaje automático en Apple, apasionado por el aprendizaje automático, el baloncesto y la construcción de cosas.

Características del Proyecto

1. Orientación Educativa

• Se centra en la demostración transparente del mecanismo de funcionamiento interno de los algoritmos.
• La implementación del código es clara y fácil de entender, lo que facilita el aprendizaje y la comprensión.
• Proporciona numerosos ejemplos y resultados visuales.

2. Pila Tecnológica

• Lenguaje principal: Python
• Dependencias clave: NumPy (para cálculos numéricos)
• Visualización: Matplotlib (para la representación gráfica)

3. Amplia Cobertura

Cubre diversas áreas importantes del aprendizaje automático, desde la regresión lineal hasta el aprendizaje profundo.

Instalación y Uso

Pasos de Instalación

$ git clone https://github.com/eriklindernoren/ML-From-Scratch
$ cd ML-From-Scratch
$ python setup.py install

Ejecución de Ejemplos

# Ejemplo de Regresión Polinomial
$ python mlfromscratch/examples/polynomial_regression.py

# Ejemplo de Red Neuronal Convolucional
$ python mlfromscratch/examples/convolutional_neural_network.py

# Ejemplo de Agrupamiento DBSCAN
$ python mlfromscratch/examples/dbscan.py

Clasificación de Algoritmos Implementados

Algoritmos de Aprendizaje Supervisado

• Adaboost: Algoritmo de Impulso Adaptativo
• Bayesian Regression: Regresión Bayesiana
• Decision Tree: Árbol de Decisión
• Elastic Net: Red Elástica
• Gradient Boosting: Gradient Boosting
• K Nearest Neighbors: K Vecinos Más Cercanos
• Lasso Regression: Regresión Lasso
• Linear Discriminant Analysis: Análisis Discriminante Lineal
• Linear Regression: Regresión Lineal
• Logistic Regression: Regresión Logística
• Multi-class Linear Discriminant Analysis: Análisis Discriminante Lineal Multiclase
• Multilayer Perceptron: Perceptrón Multicapa
• Naive Bayes: Naive Bayes
• Neuroevolution: Neuroevolución
• Particle Swarm Optimization of Neural Network: Optimización por Enjambre de Partículas de Red Neuronal
• Perceptron: Perceptrón
• Polynomial Regression: Regresión Polinomial
• Random Forest: Bosque Aleatorio
• Ridge Regression: Regresión Ridge
• Support Vector Machine: Máquina de Soporte Vectorial
• XGBoost: Extreme Gradient Boosting

Algoritmos de Aprendizaje No Supervisado

• Apriori: Minería de Reglas de Asociación
• Autoencoder: Autoencoder
• DBSCAN: Agrupamiento Basado en Densidad
• FP-Growth: Crecimiento de Patrones Frecuentes
• Gaussian Mixture Model: Modelo de Mezcla Gaussiana
• Generative Adversarial Network: Red Generativa Antagónica
• Genetic Algorithm: Algoritmo Genético
• K-Means: K-Medias
• Partitioning Around Medoids: Particionamiento Alrededor de Medoides
• Principal Component Analysis: Análisis de Componentes Principales
• Restricted Boltzmann Machine: Máquina de Boltzmann Restringida

Componentes de Aprendizaje Profundo

• Neural Network: Marco de Red Neuronal
• Tipos de Capas:
  • Activation Layer (Capa de Activación)
  • Average Pooling Layer (Capa de Agrupamiento Promedio)
  • Batch Normalization Layer (Capa de Normalización por Lotes)
  • Constant Padding Layer (Capa de Relleno Constante)
  • Convolutional Layer (Capa Convolucional)
  • Dropout Layer (Capa Dropout)
  • Flatten Layer (Capa de Aplanamiento)
  • Fully-Connected (Dense) Layer (Capa Totalmente Conectada (Densa))
  • Fully-Connected RNN Layer (Capa RNN Totalmente Conectada)
  • Max Pooling Layer (Capa de Agrupamiento Máximo)
  • Reshape Layer (Capa de Remodelación)
  • Up Sampling Layer (Capa de Sobremuestreo)
  • Zero Padding Layer (Capa de Relleno con Ceros)

Resultados de Ejecución de Ejemplos

1. Ejemplo de Red Neuronal Convolucional

+---------+
| ConvNet |
+---------+
Input Shape: (1, 8, 8)
+----------------------+------------+--------------+
| Layer Type           | Parameters | Output Shape |
+----------------------+------------+--------------+
| Conv2D              | 160        | (16, 8, 8)   |
| Activation (ReLU)   | 0          | (16, 8, 8)   |
| Dropout             | 0          | (16, 8, 8)   |
| BatchNormalization  | 2048       | (16, 8, 8)   |
| Conv2D              | 4640       | (32, 8, 8)   |
| Activation (ReLU)   | 0          | (32, 8, 8)   |
| Dropout             | 0          | (32, 8, 8)   |
| BatchNormalization  | 4096       | (32, 8, 8)   |
| Flatten             | 0          | (2048,)      |
| Dense               | 524544     | (256,)       |
| Activation (ReLU)   | 0          | (256,)       |
| Dropout             | 0          | (256,)       |
| BatchNormalization  | 512        | (256,)       |
| Dense               | 2570       | (10,)        |
| Activation (Softmax)| 0          | (10,)        |
+----------------------+------------+--------------+
Total Parameters: 538570

Training: 100% [------------------------------------------------------------------------] Time: 0:01:55
Accuracy: 0.987465181058

2. Ejemplo de Red Q Profunda

+----------------+
| Deep Q-Network |
+----------------+
Input Shape: (4,)
+-------------------+------------+--------------+
| Layer Type        | Parameters | Output Shape |
+-------------------+------------+--------------+
| Dense             | 320        | (64,)        |
| Activation (ReLU) | 0          | (64,)        |
| Dense             | 130        | (2,)         |
+-------------------+------------+--------------+
Total Parameters: 450

3. Ejemplo de Neuroevolución

+---------------+
| Model Summary |
+---------------+
Input Shape: (64,)
+----------------------+------------+--------------+
| Layer Type           | Parameters | Output Shape |
+----------------------+------------+--------------+
| Dense                | 1040       | (16,)        |
| Activation (ReLU)    | 0          | (16,)        |
| Dense                | 170        | (10,)        |
| Activation (Softmax) | 0          | (10,)        |
+----------------------+------------+--------------+
Total Parameters: 1210

Population Size: 100
Generations: 3000
Mutation Rate: 0.01
[0 Best Individual - Fitness: 3.08301, Accuracy: 10.5%]
[1 Best Individual - Fitness: 3.08746, Accuracy: 12.0%]
...
[2999 Best Individual - Fitness: 94.08513, Accuracy: 98.5%]
Test set accuracy: 96.7%

Valor de Aprendizaje

1. Comprensión Profunda de los Principios del Algoritmo

• Al implementarlos desde cero, se puede comprender a fondo la idea central de cada algoritmo.
• La estructura del código es clara, lo que ayuda a comprender los detalles específicos de la implementación del algoritmo.

2. Habilidades de Programación Práctica

• Mejora las habilidades en el uso de bibliotecas de computación científica como NumPy.
• Aprende cómo transformar la teoría matemática en implementación de código.

3. Base para Investigación y Desarrollo

• Proporciona una base para futuras investigaciones y mejoras de algoritmos.
• Ayuda a comprender la implementación subyacente de los marcos de aprendizaje automático existentes.

Público Objetivo

• Estudiantes principiantes e intermedios de aprendizaje automático.
• Investigadores que deseen comprender a fondo los mecanismos internos de los algoritmos.
• Desarrolladores que quieran mejorar sus habilidades de implementación de programación.
• Estudiantes de carreras relacionadas con el aprendizaje automático.

Ventajas del Proyecto

1. Altamente Educativo: El código es claro y fácil de entender, con un fuerte enfoque en el valor pedagógico.
2. Amplia Cobertura: Incluye desde algoritmos básicos hasta avanzados.
3. Altamente Práctico: Proporciona ejemplos completos y ejecutables.
4. Actualización Continua: El proyecto está activo y se añaden constantemente nuevas implementaciones de algoritmos.

Notas Importantes

• Este proyecto está destinado principalmente para fines educativos y de aprendizaje, no es adecuado para su uso en entornos de producción.
• La implementación de los algoritmos se centra en la legibilidad, no en la optimización del rendimiento.
• Se recomienda utilizarlo junto con el estudio teórico para obtener mejores resultados.