Aprender los conceptos clave

1

Todo lo que aprenderás sobre MA con Scikit-Learn

2

¿Cómo aprenden las máquinas?

3

Problemas que podemos resolver con Scikit-learn

4

Las matemáticas que vamos a necesitar

Iniciar un proyecto con sklearn

5

Configuración de nuestro entorno Python

6

Instalación de librerías en Python

7

Datasets que usaremos en el curso

Optimización de features

8

¿Cómo afectan nuestros features a los modelos de Machine Learning?

9

Introducción al PCA

10

Preparación de datos para PCA e IPCA

11

Implementación del algoritmo PCA e IPCA

12

Kernels y KPCA

13

¿Qué es la regularización y cómo aplicarla?

14

Implementación de Lasso y Ridge

15

Explicación resultado de la implementación

16

ElasticNet: Una técnica intermedia

Regresiones robustas

17

El problema de los valores atípicos

18

Regresiones Robustas en Scikit-learn

19

Preparación de datos para la regresión robusta

20

Implementación regresión robusta

Métodos de ensamble aplicados a clasificación

21

¿Qué son los métodos de ensamble?

22

Preparación de datos para implementar métodos de ensamble

23

Implementación de Bagging

24

Implementación de Boosting

Clustering

25

Estrategias de Clustering

26

Implementación de Batch K-Means

27

Implementación de Mean-Shift

Optimización paramétrica

28

Validación de nuestro modelo usando Cross Validation

29

Implementación de K-Folds Cross Validation

30

Optimización paramétrica

31

Implementación de Randomized

32

Bonus: Auto Machine Learning

Salida a producción

33

Revisión de nuestra arquitectura de código

34

Importar y exportar modelos con Sklearn

35

Creación de una API con Flask para el modelo

36

Cierre del curso

37

Material adicional para consultar

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Aprende todo un fin de semana sin pagar una suscripción 🔥

Aprende todo un fin de semana sin pagar una suscripción 🔥

Regístrate

Comienza en:

3D
20H
31M
27S

Kernels y KPCA

12/37
Recursos

Aportes 25

Preguntas 8

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

o inicia sesión.

Ahora que ya sabemos para el algoritmo de PCA, ¿que otras alternativas tenemos?


Bueno, una alternativa son los Kernels. Un Kernel es una función matemática que toma mediciones que se comportan de manera no lineal y las proyecta en un espacio dimensional más grande en donde sen linealmente separables.

Y, ¿esto para que puede servir?

Sirve para casos en donde no son linealmente separables. El la primera imagen no es posible separarlos con una linea y en la imagen 2 si lo podemos hacer mediante Kernels. Lo que hace la función de Kernels es proyectar los puntos en otra dimensión y así volver los datos linealmente separables.

¿Que tipo de funciones para Kernels nos podemos encontrar?

Ejemplos de funciones de Kernels en datasets aplicados a un clasificador:

Me ha sorprendido el curso, de los mejores de ML de Platzi. Qué gusto!

Rendimiento de cada una de las técnicas a partir de la cantidad de componentes con las que fueron entrenados vs el accuracy del modelo de regresión logística

Excelente! todos los conceptos y hasta el código muy ordenado.

Comparación entre los tres tipos de kernel con este ejercicio en particular

Les dejo el código comentado por si no les corre:

