Modelos de lógica sonora e IA monotônica

A IA está rapidamente se tornando um ativo incrível, tendo alcançado níveis de desempenho sobre-humanos em domínios como reconhecimento de imagem, Go e até poker. Muitos estão animados com o futuro da IA ​​e da humanidade. Ao mesmo tempo, há uma sensação geral de que a IA sofre de uma falha incômoda: a IA em seu estado atual pode ser imprevisivelmente não confiável.

O exemplo clássico é o Jeopardy! IBM Challenge , durante o qual Watson, o IBM AI, limpou a placa com facilidade, apenas para perder o “Final Jeopardy!” questão, que estava na categoria de Cidades dos EUA : “Seu maior aeroporto tem o nome de um herói da Segunda Guerra Mundial; seu segundo maior para uma batalha da Segunda Guerra Mundial.” Watson respondeu: “O que é Toronto?????” – os pontos de interrogação extras (e aposta baixa) indicando sua dúvida.

Portanto, embora a IA tenha a capacidade de desempenho semelhante a um conto de fadas por grandes períodos de tempo – meses, anos, até décadas – há sempre essa possibilidade incômoda de que, de repente, ela irá misteriosamente errar.

O mais preocupante para nós, humanos, não é que a IA cometa um erro, mas quão “ilógico” o erro será. No caso de Watson, alguém que não sabe a resposta para a pergunta tentaria “logicamente” pelo menos adivinhar uma grande cidade dos EUA. Acredito que essa seja uma das principais razões pelas quais ainda não temos adoção pública de carros autônomos: mesmo que carros autônomos possam ser estatisticamente mais seguros, tememos que sua IA subjacente possa inesperadamente errar em um sentido semelhante ao Watson , mas com repercussões muito mais graves.

Isso me fez pensar, o modelo de IA correto poderia corrigir esse problema? A IA certa poderia ter a capacidade de tomar decisões acertadas em momentos críticos, mesmo quando não tem todas as respostas? Essa IA seria capaz de mudar o curso da tecnologia e nos permitir os benefícios de contos de fadas da IA…

Acredito que a resposta para essas perguntas seja sim. Acredito que erros como o de Watson podem ser evitados com o uso de modelos aprimorados e mais logicamente restritos, cujos primeiros protótipos são chamados de modelos monotônicos de aprendizado de máquina . Sem entrar em detalhes ainda, com o modelo de IA monotônico adequado:

• Um carro autônomo seria mais seguro, pois a detecção do menor sinal humano sempre seria suficiente para ativar um protocolo de segurança mesmo na presença de uma grande quantidade de outro sinal.
• Os sistemas de aprendizado de máquina (ML) seriam mais robustos a ataques adversários e situações inesperadas.
• O desempenho de ML seria mais lógico e humanamente compreensível.

Acredito que estamos passando de uma era de grande crescimento no poder computacional e algorítmico da IA ​​para uma era de sutileza, eficácia e compreensão em IA, e os modelos monotônicos de aprendizado de máquina são o primeiro passo nessa emocionante jornada. Modelos monotônicos tornam a IA mais “lógica”.

Nota do editor: os leitores que desejam dar o primeiro passo para entender os fundamentos do ML são incentivados a ler nosso artigo introdutório sobre o ML.

A teoria dos modelos monotônicos de IA

Então, o que é um modelo monotônico? Falando livremente, um modelo monotônico é um modelo de ML que possui algum conjunto de recursos ( recursos monotônicos ) cujo aumento sempre leva o modelo a aumentar sua saída.

Na vida real, muitos pares de variáveis ​​exibem relações monotônicas. Por exemplo:

• O preço do gás para uma viagem está aumentando monotonicamente na distância percorrida.
• A probabilidade de receber um empréstimo é maior com melhor crédito.
• O tempo de condução esperado aumenta com a quantidade de tráfego.
• A receita aumenta com a taxa de cliques em um anúncio.

Embora esses relacionamentos lógicos sejam suficientemente claros, para um modelo de ML que está interpolando usando dados limitados e nenhum conhecimento de domínio, eles podem não ser. Na verdade, o modelo pode interpolá-los incorretamente, resultando em previsões ridículas e malucas. Os modelos de aprendizado de máquina que capturam esse conhecimento têm melhor desempenho na prática (evitando o overfitting), são mais fáceis de depurar e são mais interpretáveis. Na maioria dos casos de uso, o modelo monotônico deve ser usado em conjunto com um modelo comum, como parte de um conjunto de aprendizes.

