Implementación Clasificadores Python

Aquí están los pasos detallados para implementar el algoritmo Naive Bayes en Python, cargando el dataset Iris en formato ARFF con la ayuda de scipy y luego aplicando el clasificador GaussianNB de scikit-learn.

Pasos:

1. Instalación de dependencias: Si aún no tienes instaladas las bibliotecas necesarias, ejecuta lo siguiente:

   pip install scikit-learn scipy pandas
   

2. Código en Python para implementar Naive Bayes:

from scipy.io import arff
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import classification_report, confusion_matrix

# Cargar el archivo iris.arff
data, meta = arff.loadarff('iris.arff')

# Convertir el dataset a un DataFrame de pandas
df = pd.DataFrame(data)

# Convertir la columna 'class' de bytes a string
df['class'] = df['class'].apply(lambda x: x.decode('utf-8'))

# Separar las características (X) y la clase objetivo (y)
X = df.drop('class', axis=1)
y = df['class']

# Dividir el conjunto de datos en entrenamiento y prueba (70% entrenamiento, 30% prueba)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Crear el modelo Naive Bayes (Gaussian)
model = GaussianNB()

# Entrenar el modelo con los datos de entrenamiento
model.fit(X_train, y_train)

# Predecir las etiquetas de clase para los datos de prueba
y_pred = model.predict(X_test)

# Mostrar la matriz de confusión y el informe de clasificación
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))
print("\nClassification Report:\n", classification_report(y_test, y_pred))

Explicación del código:

1. Cargar el dataset ARFF: Utilizamos scipy.io.arff para cargar el archivo ARFF, que se convierte en un DataFrame de pandas. Este formato es más fácil de manipular en Python.
2. Preprocesamiento:
   • La columna class contiene valores codificados en bytes, así que se decodifican a strings para que puedan ser manejados adecuadamente por scikit-learn.
   • X (las características) se extraen eliminando la columna de clase, mientras que y (las etiquetas de clase) se asignan a la columna class.
3. División de datos: Usamos train_test_split de scikit-learn para dividir el dataset en 70% para entrenamiento y 30% para prueba. Esto es útil para evaluar el rendimiento del modelo.
4. Modelo Naive Bayes:
   • GaussianNB: Es el clasificador Naive Bayes para datos continuos, que asume que los datos siguen una distribución gaussiana.
   • El modelo se entrena con los datos de entrenamiento y se realizan predicciones con los datos de prueba.
5. Evaluación:
   • Se genera una matriz de confusión para ver cuántas veces el modelo clasificó correctamente o incorrectamente cada clase.
   • El informe de clasificación muestra métricas como precisión, recall, F1-score y el soporte para cada clase.

Ejemplo de Salida:

El resultado será algo como esto:

Confusion Matrix:
 [[16  0  0]
  [ 0 11  1]
  [ 0  1 17]]

Classification Report:
               precision    recall  f1-score   support

    Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       0.92      0.92      0.92        12
 Iris-virginica       0.94      0.94      0.94        18

     accuracy                           0.96        46
    macro avg       0.95      0.95      0.95        46
 weighted avg       0.96      0.96      0.96        46

J48

A continuación te muestro el código para implementar no el J48 (que no está en la librería), sino el DecisionTree, que es parecido.

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn import tree
import matplotlib.pyplot as plt

# Cargar el dataset Iris
iris = load_iris()
X = iris.data
y = iris.target

# Dividir el conjunto de datos en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)


# Crear el modelo con múltiples opciones
clf = DecisionTreeClassifier(criterion='entropy', max_depth=3, min_samples_split=5)

# Entrenar el modelo
clf.fit(X_train, y_train)

# Visualizar el árbol
plt.figure(figsize=(12,8))
tree.plot_tree(clf, filled=True, feature_names=iris.feature_names, class_names=iris.target_names)
plt.show()

# Evaluar el modelo
accuracy = clf.score(X_test, y_test)
print(f"Precisión del modelo: {accuracy * 100:.2f}%")

El código nos muestra el árbol de decisión y la precisión del modelo (en general, bastante alta)

Ya sabemos que el dataset iris está muy bien diseñado para realizar este tipo de análisis. Con otros datasets no tendremos tanta precisión. Pero podemos utilizar python para explorar diferentes opciones y quedarnos con la mejor.

En el siguiente código de ejemplo utilizo el dataset wines para intentar encontrar un árbol de decisión, y planteo diferentes modelos (‘giny’ y ‘entropy’) y varias opciones de profundidad para poder evaluar cual es el mejor:

from sklearn.datasets import load_wine
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn import tree
import matplotlib.pyplot as plt

# Cargar el dataset Wine
wine = load_wine()
X = wine.data
y = wine.target

# Dividir el conjunto de datos en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Definir las diferentes opciones a explorar
criterios = ['gini', 'entropy']
max_depths = [2, 3, 4, 5]

# Bucle para probar diferentes combinaciones de parámetros
for criterio in criterios:
    for max_depth in max_depths:
        # Crear y entrenar el modelo con diferentes parámetros
        clf = DecisionTreeClassifier(criterion=criterio, max_depth=max_depth, random_state=42)
        clf.fit(X_train, y_train)

        # Evaluar el modelo
        accuracy = clf.score(X_test, y_test)
        print(
            f"Modelo con criterion='{criterio}' y max_depth={max_depth} tiene una precisión del {accuracy * 100:.2f}%")

Me devuelve el siguiente resultado:

Modelo con criterion=’gini’ y max_depth=2 tiene una precisión del 87.04%
Modelo con criterion=’gini’ y max_depth=3 tiene una precisión del 96.30%
Modelo con criterion=’gini’ y max_depth=4 tiene una precisión del 96.30%
Modelo con criterion=’gini’ y max_depth=5 tiene una precisión del 96.30%
Modelo con criterion=’entropy’ y max_depth=2 tiene una precisión del 88.89%
Modelo con criterion=’entropy’ y max_depth=3 tiene una precisión del 83.33%
Modelo con criterion=’entropy’ y max_depth=4 tiene una precisión del 85.19%
Modelo con criterion=’entropy’ y max_depth=5 tiene una precisión del 85.19%

Podemos ver que el modelo ‘gini’ supera en general al ‘entropy’, y que a partir de una profundidad de 3 no obtenemos una mejora fundamental. Así que podemos quedarnos con esos parámetros.

A continuación te muestro la implementación del NaiveBayes para el dataset wine, con diferentes tamaños de entrenamiento:

from sklearn.datasets import load_wine
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Cargar el dataset Wine
wine = load_wine()
X = wine.data
y = wine.target

# Definir diferentes proporciones de datos de prueba
test_sizes = [0.1, 0.2, 0.3, 0.4]

for test_size in test_sizes:
    # Dividir los datos con diferentes proporciones de prueba
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size)

    # Crear y entrenar el modelo
    gnb = GaussianNB()
    gnb.fit(X_train, y_train)

    # Predecir en el conjunto de prueba
    y_pred = gnb.predict(X_test)

    # Evaluar el modelo
    accuracy = accuracy_score(y_test, y_pred)
    print(f"Precisión del modelo con test_size={test_size}: {accuracy * 100:.2f}%")