Introducción al ML con scikit-learn

• Ultima modificación: 2024-01-22 | YouTube

Tipos de aprendizajes

• Aprendizaje supervisado:

  • Clasificación

  • Regresión

• Aprendizaje no supervisado:

  • Clustering

  • Reducción de dimensionalidad

  • Estimación de la densidad de probabilidad

Carga de un dataset de ejemplo

from sklearn import datasets

digits = datasets.load_digits()

# Variable independiente (X) o features
digits.data

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

digits.data.shape

(1797, 64)

# Variable dependiente (y) o target
digits.target

array([0, 1, 2, ..., 8, 9, 8])

# Dimensiones de los arrays de datos
digits.images[0]

array([[ 0.,  0.,  5., 13.,  9.,  1.,  0.,  0.],
       [ 0.,  0., 13., 15., 10., 15.,  5.,  0.],
       [ 0.,  3., 15.,  2.,  0., 11.,  8.,  0.],
       [ 0.,  4., 12.,  0.,  0.,  8.,  8.,  0.],
       [ 0.,  5.,  8.,  0.,  0.,  9.,  8.,  0.],
       [ 0.,  4., 11.,  0.,  1., 12.,  7.,  0.],
       [ 0.,  2., 14.,  5., 10., 12.,  0.,  0.],
       [ 0.,  0.,  6., 13., 10.,  0.,  0.,  0.]])

Aprendizaje y predicción

#
# creacion de un estimador SVM
#
from sklearn import svm

# Selección manual de los parámetros del estimador
clf = svm.SVC(
    gamma=0.001,
    C=100.0,
)

# aprendizaje (entrenamiento)
clf.fit(
    digits.data[:-1],
    digits.target[:-1],
)

SVC(C=100.0, gamma=0.001)

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

# Predicción
clf.predict(
    digits.data[-1:],
)

array([8])

Conversiones entre tipos de datos

#
# Cuando sea posible, una entrada de tipo 'float32' se mantendra.
# De otra forma, se hara la conversión a float64.
#
import numpy as np
from sklearn import kernel_approximation

rng = np.random.RandomState(0)
X = rng.rand(10, 2000)
X = np.array(X, dtype="float32")
display(X.dtype)

dtype('float32')

transformer = kernel_approximation.RBFSampler()
X_new = transformer.fit_transform(X)
X_new.dtype

dtype('float32')

#
# Algunos estimadores hacen la conversión a float64 por estabilidad numérica
#
from sklearn import datasets
from sklearn.svm import SVC

iris = datasets.load_iris()
clf = SVC()
clf.fit(iris.data, iris.target)

# Los targets en modelos de regresión son convertiddos
# a float64
list(
    clf.predict(iris.data[:3]),
)

[0, 0, 0]

clf.fit(
    iris.data,
    iris.target_names[iris.target],
)

# El tipo de los targets se mantiene en modelos de clasificación
list(
    clf.predict(iris.data[:3]),
)

['setosa', 'setosa', 'setosa']

Reajuste y modificación de parámetros

#
# Es posible reajustar y modificar los valores de los parámetros de un
# estimador
#
import numpy as np
from sklearn.datasets import load_iris
from sklearn.svm import SVC

X, y = load_iris(return_X_y=True)

# No se especifican los parámetros del estimador
clf = SVC()

# Se ajusta el estimador usando 'set_params'
clf.set_params(kernel="linear").fit(X, y)
clf.predict(X[:5])

array([0, 0, 0, 0, 0])

# Se ajusta el estimador usando 'set_params'
clf.set_params(kernel="rbf").fit(X, y)
clf.predict(X[:5])

array([0, 0, 0, 0, 0])

Multiclase vs multietiqueta

#
# Ajuste multiclase vs muultietiqueta
#
from sklearn.multiclass import OneVsRestClassifier
from sklearn.preprocessing import LabelBinarizer
from sklearn.svm import SVC

X = [  # Ejemplos
    [1, 2],  # 1
    [2, 4],  # 2
    [4, 5],  # 3
    [3, 2],  # 4
    [3, 1],  # 5
]

# Clases: {0, 1, 2}
y = [
    0,
    0,
    1,
    1,
    2,
]

#
# Clasificación multiclase
#
classif = OneVsRestClassifier(
    estimator=SVC(random_state=0),
)
classif.fit(X, y).predict(X)

array([0, 0, 1, 1, 2])

#
# Clasificación multietiqueta
#
y = LabelBinarizer().fit_transform(y)
y
#       0  1  2  <--- clases
# ---------------------------

array([[1, 0, 0],
       [1, 0, 0],
       [0, 1, 0],
       [0, 1, 0],
       [0, 0, 1]])

classif.fit(X, y).predict(X)  # para los ultimos 2 ejemplos no se asigna clase

array([[1, 0, 0],
       [1, 0, 0],
       [0, 1, 0],
       [0, 0, 0],
       [0, 0, 0]])

from sklearn.preprocessing import MultiLabelBinarizer

# Es posible asignar más de una clase a un ejemplo.
# Las etiquetas son 0, 1, 2, 3, y 4.
y = [
    [0, 1],
    [0, 2],
    [1, 3],
    [0, 2, 3],
    [2, 4],
]

y = MultiLabelBinarizer().fit_transform(y)
y
#       0  1  2  3  4 <--- etiquetas
# ------------------------------------

array([[1, 1, 0, 0, 0],
       [1, 0, 1, 0, 0],
       [0, 1, 0, 1, 0],
       [1, 0, 1, 1, 0],
       [0, 0, 1, 0, 1]])

classif.fit(X, y).predict(X)
#       0  1  2  3  4 <--- etiquetas
# -------------------------------------

array([[1, 1, 0, 0, 0],
       [1, 0, 1, 0, 0],
       [0, 1, 0, 1, 0],
       [1, 0, 1, 0, 0],
       [1, 0, 1, 0, 0]])