Skip to content

Clasificación lineal (regresión logística) utilizando reciente Tensorflow 2+

En este artículo, implementamos la clasificación lineal utilizando la versión más reciente de Tensorflow. es decir, 2.2+

¿Qué es la clasificación lineal ? 

 
  • Cuando los puntos de datos a clasificar son separables por una línea o, en términos más fáciles, podemos trazar una línea entre los registros de éxito y los registros de falla, lo llamamos Clasificador lineal .  
  •  En el campo de la ciencia de datos o el aprendizaje automático , un clasificador lineal tiene un objetivo de clasificación estadística para identificar a qué clase de salida pertenece un conjunto de entrada. 

  • Al usar valores de  combinaciones lineales y tomar una   decisión de clasificación , un   clasificador lineal logra su objetivo final.

    Los ejemplos de clasificador lineal incluyen regresión logística , clasificación NB , etc.

  •  

¿Cuál es la diferencia entre las técnicas de clasificación lineal y no lineal?

Para el espacio de entidades 2D , digamos datos que tienen solo el eje xy el eje y. Si se puede dibujar una línea entre puntos sin cortar ninguno de ellos, son linealmente separables .

Ahora, mira la  imagen de abajo (a tu derecha). Los casos en los que los datos no son separables utilizando una línea recta se incluyen en la categoría no lineal . Aquí necesitábamos un círculo para separar los puntos. 

 Lo mismo ocurre con los clústeres en datos 3D . La única diferencia es que se usa un plano allí en lugar de una línea.

  •  Este tipo de clasificador funciona mejor cuando el problema es lineal separable.

linear_vs_nonlinear

¿Cuáles son los tipos de diferencia de clasificadores lineales?

Principalmente dividido en:

A: Generativo (asume funciones de densidad condicional): 

A1: Análisis discriminante lineal (LDA): asume modelos de densidad condicional gaussiana

A2: clasificador Naive Bayes con modelos Bernoulli multinomiales o multivariados .

B: modelos discriminatorios
(intentos de maximizar la calidad del resultado en un conjunto de entrenamiento)

B1: regresión logística

B1: perceptrones

B1: Máquinas de vectores de soporte (SVM)

  • El siguiente truco nos muestra cómo podemos implementar un clasificador lineal usando la famosa biblioteca de tensorflow.
  • Este código también demuestra cómo podemos guardar el modelo y usarlo en producción.
 
Versión de Pythonnivel de dificultadRequisito previo
2.7+fácilfundamentos de python
” ‘
Importar módulos
” ‘
importar tensorflow como tf
importar numpy como np
importar pandas como pd

 

importar matplotlib.pyplot como plt
% matplotlib en línea

 

# Cargar en los datos
desde sklearn.datasets import load_breast_cancer

 

# Utilizado para dividir el conjunto de datos para entrenar y probar
de sklearn.model_selection import train_test_split

 

# Utilizado para escalar los datos
desde sklearn.preprocessing import StandardScaler
 
 
” ‘
Módulo incorporado para cargar los datos.
Esto descarga los datos (se necesita conexión a Internet)
” ‘
data = load_breast_cancer ()

 

# verifique el tipo de ‘datos’
tipo (datos)
” ‘
Qué datos representan y Obtener las columnas de datos y el objetivo
” ‘
data.target_names, data.feature_names
(array(['malignant', 'benign'], dtype='<U9'), array(['mean radius', 'mean texture', 'mean perimeter', 'mean area', 'mean smoothness', 'mean compactness', 'mean concavity', 'mean concave points', 'mean symmetry', 'mean fractal dimension', 'radius error', 'texture error', 'perimeter error', 'area error', 'smoothness error', 'compactness error', 'concavity error', 'concave points error', 'symmetry error', 'fractal dimension error', 'worst radius', 'worst texture', 'worst perimeter', 'worst area', 'worst smoothness', 'worst compactness', 'worst concavity', 'worst concave points', 'worst symmetry', 'worst fractal dimension'], dtype='<U23'))
” ‘
Rompemos los datos de entrada usando la biblioteca sklearn (Verifique la sintaxis de parámetros para train_test_split)
” ‘
X_train, X_test, y_train, y_test = train_test_split (data.data, data.target, test_size = 0.33 )
N, D = X_train.shape
 
 
” ‘
El escalado es imprescindible para ayudar a las redes neuronales a encontrar patrones de manera efectiva
” ‘
scaler = StandardScaler ()
X_train = scaler.fit_transform (X_train)
X_test = scaler.transform (X_test)
 