Um lugar onde os modelos monotônicos de IA realmente brilham é na robustez do adversário. Os modelos monotônicos são modelos de aprendizado de máquina “reforçados”, o que significa que são resistentes a ataques adversários. Os invasores que são capazes de manipular apenas recursos não monotônicos são incapazes de evitar o modelo monotônico de IA porque não conseguem alterar o rótulo do exemplo em relação ao modelo monotônico de IA.

Casos de uso para modelos monotônicos de IA

Até agora, essa discussão tem sido inteiramente teórica. Vamos discutir alguns casos de uso da vida real.

Caso de uso nº 1: detecção de malware

Um dos casos de uso mais legais para modelos monotônicos de IA deve ser o uso na detecção de malware. Implementado como parte do Windows Defender, um modelo monotônico está presente em todos os dispositivos Windows atualizados, protegendo silenciosamente os usuários contra malware.

Em um cenário, os autores de malware fingiram ser empresas legítimas e registradas para fraudar autoridades de certificação, assinando com sucesso digitalmente seu malware com certificados confiáveis. Um classificador de malware ingênuo provavelmente usaria a assinatura de código como um recurso e indicaria que tais amostras são benignas.

Mas não é assim no caso do modelo monotônico de IA do Windows Defender, cujos recursos monotônicos são apenas os recursos que indicam malware. Não importa o quanto os autores de malware de conteúdo “benigno” injetam em seu malware, o modelo monotônico de IA do Windows Defender continuaria a capturar a amostra e defender os usuários contra danos.

No meu curso, Machine Learning for Red Team Hackers, ensino várias técnicas para evitar classificadores de malware baseados em ML. Uma das técnicas consiste em encher uma amostra maliciosa com conteúdo/recursos “benignos” para evitar modelos de ML ingênuos. Os modelos monotônicos são resistentes a esse ataque e forçam os agentes mal-intencionados a trabalhar muito mais se quiserem ter alguma esperança de escapar do classificador.

Caso de uso nº 2: filtragem de conteúdo

Suponha que uma equipe esteja construindo um filtro de conteúdo de navegação na web para bibliotecas escolares. Um modelo de IA monotônico é um ótimo candidato para usar aqui porque um fórum que contém conteúdo impróprio também pode conter muito conteúdo aceitável.

Um classificador ingênuo pode pesar a presença de características “apropriadas” contra a presença de características “inadequadas”. Mas isso não funcionará, pois não queremos que nossos filhos acessem conteúdo impróprio, mesmo que represente apenas uma pequena fração do conteúdo.

Caso de uso nº 3: IA de carro autônomo

Imagine construir um algoritmo de carro autônomo. Ele olha para uma imagem e vê uma luz verde. Ele também vê um pedestre. Deve pesar o sinal de cada um contra o outro? Absolutamente não. A presença de um pedestre é suficiente para tomar a decisão de parar o carro. A presença de pedestres deve ser vista como uma característica monotônica, e um modelo monotônico de IA deve ser usado neste cenário.

Caso de uso nº 4: mecanismos de recomendação

Os mecanismos de recomendação são um ótimo caso de uso para modelos monotônicos de IA. Em geral, eles podem ter muitas entradas sobre cada produto: classificação por estrelas, preço, número de avaliações etc. Com todas as outras entradas iguais, como avaliações por estrelas e preço, preferimos o produto com maior número de avaliações. Podemos aplicar essa lógica usando um modelo monotônico de IA.

Caso de uso nº 5: filtragem de spam e phishing

Este caso de uso é semelhante ao caso de uso de detecção de malware. Usuários maliciosos podem injetar seus e-mails de spam ou phishing com termos aparentemente benignos para enganar os filtros de spam. Um modelo monotônico de IA será imune a isso.

Implementação e Demonstração

Quando se trata de implementações disponíveis gratuitamente de modelos monotônicos de IA, três se destacam como os mais suportados: XGBoost, LightGBM e TensorFlow Lattice.

Tutorial monotônico de ML XGBoost

