Como criar confiança nas previsões do seu modelo de aprendizado de máquina com LIME


Este artigo é um guia passo a passo que ajudará você a interpretar as previsões do seu modelo de aprendizado de máquina usando LIME. Mesmo quando seu modelo atinge quase 100% de precisão, sempre existe uma pergunta em sua mente: devemos confiar nisso?

Considere uma situação no consultório médico – um médico confiaria em um computador se ele apenas mostrasse um diagnóstico sem fornecer qualquer razão válida por trás dele?

Qualquer modelo que não explique o motivo por trás de sua produção é considerado uma caixa preta. E confiar nesse modelo não é a abordagem correta.

Digamos que recebamos um modelo que prevê se um animal é um cachorro ou gato e tem 100% de precisão. Mas e se ele predizer com base no plano de fundo da imagem? Você confiaria nesse modelo?

Como você pode ver na figura acima, a cor verde representa os recursos necessários para identificar a imagem como um gato e o vermelho indica os recursos necessários para representá-la como um cachorro.

Se nosso modelo fornecer uma razão válida para sua previsão, ele cria nossa confiança para esse modelo. Da mesma forma, para a situação do médico, se o modelo pode dizer quais recursos eram importantes em sua previsão e para quais sintomas deu mais peso, é mais fácil para o médico confiar nesse modelo.

Mas é simples assim interpretar qualquer modelo? Felizmente sim. Marco Tulio Ribeiro, Sameer Singh e Carlos Guestrin publicaram um artigo chamado “Por que devo confiar em você?”: Explicando as previsões de qualquer classificador em 2016.

Nele, eles propuseram sua técnica LIME. A abordagem básica dessa técnica foi interpretar facilmente qualquer modelo, aprendendo-o localmente em torno de sua previsão.

Eles escreveram este artigo para entender as explicações por trás da previsão de qualquer modelo. Portanto, sempre que você precisar escolher um modelo, poderá usar as informações do LIME.

Explicando previsões individuais usando LIME fonte

No diagrama acima, o modelo prevê que um paciente está com gripe e o LIME destaca os sintomas no histórico do paciente que levaram à previsão.

Espirro e dor de cabeça contribuem para a previsão da “gripe”, enquanto “sem fadiga” é uma evidência contra ela. Com essas informações, um médico pode tomar uma decisão informada sobre a confiança na previsão do modelo.

Então, o que exatamente é LIME?

O LIME é independente de modelo, o que significa que pode ser aplicado a qualquer modelo de aprendizado de máquina. O objetivo do LIME é identificar um modelo interpretável sobre a representação interpretável localmente fiel ao classificador. – Definição de documento oficial (ligação)

Para entender isso, precisamos entender o significado da sigla LIME.

Local: refere-se a como obtemos essas explicações. O LIME aproxima o modelo de caixa preta localmente na vizinhança das previsões.

Interpretável: as explicações fornecidas pelo LIME são simples o suficiente para os seres humanos entenderem.

Agnóstico ao modelo: significa que o LIME trata o modelo como uma caixa preta e, portanto, funciona para qualquer modelo.

Explicações: as justificativas dadas para as ações executadas pelo modelo.

LIME fornece interpretabilidade do modelo local. Ele modifica uma única amostra de dados, ajustando os valores dos recursos e observando o impacto resultante na saída.

Com LIME, podemos explicar por que o RandomForestClassifier pensa antes de fornecer uma previsão.

Vamos dar uma olhada em algum código

Começaremos usando o modelo RandomForestClassifier para trabalhar no conjunto de dados “Choveu em Seattle”. Os dados estão disponíveis aqui.

Primeiro, importaremos nossas bibliotecas básicas:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

Para evitar futuros avisos em nosso código, adicionaremos isso ao nosso código no início de nosso script:

import warnings
warnings.filterwarnings('ignore')

Em seguida, importamos algumas bibliotecas do sklearn para dividir o conjunto de dados e definir as métricas. O RandomForestClassifier também será importado da mesma biblioteca.

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import RandomForestClassifier

Como temos todas as nossas bibliotecas necessárias, leremos nossos dados:

df = pd.read_csv('seattleWeather_1948-2017.csv')
df.head()

Portanto, os dados consistem em 4 colunas de recursos e uma coluna de destino, ou seja, RAIN. Nossa tarefa é prever se houve chuva em Seattle.

df.shape

(25551, 5)

Nossos dados consistem em 25.551 linhas, o que é suficiente para o nosso modelo treinar.

Verificaremos os valores ausentes, se houver:

df.isnull().sum()

