Lógica de sonido y modelos de IA monótona

La IA se está convirtiendo rápidamente en un activo increíble, ya que ha alcanzado niveles de rendimiento sobrehumanos en dominios como el reconocimiento de imágenes, Go e incluso el póquer. Muchos están entusiasmados con el futuro de la IA y la humanidad. Al mismo tiempo, existe la sensación general de que la IA sufre de un defecto molesto: la IA en su estado actual puede ser impredeciblemente poco confiable.

El ejemplo clásico es Jeopardy! IBM Challenge , durante el cual Watson, la IA de IBM, limpió el tablero con facilidad, solo para perderse el "¡Peligro final!" pregunta, que estaba bajo la categoría de Ciudades de EE . UU.: “Su aeropuerto más grande lleva el nombre de un héroe de la Segunda Guerra Mundial; es el segundo más grande para una batalla de la Segunda Guerra Mundial”. Watson respondió: "¿Qué es Toronto?????", Los signos de interrogación adicionales (y la apuesta baja) indican su duda.

Entonces, aunque la IA tiene la capacidad de un rendimiento de cuento de hadas durante largos períodos de tiempo (meses, años, incluso décadas ), siempre existe la molesta posibilidad de que, de repente, cometa un error misterioso.

Lo que más nos preocupa a los humanos no es que la IA cometa un error, sino cuán "ilógico" será el error. En el caso de Watson, alguien que no sabe la respuesta a la pregunta "lógicamente" intentaría al menos adivinar una ciudad importante de los Estados Unidos. Creo que esta es una de las principales razones por las que aún no tenemos la adopción pública de los autos sin conductor: incluso si los autos sin conductor pueden ser estadísticamente más seguros, tememos que su IA subyacente pueda cometer un error inesperado en un sentido similar al de Watson. , pero con repercusiones mucho más graves.

Esto me hizo preguntarme, ¿podría el modelo de IA correcto solucionar este problema? ¿Podría la IA correcta tener la capacidad de tomar decisiones acertadas en momentos críticos, incluso cuando no tenga todas las respuestas? Tal IA sería capaz de cambiar el curso de la tecnología y permitirnos los beneficios de cuento de hadas de la IA...

Creo que la respuesta a estas preguntas es sí. Creo que los errores como el de Watson pueden evitarse con el uso de modelos mejorados y más restringidos lógicamente, cuyos primeros prototipos se denominan modelos monotónicos de aprendizaje automático . Sin entrar en detalles todavía, con el modelo monotónico de IA adecuado:

• Un automóvil autónomo sería más seguro, ya que la detección de incluso la más mínima señal humana siempre sería suficiente para activar un protocolo de seguridad incluso en presencia de una gran cantidad de otra señal.
• Los sistemas de aprendizaje automático (ML) serían más resistentes a los ataques de adversarios y situaciones inesperadas.
• El rendimiento de ML sería más lógico y humanamente comprensible.

Creo que estamos pasando de una era de gran crecimiento en el poder computacional y algorítmico de la IA a una era de delicadeza, efectividad y comprensión en la IA, y los modelos monotónicos de aprendizaje automático son el primer paso en este emocionante viaje. Los modelos monotónicos hacen que la IA sea más "lógica".

Nota del editor: Se recomienda a los lectores que deseen dar su primer paso para comprender los conceptos básicos de ML que lean nuestro artículo introductorio sobre ML.

La teoría de los modelos monotónicos de IA

Entonces, ¿qué es un modelo monótono? En términos generales, un modelo monotónico es un modelo ML que tiene un conjunto de características ( características monotónicas ) cuyo aumento siempre lleva al modelo a aumentar su producción.

En la vida real, muchos pares de variables exhiben relaciones monótonas. Por ejemplo:

• El precio de la gasolina para un viaje aumenta monótonamente en la distancia recorrida.
• La probabilidad de recibir un préstamo es mayor con un mejor crédito.
• El tiempo de conducción esperado aumenta con la cantidad de tráfico.
• Los ingresos aumentan con la tasa de clics en un anuncio.

Aunque estas relaciones lógicas son lo suficientemente claras, para un modelo de ML que interpola utilizando datos limitados y sin conocimiento del dominio, es posible que no lo sean. De hecho, el modelo podría interpolarlos incorrectamente, lo que daría lugar a predicciones ridículas y descabelladas. Los modelos de aprendizaje automático que capturan dicho conocimiento funcionan mejor en la práctica (al evitar el sobreajuste), son más fáciles de depurar y son más interpretables. En la mayoría de los casos de uso, el modelo monotónico debe usarse junto con un modelo ordinario, como parte de un conjunto de alumnos.