O XGBoost é considerado um dos algoritmos de melhor desempenho em dados estruturados, com base em anos de pesquisa empírica e competição. Além disso, a monotonicidade foi implementada no XGBoost.

O tutorial XGBoost de demonstração a seguir sobre como usar modelos monotônicos de ML tem um repositório Python que o acompanha.

Comece importando algumas bibliotecas:

 import random import numpy as np import matplotlib.pyplot as plt %matplotlib inline from sklearn.metrics import confusion_matrix import seaborn as sns sns.set(font_scale=1.4)

O cenário que vamos modelar é uma filtragem de conteúdo ou banco de dados de malware. Teremos alguns benign_features , que modelam, por exemplo, a quantidade de conteúdo relacionado a “ciência”, “história” e “esportes” ou, no caso de malware, “assinatura de código” e “autores reconhecidos”.

Além disso, teremos malicious_features , que modelam, por exemplo, a quantidade de conteúdo relacionado a “violência” e “drogas”, ou no caso de malware, “o número de vezes que são feitas chamadas para bibliotecas de criptografia” e “uma medida numérica de similaridade com uma família de malware conhecida.”

Vamos modelar a situação através de um modelo generativo. Geramos um grande número de pontos de dados aleatoriamente, metade benignos e metade maliciosos, usando a função:

 def flip(): """Simulates a coin flip.""" return 1 if random.random() < 0.5 else 0

Cada ponto de dados irá gerar aleatoriamente seus recursos. Um ponto de dados “benigno” terá um viés maior para os recursos benignos, enquanto um ponto de dados “malicioso” terá um viés maior para os recursos maliciosos.

Usaremos uma distribuição triangular, assim:

 bins = [0.1 * i for i in range(12)] plt.hist([random.triangular(0, 1, 1) for i in range(50000)], bins) 

Usaremos esta função para capturar a lógica acima:

 def generate(): """Samples from the triangular distribution.""" return random.triangular(0, 1, 1)

Em seguida, continuaremos a criar nosso conjunto de dados:

 m = 100000 benign_features = 5 malicious_features = 5 n = benign_features + malicious_features benign = 0 malicious = 1 X = np.zeros((m, n)) y = np.zeros((m)) for i in range(m): vec = np.zeros((n)) y[i] = flip() if y[i] == benign: for j in range(benign_features): vec[j] = generate() for j in range(malicious_features): vec[j + benign_features] = 1 - generate() else: for j in range(benign_features): vec[j] = 1 - generate() for j in range(malicious_features): vec[j + benign_features] = generate() X[i, :] = vec

X contém os vetores de recursos gerados aleatoriamente, enquanto y contém os rótulos. Este problema de classificação não é trivial.

Você pode ver que amostras benignas geralmente têm maior peso nos primeiros recursos, enquanto amostras maliciosas geralmente têm maior peso nos últimos recursos.

Com os dados prontos, vamos realizar uma divisão simples de treinamento-teste:

 from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

Usaremos uma função para preparar os dados para uso com nosso tutorial XGBoost:

 import xgboost as xgb def prepare_for_XGBoost(X, y): """Converts a numpy X and y dataset into a DMatrix for XGBoost.""" return xgb.DMatrix(X, label=y) dtrain = prepare_for_XGBoost(X_train, y_train) dtest = prepare_for_XGBoost(X_test, y_test) dall = prepare_for_XGBoost(X, y)

Agora, vamos treinar e testar um modelo XGBoost simples (não monotônico) nos dados. Em seguida, imprimiremos a matriz de confusão para ver uma divisão numérica dos exemplos positivos rotulados corretamente, exemplos negativos rotulados corretamente, exemplos positivos rotulados incorretamente e exemplos negativos rotulados incorretamente.

 params = {"n_jobs": -1, "tree_method": "hist"} model_no_constraints = xgb.train(params=params, dtrain=dtrain) CM = predict_with_XGBoost_and_return_confusion_matrix( model_no_constraints, dtrain, y_train ) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Unconstrained model's training confusion matrix") plt.show() print() CM = predict_with_XGBoost_and_return_confusion_matrix( model_no_constraints, dtest, y_test ) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Unconstrained model's testing confusion matrix") plt.show() model_no_constraints = xgb.train(params=params, dtrain=dall) 

Observando os resultados, podemos ver que não há overfitting significativo. Vamos comparar esses resultados com os dos modelos monotônicos.

