Estás leyendo la publicación: ¿Cómo explicar los modelos de ML y la importancia de las características con LIME?
Para mantener la confiabilidad de los modelos de aprendizaje automático, necesitamos mejorar su explicabilidad e interpretación. Debería haber una razón adecuada que podamos dar mientras el modelo hace las predicciones. Varias herramientas nos ayudan a hacer que el procedimiento de modelado sea más explicable e interpretable. LIME también es una herramienta o paquete similar que da la razón detrás de las predicciones basadas en los datos. En este artículo, vamos a discutir el paquete LIME y cómo podemos implementarlo en nuestros proyectos. Aprenderemos a explicar la importancia de las funciones en el aprendizaje automático con la ayuda de este artículo. Los puntos principales que se discutirán en el artículo se enumeran a continuación.
Tabla de contenido
- ¿Qué es LIMA?
- Implementación con cal
- Preparación de datos
- Ajuste del modelo
- Interpretación del modelo
- Explicación de características
Empecemos por entender qué es LIME.
¿Qué es LIMA?
LIME es un paquete de código abierto que nos permite explicar la naturaleza de los modelos mediante la visualización. La palabra LIME significa explicaciones locales interpretables independientes del modelo, lo que significa que este paquete explica los valores locales basados en el modelo. Este paquete es capaz de admitir modelos tabulares, modelos NLP y clasificadores de imágenes. Con este paquete, podemos explicar fácilmente la respuesta de por qué el modelo predice un valor.
La forma en que este paquete explica los resultados del modelo es que indica qué características son responsables de generar un resultado. Nos informa sobre la fuerza del resultado, qué características son importantes para obtener resultados y qué valores se le han dado al modelo para predecir el resultado. Podemos instalar este paquete en nuestro entorno usando las siguientes líneas de códigos.
!pip instalar cal
Después de la instalación de Lime en el entorno, estamos listos para usar este paquete para hacer que nuestros modelos sean más interpretables. Comencemos con la implementación.
¿Está buscando un repositorio completo de bibliotecas de Python utilizadas en ciencia de datos? echa un vistazo aquí.
Implementación de cal
En este artículo, vamos a utilizar el modelo de perceptrón multicapa de la biblioteca sklearn y los datos del iris que se pueden encontrar aquí. Empecemos por importar algunas bibliotecas y datos importantes.
Preparación de datos
importar numpy como np importar pandas como pd importar seaborn como sns desde sklearn.model_selection importar train_test_split desde sklearn importar métricas
Importemos los datos
datos = pd.read_csv(‘/content/Iris.csv’) datos.head()
Producción:
Aquí podemos ver algunos de los valores de nuestro conjunto de datos. Solo visualicemos los datos para comprender las perspectivas de los datos. Primero, trazaremos la correlación:
corr = data.corr() sns.heatmap(corr, xticklabels=corr.columns.values, yticklabels=corr.columns.values)
Producción:
En el resultado anterior, podemos ver la correlación entre las características de los datos. Obtengamos un gráfico de pares:
sns.pairplot( data=data, vars=(‘SepalLengthCm’,’SepalWidthCm’,’PetalLengthCm’,’PetalWidthCm’), hue=”Especies” )
Producción:
Aquí podemos ver las relaciones entre las características más claramente. Normalicemos los datos:
df_norm = datos[[‘SepalLengthCm’, ‘SepalWidthCm’, ‘PetalLengthCm’, ‘PetalWidthCm’]].apply(lambda x: (x – x.min()) / (x.max() – x.min())) df_norm.sample(n=5)
Producción:
En lo anterior, hemos separado los datos de destino de las características. Para modelar los datos, debemos proporcionar etiquetas numéricas a las clases presentadas en la variable de destino.
objetivo = datos[[‘Species’]].reemplazar([‘Iris-setosa’,’Iris-versicolor’,’Iris-virginica’],[0,1,2]) objetivo.muestra(5)
Producción:
Después de normalizar y etiquetar el objetivo y las características, concatenémoslos nuevamente.
df = pd.concat([df_norm, target]eje=1)
Dividamos los datos
tren, prueba = tren_prueba_dividir(df, tamaño_prueba = 0.3) trenX = tren[[‘SepalLengthCm’,’SepalWidthCm’,’PetalLengthCm’,’PetalWidthCm’]]trenY=tren.Especies testX= prueba[[‘SepalLengthCm’,’SepalWidthCm’,’PetalLengthCm’,’PetalWidthCm’]]pruebaY =prueba.Especies
Después de toda la preparación, estamos listos para modelar los datos utilizando un clasificador de perceptrón multicapa. Definamos el modelo.
Ajuste del modelo
de sklearn.neural_network import MLPClassifier clf = MLPClassifier(solver=”lbfgs”, alpha=1e-5, hidden_layer_sizes=(3, 3), random_state=1)
Ajuste del modelo con datos de entrenamiento
clf.fit(trenX, trenY)
Producción:
Después de luchar contra el modelo, estamos listos para verificar la precisión del modelo.
print(‘La precisión del perceptrón multicapa es:’,metrics.accuracy_score(prediction,testY))
Producción:
Echemos un vistazo a cuáles son las predicciones del modelo.
imprimir (predicción)
Producción:
Aquí hemos completado nuestro procedimiento de modelado y ahora estamos listos para hacer que este procedimiento sea interpretable usando la biblioteca LIME.
Interpretación del modelo
Dado que estamos usando datos tabulares aquí, debemos definir un objeto explicativo tabular usando la biblioteca lime. Este objeto esperará proporcionar valores en los siguientes parámetros:
- Datos de entrenamiento: Simplemente solicita los datos con los que hemos entrenado el modelo en el formato de matriz NumPy.
- nombres_de_funciones: Nombre de las columnas que se le han proporcionado al modelo durante el entrenamiento.
- nombre de la clase: Nombre de las clases en la variable objetivo si estamos construyendo un modelo de clasificación/
- modo: El tipo de modelo que estamos construyendo, aquí tenemos que construir un modelo MLP para la clasificación.
Definamos el objeto.
import lime from lime import lime_tabular Explainer = lime_tabular.LimeTabularExplainer( training_data=np.array(trainX), feature_names=trainX.columns, class_names=[‘Iris-setosa’,’Iris-versicolor’,’Iris-virginica’]modo=”clasificación” )
hagamos que el explicador interprete el modelo en función de los valores disponibles en el conjunto de prueba.
exp = explicador.explicar_instancia(fila_datos=pruebaX.iloc[1]predict_fn=clf.predict_proba ) exp.show_in_notebook(show_table=True)
Producción:
Aquí, en lo anterior, le hemos dicho al explicador que explique la predicción del modelo en la segunda fila de los datos de prueba. Y podemos ver que el modelo está explicando la predicción es Iris_versicolor y en el medio, podemos ver que el gráfico dice la razón por la cual esta muestra es iris_versicolor. Al final tenemos una tabla que informa sobre el valor en los datos de prueba y también dice que los valores en naranja son la razón de la predicción final y los valores en azul no respaldan el resultado.
Busquemos cualquier otra fila de los datos de texto.
exp = explicador.explicar_instancia(fila_datos=pruebaX.iloc[5]predict_fn=clf.predict_proba ) exp.show_in_notebook(show_table=True)
Producción:
En lo anterior, podemos ver que el explicador dice que hay un 100% de probabilidad de que la muestra sea Iris_virginica y cuales son las razones para no ser el Iris_versicolor.
Ultimas palabras
En el artículo, hemos discutido qué es LIME y hemos visto una implementación usando los datos del iris y el clasificador MLP. En las etapas finales, hemos discutido qué y por qué el modelo predice algo utilizando el explicador tabular de LIME.
