A IA está rapidamente se tornando um recurso incrível, tendo alcançado níveis sobre-humanos de desempenho em domínios como reconhecimento de imagem, Go e até pôquer. Muitos estão entusiasmados 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 Perigo! Desafio IBM , 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 americanas : “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 respondidas , “O que é Toronto ?????” - os pontos de interrogação extras (e baixa aposta) indicando sua dúvida .

Portanto, embora a IA tenha a capacidade de desempenho de contos de fadas por longos períodos - meses, anos, décadas até mesmo - há sempre essa possibilidade irritante de que, de repente, ele irá errar misteriosamente.

O mais preocupante para nós, humanos, não é que a IA cometa um erro, mas o quão “ilógico” o erro será. No caso de Watson, alguém que não sabe a resposta para a pergunta 'logicamente' tentaria pelo menos adivinhar uma grande cidade dos EUA. Acredito que esta seja uma das principais razões pelas quais ainda não temos a adoção pública de carros autônomos: mesmo que os 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.

quem paga mais uber ou lyft 2016

Isso me fez pensar: o modelo de IA certo poderia resolver 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? Tal IA seria capaz de mudar o curso da tecnologia e nos permitir os benefícios de conto de fadas da IA ​​...

Acredito que a resposta a essas perguntas seja sim. Acredito que erros como o de Watson podem ser evitados com o uso de modelos aprimorados e mais restritos logicamente, cujos primeiros protótipos são chamados 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, já que a detecção até mesmo da menor quantidade de 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 para ataques adversários e situações inesperadas.
• O desempenho do 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 de aprendizado de máquina monotônicos são o primeiro passo nesta jornada emocionante. Modelos monotônicos tornam a IA mais “lógica”.

Nota do editor: os leitores que procuram dar o primeiro passo para entender os fundamentos do ML são incentivados a ler nosso artigo introdutório sobre 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 tem algum conjunto de recursos ( características monotônicas ) cujo aumento sempre leva o modelo a aumentar seu produto.

Tecnicamente ...

... há dois lugares onde a definição acima é imprecisa.

Primeiro, os recursos aqui são monotônicos crescente . Também podemos ter recursos monotonicamente decrescentes, cujo aumento sempre leva a uma diminuição no modelo. Os dois podem ser convertidos um no outro simplesmente por negação (multiplicando por -1).

Em segundo lugar, quando dizemos que a produção aumenta, não queremos dizer que é estritamente aumentando - queremos dizer que não diminui , porque a saída pode permanecer a mesma.

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 crédito melhor.
• 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 essas relações lógicas sejam claras o suficiente, para um modelo de ML que interpola usando dados limitados e nenhum conhecimento de domínio, elas podem não ser. Na verdade, o modelo pode interpolar eles incorretamente, resultando em previsões ridículas e malucas. Aprendizado de máquina modelos que Faz capturar esse conhecimento tem melhor desempenho na prática (evitando 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 alunos.

Um lugar onde os modelos de IA monotônicos realmente brilham é na robustez adversária. 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 escapar do modelo de IA monotônico porque eles são incapazes de alterar o rótulo do exemplo em relação ao modelo de IA monotônico.

Casos de uso para modelos de IA monotônicos

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

Caso de uso 1: detecção de malware

Um dos casos de uso mais legais para modelos de IA monotônicos deve ser seu 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 personificaram empresas legítimas e registradas para fraudar autoridades de certificação, assinando com sucesso o código digital de seu malware com certificados confiáveis. Um classificador de malware ingênuo provavelmente usará a assinatura de código como um recurso e indicaria que esses exemplos são benignos.

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

No meu curso, Aprendizado de máquina para 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 ingênuos de ML. Os modelos monotônicos são resistentes a esse ataque e forçam os atores mal-intencionados a trabalhar muito mais arduamente se quiserem escapar do classificador.

Caso de uso 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 a ser usado aqui, porque um fórum que contém conteúdo impróprio também pode conter muito conteúdo aceitável.

o que é uma corporação s ou c

Um classificador ingênuo pode pesar a presença de recursos “apropriados” em comparação com a presença de recursos “inadequados”. Mas isso não funcionará, pois não queremos que nossos filhos acessem conteúdo impróprio, mesmo que seja 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. Veja também 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 de IA monotônico deve ser usado neste cenário.

Caso de uso 4: Mecanismos de recomendação

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

Caso de uso 5: filtragem de spam e phishing

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

Implementação e Demonstração

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

Tutorial Monotonic ML XGBoost

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

O seguinte tutorial de demonstração do XGBoost sobre como usar modelos de ML monotônicos tem um Repo Python que 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 do malware, “assinatura de código” e “autores reconhecidos. ”

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

c corporação diferença da corporação

Vamos modelar a situação por meio de um modelo generativo. Geramos um grande número de pontos de dados aleatoriamente, cerca de 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á uma tendência mais alta para os recursos benignos, enquanto um ponto de dados “malicioso” terá uma tendência mais alta 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, prosseguiremos para 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 as amostras benignas geralmente têm maior peso nos primeiros recursos, enquanto as amostras maliciosas geralmente têm maior peso nos últimos recursos.

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

como a cor afeta as pessoas

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)