” ‘
Sección de construcción de modelos
” ‘
modelo = tf.keras.models.Sequential ([
tf.keras.layers.Input (shape = (D,)),
tf.keras.layers.Dense ( 1 , activación = ‘sigmoide’ )
])

 

# compila el modelo
modelo. compilar (optimizador = ‘adam’ ,
pérdida = ‘binary_crossentropy’ ,
métricas = [ ‘precisión’ ])
# Entrena al modelo
r = model.fit (X_train, y_train, validation_data = (X_test, y_test), epochs = 100 )
# Evaluar el modelo: la función de evaluación () devuelve pérdida y precisión
print ( “Puntuación del tren:” , model.evaluate (X_train, y_train))
print ( “Puntaje de la prueba:” , model.evaluate (X_test, y_test))
Epoch 100/100 12/12 [==============================] - 0s 4ms/step - loss: 0.0855 - accuracy: 0.9816 - val_loss: 0.1101 - val_accuracy: 0.9734 
Test score: [0.10941322147846222, 0.9734042286872864]
” ‘
Tracemos la pérdida
” ‘
plt.plot (r.history [ ‘loss’ ], label = ‘loss’ )
plt.plot (r.history [ ‘val_loss’ ], label = ‘val_loss’ )
plt.legend ()
” ‘
Tracemos la precisión
” ‘
plt.plot (r.history [ ‘precision’ ], label = ‘acc’ )
plt.plot (r.history [ ‘val_accuracy’ ], label = ‘val_acc’ )
plt.legend ()
linear_classifier
linear_classifier2

Vamos a usar este modelo para hacer predicciones

” ‘
Usamos X_test para hacer predicciones (retroceda y vea qué es X_test si no lo recuerda)
” ‘
pred = model.predict (X_test) #esto devuelve salida
pred = np. round (pred) .flatten () # necesitamos redondear y flattern para compararlo con los resultados reales de y_test
imprimir (pred)

 

” ‘
Calculamos la precisión del modelo.
evaluar () devuelve PÉRDIDA Y PRECISIÓN
” ‘
print ( “Precisión calculada manualmente:” , np.mean (pred == y_test))
print ( “Evaluar salida:” , model.evaluate (X_test, y_test))
Manually calculated accuracy: 0.973404255319149 6/6 [==============================] - 0s 2ms/step - loss: 0.1094 - accuracy: 0.9734 Evaluate output: [0.10941322147846222, 0.9734042286872864]

Vamos a guardar este modelo para implementarlo en producción

” ‘
Synatx para guardar el modelo en yoru local
” ‘

model.save ( ‘linearclassifier.h5’ )

” ‘
Verifiquemos si el modelo se guarda en el sistema local
” ‘
! ls -lrt
-rw-r--r-- 1 root root 18480 Jun 5 07:41 linearclassifier.h5
”’
Nota :
Podemos optimizar este modelo para obtener una mayor precisión cambiando valores como épocas,
número de capas ocultas, etc.
Todo es un juego de trail y error.
”’
” ‘
Así es como cargamos el modelo guardado y lo usamos para predicciones;
” ‘
modelo = tf.keras.models.load_model ( ‘linearclassifier.h5’ )
print (model.layers)
model.evaluate (X_test, y_test)
[<tensorflow.python.keras.layers.core.Dense object at 0x7fd15925eb38>]
6/6 [==============================] - 0s 2ms/step - loss: 0.1094 - accuracy: 0.9734
[0.10941322147846222, 0.9734042286872864]

 Eso fue genial !

No te pierdas los artículos a continuación.