Un lugar donde los modelos monotónicos de IA realmente brillan es en la robustez contradictoria. Los modelos monotónicos son modelos de aprendizaje automático "reforzados", lo que significa que son resistentes a los ataques de los adversarios. Los atacantes que solo pueden manipular características no monotónicas no pueden evadir el modelo de IA monotónica porque no pueden alterar la etiqueta del ejemplo con respecto al modelo de IA monotónica.

Casos de uso para modelos de IA monótona

Hasta ahora, esta discusión ha sido completamente teórica. Analicemos algunos casos de uso de la vida real.

Caso de uso #1: Detección de malware

Uno de los mejores casos de uso para los modelos monotónicos de IA tiene que ser su uso en la detección de malware. Implementado como parte de Windows Defender, un modelo monotónico está presente en todos los dispositivos Windows actualizados, protegiendo silenciosamente a los usuarios del malware.

En un escenario, los autores de malware se hicieron pasar por empresas legítimas y registradas para defraudar a las autoridades de certificación, firmando con código digital con éxito su malware con certificados de confianza. Es probable que un clasificador de malware ingenuo use la firma de código como una función e indique que dichas muestras son benignas.

Pero no es así en el caso del modelo de IA monótona de Windows Defender, cuyas características monótonas son solo las características que indican malware. No importa cuánto contenido "benigno" inyecten los autores de malware en su malware, el modelo monotónico de IA de Windows Defender continuaría capturando la muestra y defendiendo a los usuarios de los daños.

En mi curso, Machine Learning for Red Team Hackers, enseño varias técnicas para evadir clasificadores de malware basados ​​en ML. Una de las técnicas consiste en rellenar una muestra maliciosa con contenido/características "benignas" para evadir los modelos ML ingenuos. Los modelos monotónicos son resistentes a este ataque y obligan a los actores maliciosos a trabajar mucho más si quieren tener alguna esperanza de evadir el clasificador.

Caso de uso n.° 2: Filtrado de contenido

Supongamos que un equipo está construyendo un filtro de contenido de navegación web para bibliotecas escolares. Un modelo de IA monótona es un gran candidato para usar aquí porque un foro que contiene contenido inapropiado también puede contener mucho contenido aceptable.

Un clasificador ingenuo podría sopesar la presencia de características "apropiadas" frente a la presencia de características "inapropiadas". Pero eso no funcionará ya que no queremos que nuestros hijos accedan a contenido inapropiado, incluso si representa solo una pequeña fracción del contenido.

Caso de uso n.º 3: IA de automóvil autónomo

Imagine construir un algoritmo de automóvil autónomo. Mira una imagen y ve una luz verde. También ve a un peatón. ¿Debe sopesar la señal de cada uno contra el otro? Absolutamente no. La presencia de un peatón es suficiente para tomar la decisión de detener el automóvil. La presencia de peatones debe verse como una característica monotónica, y en este escenario se debe utilizar un modelo de IA monotónica.

Caso de uso #4: Motores de recomendación

Los motores de recomendación son un excelente caso de uso para los modelos de IA monotónicos. En general, pueden tener muchas entradas sobre cada producto: calificación de estrellas, precio, número de reseñas, etc. Si todas las demás entradas son iguales, como las calificaciones de estrellas y el precio, preferiríamos el producto que tiene una mayor cantidad de reseñas. Podemos hacer cumplir esa lógica usando un modelo monotónico de IA.

Caso de uso n.º 5: Filtrado de spam y phishing

Este caso de uso es similar al caso de uso de detección de malware. Los usuarios maliciosos pueden inyectar sus correos electrónicos no deseados o de phishing con términos aparentemente benignos para engañar a los filtros de correo no deseado. Un modelo de IA monotónico será inmune a eso.

Implementación y Demostración

Cuando se trata de implementaciones disponibles gratuitamente de modelos monotónicos de IA, tres se destacan como los mejor admitidos: XGBoost, LightGBM y TensorFlow Lattice.

Tutorial monotónico de ML XGBoost

XGBoost se considera uno de los algoritmos de mejor rendimiento en datos estructurados, según años de investigación empírica y competencia. Además, se ha implementado la monotonicidad en XGBoost.

El siguiente tutorial de demostración de XGBoost sobre cómo usar modelos monotónicos de ML tiene un repositorio de Python que lo acompaña.

Comience importando algunas 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)

El escenario que vamos a modelar es una base de datos de filtrado de contenido o malware. Tendremos algunas benign_features , que modelan, por ejemplo, la cantidad de contenido relacionado con "ciencia", "historia" y "deportes" o, en el caso del malware, "firma de código" y "autores reconocidos".