Olhando para os resultados, podemos ver que não há overfitting significativo. Iremos comparar esses resultados aos 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_Eu é -1, 0 ou 1, dependendo se queremos o recurso Eu para ser 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)

É 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 “empacotar” seus recursos benignos, definindo-os todos como 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 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 de IA monotônico era cerca de 2.500 vezes mais robusto para ataques adversários .

LightGBM

A sintaxe para usar recursos monotônicos no LightGBM É similar .

TensorFlow Lattice

O TensorFlow Lattice é outra estrutura para lidar com as restrições de monotonicidade e é um conjunto de TensorFlow Estimators e também de operadores TensorFlow para construir seus próprios modelos de rede. Os reticulados são tabelas de consulta interpoladas multidimensionais, o que significa que são pontos uniformemente distribuídos no espaço (como uma grade), junto com os valores das funções nesses pontos. De acordo com the Google AI Blog :

“... 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 ressaltar que, como eles interpola 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 falsas 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 de ataques maliciosos até a oferta de recomendações lógicas e úteis de restaurantes, os modelos de IA monotônicos provaram ser um grande benefício para a sociedade e uma ferramenta maravilhosa para dominar. Modelos monotônicos estão aqui para nos conduzir a uma nova era de segurança, sutileza e compreensão em IA. E então eu digo, aqui está os modelos de IA monotônicos, aqui está o progresso.

Compreender o básico

O que é uma série monotônica?

Uma série monotônica é aquela que aumenta ou diminui monotonicamente. Uma série está aumentando monotonicamente se seus termos estão sempre aumentando. Uma série é monotonicamente decrescente se seus termos estão sempre diminuindo.

O que significa uma função ser monotônica?

Uma função é monotônica se for monotônica crescente ou monotônica decrescente. Uma função f (x) é monotônica crescente se y> x implica que f (y)> f (x). É monotônico decrescente se y> x implica que f (y)

orçamento de capital é o processo de:

O que é um modelo de ML?

Um modelo de aprendizado de máquina (ML) é um algoritmo matemático que aprende a partir de um conjunto de dados de entrada ('dados de treinamento') para fazer previsões sobre novos dados sem ser explicitamente programado para fazê-lo.

O que é monotonicidade em inteligência artificial?

Monotonicidade em inteligência artificial (IA) pode se referir à classificação monotônica ou raciocínio monotônico. A classificação monotônica é uma propriedade matemática de um modelo de IA intimamente relacionada ao conceito de função monotônica. O raciocínio monotônico é uma forma de raciocínio que pode ser a base da lógica do sistema de IA.

O que é um modelo XGBoost?

O XGBoost é uma implementação amplamente usada do algoritmo de aprendizado de máquina conhecido como 'aumento de gradiente'. Alcançou a fama por meio do desempenho superior em muitas competições de aprendizado de máquina, além de ganhar vários prêmios. O XGBoost está disponível em Python, R, C ++, Java, Julia, Perl e Scala.

Para que serve o XGBoost?

O XGBoost é normalmente preciso e confiável em conjuntos de dados tabulares de tamanho médio (100k-1m).