# Importamos las bibliotecas generales
import pandas as pd
import sklearn
import matplotlib.pyplot as plt
# Importamos los módulos específicos
from sklearn.decomposition import KernelPCA
 
 
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
if __name__ == "__main__":
 # Cargamos los datos del dataframe de pandas
 dt_heart = pd.read_csv('data/heart.csv')
 # Imprimimos un encabezado con los primeros 5 registros
 print(dt_heart.head(5))
 # Guardamos nuestro dataset sin la columna de target
 dt_features = dt_heart.drop(['target'], axis=1)
 # Este será nuestro dataset, pero sin la columna
 dt_target = dt_heart['target']
 # Normalizamos los datos
 dt_features = StandardScaler().fit_transform(dt_features)
  # Partimos el conjunto de entrenamiento y para añadir replicabilidad usamos el random state
 X_train, X_test, y_train, y_test = train_test_split(dt_features, dt_target, test_size=0.3, random_state=42)
 
 #Aplicamos la función de kernel de tipo polinomial
 kpca = KernelPCA(n_components=4, kernel='poly' )
 #Vamos a ajustar los datos
 kpca.fit(X_train)
 
 #Aplicamos el algoritmo a nuestros datos de prueba y de entrenamiento
 dt_train = kpca.transform(X_train)
 dt_test = kpca.transform(X_test)
 
 #Aplicamos la regresión logística un vez que reducimos su dimensionalidad
 logistic = LogisticRegression(solver='lbfgs')
 
 #Entrenamos los datos
 logistic.fit(dt_train, y_train)
 
 #Imprimimos los resultados
 print("SCORE KPCA: ", logistic.score(dt_test, y_test))
 

Increíble forma de enseñar!

Para los curiosos, en ésta página hay información sobre la Función de Base Radial (RBF) pero aplicada como una red nuronal.

NoteBook de la clase git hub

Hasta el momento ha sido el mejor curso de Machine Learning que hay en la ruta, todo muy bien explicado y con aplicabilidad en código

Excelente explicación para entender el concepto de kernels y como el aumento de dimensiones puede ayudar a resolver problemas de clasificación.

Deberían citar a los autores de las imágenes que toman de otras fuentes.

Comparando los kernels

import pandas as pd
import sklearn
import matplotlib.pyplot as plt

from sklearn.decomposition import KernelPCA

from sklearn.linear_model import LogisticRegression

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split


if __name__ == "__main__":

    dt_heart = pd.read_csv('./data/heart.csv')
    #print(dt_heart.head(5))

    dt_features = dt_heart.drop(['target'],axis=1) # separamos los target del dataframe features
    dt_target = dt_heart['target'] # creamos otra dataframe unicamente con los target


    dt_features = StandardScaler().fit_transform(dt_features) # estandarizamos los datos
    X_train, X_test, y_train, y_test = train_test_split(dt_features, dt_target, test_size=0.3, random_state=42) # obtenemos datos de entrenamiento y datos de prueba

    logistic = LogisticRegression(solver='lbfgs')

    kernel = ['linear','poly','rbf']
    for k in kernel:
        kpca = KernelPCA(n_components=4, kernel = k) # kernel = linear / poly / rbf
        kpca.fit(X_train)

        dt_train = kpca.transform(X_train)
        dt_test = kpca.transform(X_test)

        logistic.fit(dt_train, y_train)
        print("SCORE KPCA " + k + " : ", logistic.score(dt_test, y_test))

$py kpca .py
SCORE KPCA linear : 0.8214285714285714
SCORE KPCA poly : 0.7987012987012987
SCORE KPCA rbf : 0.8181818181818182

De momento no existe ninguna alternativa Incremental para KernelPCA, así que queda descartada para trabajar con datasets grandes
https://github.com/scikit-learn/scikit-learn/issues/19479

El numero de componentes del PCA es opcional

Esta interesante hasta ahora el curso. Espero que al final del curso se llegue a una conclusión de las predicciones, cosas que le faltan a otros cursos de ML de Platzi.

Este curso va muy bien

Muy bien explicado!!

Muuuuy muy interesante! creo q esto podria resolver mi pregunta al principio del curso.

Como nota en las funciones de Scikit-Learn que aplican transformaciones en los datos tiene un metodo llamafo fit_transform que hace lo mismo que primero usar el metodo fit y luego transform

El kernel en si tiene varias definiciones si hablamos por ejemplo de PCA, de Feed Forward Networks o de Convolutional Neural Networks.En FFN, el kernel no es nada mas que los pesos de nuestros inputs, sin embargo en CNN el kernel es una matriz que multiplica a cada slice o “submatriz” de nuestro input.

LBFGS es un algoritmo de optimizacion que hasta Andrew Ng dijo que a veces le costaba entender, asi que si a un experto de ML le costo, imaginense lo complicado que debe ser xd.