Además, tendremos malicious_features , que modelan, por ejemplo, la cantidad de contenido relacionado con “violencia” y “drogas”, o en el caso del malware, “la cantidad de veces que se realizan llamadas a criptobibliotecas” y “una medida numérica de similitud con una familia de malware conocida”.

Modelaremos la situación a través de un modelo generativo. Generamos una gran cantidad de puntos de datos al azar, aproximadamente la mitad benignos y la mitad maliciosos, usando la función:

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

Cada punto de datos generará aleatoriamente sus características. Un punto de datos "benigno" tendrá un mayor sesgo para las funciones benignas, mientras que un punto de datos "malicioso" tendrá un mayor sesgo para las funciones maliciosas.

Usaremos una distribución triangular, así:

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

Usaremos esta función para capturar la lógica anterior:

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

Luego, procederemos a crear nuestro conjunto de datos:

 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 contiene los vectores de características generadas aleatoriamente, mientras que y contiene las etiquetas. Este problema de clasificación no es trivial.

Puede ver que las muestras benignas generalmente tienen mayor peso en las primeras funciones, mientras que las muestras maliciosas generalmente tienen mayor peso en las últimas funciones.

Con los datos listos, realicemos una simple división de entrenamiento y prueba:

 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 una función para preparar los datos para usar con nuestro tutorial de 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)

Ahora, entrenemos y probemos un modelo XGBoost simple (no monótono) en los datos. Luego imprimiremos la matriz de confusión para ver un desglose numérico de los ejemplos positivos etiquetados correctamente, los ejemplos negativos etiquetados correctamente, los ejemplos positivos etiquetados incorrectamente y los ejemplos negativos etiquetados incorrectamente.

 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) 

Al observar los resultados, podemos ver que no hay un sobreajuste significativo. Compararemos estos resultados con los de los modelos monotónicos.

Con ese fin, entrenemos y probemos un modelo monotónico XGBoost. La sintaxis en la que pasamos las restricciones monótonas es una secuencia ( f ₀ , f ₁ , …, f _N ), donde cada _fi es uno de -1, 0 o 1, dependiendo de si queremos que la característica i sea monótonamente decreciente, sin restricciones o monótonamente creciente, respectivamente. En el caso que nos ocupa, especificamos que las características maliciosas sean monótonas y crecientes.

 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) 

Está claro que el rendimiento del modelo monotónico es el mismo que el del modelo sin restricciones.

Ahora, vamos a crear un conjunto de datos contradictorios. Vamos a tomar todas las muestras maliciosas y "rellenar" sus características benignas configurándolas todas en 1. Luego veremos cómo funcionan los dos modelos uno al lado del otro.

 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

Convirtámoslos en un formulario para que los ingiera XGBoost:

 dadv = prepare_for_XGBoost(X_adversarial, y_adversarial)

Para el paso final de nuestro tutorial de XGBoost, probaremos los dos tipos de modelos de aprendizaje automático:

 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 puede ver, el modelo monotónico de IA era unas 2500 veces más resistente a los ataques de los adversarios.

LuzGBM

La sintaxis para usar funciones monótonas en LightGBM es similar.

Celosía TensorFlow

TensorFlow Lattice es otro marco para abordar las restricciones de monotonicidad y es un conjunto de Estimadores de TensorFlow prediseñados, así como de operadores de TensorFlow para crear sus propios modelos de celosía. Las redes son tablas de consulta interpoladas multidimensionales, lo que significa que son puntos distribuidos uniformemente en el espacio (como una cuadrícula), junto con valores de función en estos puntos. Según el blog de IA de Google:

“…los valores de la tabla de búsqueda están entrenados para minimizar la pérdida en los ejemplos de entrenamiento, pero además, los valores adyacentes en la tabla de búsqueda están restringidos para aumentar a lo largo de las direcciones dadas del espacio de entrada, lo que hace que las salidas del modelo aumenten en esas direcciones. Es importante destacar que, debido a que se interpolan entre los valores de la tabla de búsqueda, los modelos de celosía son uniformes y las predicciones están limitadas, lo que ayuda a evitar predicciones grandes o pequeñas falsas en el tiempo de prueba”.

Los tutoriales sobre cómo usar TensorFlow Lattice se pueden encontrar aquí.

Modelos monotónicos de IA y el futuro

Desde defender dispositivos de ataques maliciosos hasta ofrecer recomendaciones de restaurantes lógicas y útiles, los modelos monotónicos de IA han demostrado ser una gran ayuda para la sociedad y una herramienta maravillosa para dominar. Los modelos monotónicos están aquí para llevarnos a una nueva era de seguridad, delicadeza y comprensión en IA. Y entonces digo, brindemos por los modelos monotónicos de IA, brindemos por el progreso.