Para isso, vamos treinar e testar um modelo XGBoost monotônico. A sintaxe na qual passamos as restrições monótonas é uma sequência ( f ₀ , f ₁ , …, f _N ), onde cada f _i é um de -1, 0 ou 1, dependendo se queremos que o traço i seja monotonicamente decrescente, irrestrito ou monotonicamente crescente, respectivamente. No caso em questão, especificamos os recursos maliciosos para serem crescentes monotônicos.

 params_constrained = params.copy() monotone_constraints = ( "(" + ",".join([str(0) for m in range(benign_features)]) + "," + ",".join([str(1) for m in range(malicious_features)]) + ")" ) print("Monotone constraints enforced are:") print(monotone_constraints) params_constrained["monotone_constraints"] = monotone_constraints model_monotonic = xgb.train(params=params_constrained, dtrain=dtrain) CM = predict_with_XGBoost_and_return_confusion_matrix(model_monotonic, dtrain, y_train) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Monotonic model's training confusion matrix") plt.show() print() CM = predict_with_XGBoost_and_return_confusion_matrix(model_monotonic, dtest, y_test) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Monotonic model's testing confusion matrix") plt.show() model_monotonic = xgb.train(params=params_constrained, dtrain=dall) 

Fica claro que o desempenho do modelo monotônico é o mesmo do modelo irrestrito.

Agora, vamos criar um conjunto de dados adversário. Vamos pegar todas as amostras maliciosas e “rechear” seus recursos benignos, definindo-os todos para 1. Veremos então como os dois modelos funcionam lado a lado.

 X_adversarial = X[y == malicious] y_adversarial = len(X_adversarial) * [malicious] for i in range(len(X_adversarial)): vec = X_adversarial[i, :] for j in range(benign_features): vec[j] = 1 X_adversarial[i, :] = vec

Vamos convertê-los em um formulário a ser ingerido pelo XGBoost:

 dadv = prepare_for_XGBoost(X_adversarial, y_adversarial)

Para a etapa final do nosso tutorial do XGBoost, testaremos os dois tipos de modelo de aprendizado de máquina:

 CM = predict_with_XGBoost_and_return_confusion_matrix( model_no_constraints, dadv, y_adversarial ) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Unconstrained model's confusion matrix on adversarial dataset") plt.show()

 CM = predict_with_XGBoost_and_return_confusion_matrix( model_monotonic, dadv, y_adversarial ) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Monotonic model's confusion matrix on adversarial dataset") plt.show() 

Como você pode ver, o modelo monotônico de IA era cerca de 2.500 vezes mais robusto a ataques adversários.

Light GBM

A sintaxe para usar recursos monotônicos no LightGBM é semelhante.

TensorFlow Lattice

O TensorFlow Lattice é outra estrutura para lidar com restrições de monotonicidade e é um conjunto de estimadores do TensorFlow pré-construídos, bem como operadores do TensorFlow para criar seus próprios modelos de treliça. As treliças são tabelas de consulta interpoladas multidimensionais, o que significa que são pontos distribuídos uniformemente no espaço (como uma grade), juntamente com os valores das funções nesses pontos. De acordo com o blog de IA do Google:

“… os valores da tabela de consulta são treinados para minimizar a perda nos exemplos de treinamento, mas, além disso, os valores adjacentes na tabela de consulta são restritos a aumentar ao longo de determinadas direções do espaço de entrada, o que faz com que as saídas do modelo aumentem em essas direções. Importante, porque eles interpolam entre os valores da tabela de consulta, os modelos de rede são suaves e as previsões são limitadas, o que ajuda a evitar previsões espúrias grandes ou pequenas no tempo de teste.”

Tutoriais sobre como usar o TensorFlow Lattice podem ser encontrados aqui.

Modelos monotônicos de IA e o futuro

Desde a defesa de dispositivos contra ataques maliciosos até a oferta de recomendações lógicas e úteis para restaurantes, os modelos monotônicos de IA provaram ser um grande benefício para a sociedade e uma ferramenta maravilhosa para dominar. Modelos monotônicos estão aqui para nos levar a uma nova era de segurança, sutileza e compreensão em IA. E então eu digo, um brinde aos modelos monotônicos de IA, um brinde ao progresso.