Como nosso foco principal é interpretar a previsão do modelo, descartamos as linhas de valor ausentes diretamente. Por uma questão de simplicidade, removeremos a coluna DATE também.

df.dropna(inplace=True)
df.pop('DATE')

Agora vamos codificar nossa coluna de destino:

df.RAIN.replace({True:1,False:0},inplace=True)
df.head()

É assim que nossos dados ficam no final.

target = df.pop('RAIN')
x_train , x_test , y_train , y_test = train_test_split(df, target, train_size=0.75)

Agora, dividimos os dados em conjuntos de trens e testes com um trem igual a 75% dos dados originais.

Agora criaremos nosso modelo com parâmetros padrão:

rfc = RandomForestClassifier()

E ajuste o modelo às amostras de treinamento:

rfc.fit(x_train,y_train)

accuracy_score(y_test,rfc.predict(x_test))

1.0

O modelo alcançou 100% de precisão. Mas agora vamos interpretar o modelo para que possamos confiar nele.

LIMA

Primeiro, precisamos discutir um pouco de teoria antes de prosseguirmos.

O LIME cria novos dados que incluem amostras permutadas e suas respectivas previsões.

Nesse sentido, o LIME treina um modelo local que é ponderado pela proximidade de instâncias de amostra. Este modelo pode ser qualquer modelo básico, ou seja, uma árvore de Decisão.

Esse modelo deve ter previsões locais semelhantes às do modelo existente. Essa precisão é chamada fidelidade local.

import lime
from lime import lime_tabular

Nós importamos os pacotes necessários para executar nossa interpretação.

Aqui está a receita para o treinamento de modelos substitutos locais:

  1. Selecione o modelo para o qual deseja obter a explicação de sua previsão
  2. Treine este modelo e obtenha sua previsão para os valores de teste
  3. Para LIME, ponderamos as novas amostras em relação à proximidade com o modelo
  4. Crie um modelo local no conjunto de dados
  5. Finalmente, explicamos a previsão interpretando o modelo local

Defina um modelo LimeTableExplainer. Os parâmetros deste modelo são amostra de treinamento, nomes de recursos e nomes de classe:

explainer = lime_tabular.LimeTabularExplainer(x_train.values,feature_names=['PRCP','TMAX','TMIN'],class_names=['False','True'],discretize_continuous=True)

Precisamos passar amostras de treinamento, nomes de colunas de treinamento e nomes de classes de destino que são esperados.

Em seguida, chamamos a função explan_instance () do explicador que criamos.

Usaremos os seguintes parâmetros desta função – amostra de teste, prever a função do modelo, número de recursos e rótulos principais a serem considerados:

i = np.random.randint(0,x_test.shape[0])
exp = explainer.explain_instance(x_test.iloc[i],rfc.predict_proba,num_features=x_train.shape[1],top_labels=None)

Para exibir a explicação no caderno, é necessário o seguinte código.

exp.show_in_notebook()

Vamos decifrar a saída.

O diagrama superior esquerdo indica a saída prevista com probabilidade.

A saída do modelo é Falso com 100% de probabilidade.

O diagrama superior direito indica as condições necessárias para cair em cada categoria com seus pesos.

Como a condição das variáveis ​​do PRCP para prever o alvo como Falso é PRCP ≤0,00 e tem peso de 0,96.

O diagrama inferior direito indica nossos valores de teste. Como os valores do PRCP satisfazem por um Falso condição, você pode ver a cor azul como pano de fundo para isso.

Para exibir a explicação como uma plotagem:

fig = exp.as_pyplot_figure()

Aqui você pode ver o peso de cada recurso com sua classe prevista (representada pela cor). Eles representam os pesos locais atribuídos a cada recurso. A cor vermelha representa um Falso alvo enquanto a cor verde representa uma Verdade alvo.

Agora é fácil interpretar o modelo observando o peso atribuído a cada recurso, bem como a condição de cada valor de teste que se enquadra na classe específica.

Os valores de PRCP e TMAX indicam que a meta prevista deve ser Falso considerando que o valor de TMIN indica uma Verdade Alvo.

O LIME não é usado apenas para classificação binária de dados tabulares, mas também para maiúsculas e minúsculas, imagens e texto.

O código pode ser encontrado no meu repositório GitHub: https://github.com/Sid11/Lime

E aqui está um link para o repositório oficial do LIME no GitHub: https://github.com/marcotcr/lime

Se você tiver alguma dúvida, entre em contato comigo. Espero que você goste!



Fonte

Leave a Reply

Your email address will not be published. Required fields are marked *