Descarga generative ai cybersecurity - Descargar el código fuente de generative ai cybersecurity

generative ai cybersecurity

Código Fuente de IA

1.0.0

Descargar

AI generativa en ciberseguridad: generar código ofensivo a partir del lenguaje natural

Este repositorio contiene los materiales y guiones para la charla titulada "IA generativa en ciberseguridad: generar código ofensivo del lenguaje natural" por Pietro Liguori, Universidad de Nápoles Federico II, grupo de postres. La charla es parte de Artisan 2024: School de verano sobre el papel y los efectos de la inteligencia artificial en aplicaciones seguras .

Configuración de Python

Asegúrese de tener Python instalado en su sistema. Si no, puede usar un entorno virtual con Anaconda para evitar trabajar directamente en su máquina. Siga los pasos a continuación:

Instalación de Anaconda

Instale Anaconda3 :
- Asegúrese de que tenga instalado Anaconda3. Si no, puede descargar el instalador desde aquí.
- Use el comando wget para descargar el instalador:
```
wget https://repo.anaconda.com/archive/Anaconda3-version-OS.sh
```
- Hacer que el instalador sea ejecutable:
```
chmod +x Anaconda3-version-OS.sh
```
- Ejecute el instalador:
```
bash Anaconda3-version-OS.sh
```
- Es posible que deba agregar el directorio de Anaconda a la variable de entorno de ruta. Por ejemplo, agregue esta línea a su archivo bashrc :
```
 export PATH= " /path_to_anaconda/anaconda3/bin: $PATH "
```

Creando el entorno virtual

Crea un entorno virtual Python 3.9 :
- Cree un entorno virtual utilizando el comando:
```
conda create -n yourenvname python=3.9
```
  Reemplace yourenvname con su nombre de entorno deseado.
Activar el entorno :
- Active el entorno creado con el comando:
```
 source activate yourenvname
```

Ahora está listo para instalar dependencias y trabajar dentro de su entorno virtual.

Parte 1: Generación y evaluación automática de código

Descripción

En la carpeta Violent-Python-functions , tenemos archivos .in y .out que contienen las descripciones de NL (lenguaje natural) y las funciones de pitón correspondientes, respectivamente.

El violento conjunto de datos de Python es un conjunto de datos curado manualmente, donde una muestra contiene una pieza de código Python de un software ofensivo y su descripción correspondiente en lenguaje natural (inglés simple). Construimos el conjunto de datos utilizando el popular libro "Violent Python" de TJ O'Connor, que presenta varios ejemplos de programas ofensivos utilizando el lenguaje Python.

Hemos incluido solo las descripciones a nivel de función, totalizando 72 pares de descripciones de NL: funciones de Python.

Extraer un subconjunto

Instalar dependencias :
- En el directorio principal, instale las dependencias requeridas utilizando:
```
pip install -r requirements.txt --user
```
Extracción de subconjunto :
- Extraeremos un subconjunto aleatorio de 10 muestras del conjunto de datos de Python Violent-Python.
- En el directorio principal, ejecute el script create_subset.py con el siguiente comando:
```
python create_subset.py
```
- El script creará la subcarpeta scripts/results que contiene reference.in y reference.out archivos.
- El archivo reference.in contiene las 10 descripciones de NL extraídas al azar.
- El archivo reference.out contiene las 10 funciones de Python correspondientes y sirve como nuestra verdad fundamental para la evaluación.

Generación de salidas con modelos de IA

A continuación, generará 10 salidas utilizando modelos AI generativos como ChatGPT o Claude Sonnet.

Precaución

Presta atención a la estructura de los fragmentos de código. Como puede ver, los códigos de Python son todos una sola línea . De hecho, las instrucciones de varias líneas se separan entre sí con n .

Generar salidas :
- Use las descripciones de NL almacenadas en el archivo reference.in para generar las 10 salidas utilizando los modelos AI.
- Asegúrese de que los modelos AI generen las salidas línea por línea según sea necesario para la evaluación.
- Guarde las salidas del modelo en un archivo llamado output.out en la carpeta results .
- Asegúrese de que el modelo haya generado el código en formato de una sola línea
- Asegúrese de tener un archivo con 10 líneas (sin líneas vacías al final del archivo).
Solicitud de ejemplo:
```
 Generate Python 10 functions starting from the following 10 natural language (NL) descriptions:

1. [NL description]
2. [NL description]
...
10. [NL description]

Each function should be generated in a single line, for a total of 10 lines.
Different instructions of the same function should be separated by the special character "n".
Do not use empty lines to separate functions.
```
Calcule las métricas de similitud de salida :
- En la carpeta scripts , ejecute el script Python script output_similarity_metrics.py para calcular las métricas de similitud de salida entre las predicciones del modelo ( output.out ) y la referencia de la verdad de tierra ( reference.out )::
```
python output_similarity_metrics.py hypothesis_file
```
  donde hypothesis_file es el archivo results/output.out .

Las métricas se generarán en el archivo results/output_metrics.txt .

Visualizar la variabilidad métrica :
- En la carpeta scripts , ejecute el script boxplot_metrics.py para visualizar la variabilidad de las métricas guardadas en el archivo results/output_metrics.txt :
```
python boxplot_metrics.py
```

A continuación se muestra una imagen que muestra la variabilidad de las métricas de similitud de salida con un diagrama de caja:

Comparación métrica

Compare diferentes modelos
- Intente generar la salida con un modelo diferente y guarde la predicción del modelo en el archivo de results/output2.out .
- Ejecute nuevamente el script de Python output_similarity_metrics.py para calcular las métricas de similitud de salida entre las predicciones del modelo ( output2.out ) y la referencia de la verdad del suelo ( reference.out )::
```
python output_similarity_metrics.py results/output2.out
```
- Ejecute el script compare_models.py para mostrar la comparación de dos modelos de rendimiento en dos métricas
```
 python compare_models.py
```

A continuación se muestra un ejemplo de la salida:

Comparación métrica

Parte 2: Ingeniería rápida

Descripción

En esta parte, repetiremos el proceso de generación de código utilizando los modelos AI, pero esta vez aplicando una técnica de ingeniería rápida discutida durante la charla. El objetivo es observar si esta técnica mejora la calidad del código generado.

Pasos

Aplicar ingeniería rápida :
- Use las mismas descripciones de NL almacenadas en el archivo reference.in .
- Modifique sus indicaciones de acuerdo con las técnicas de ingeniería rápida aprendidas durante la charla.
Se pueden encontrar ejemplos de indicaciones en la carpeta scripts/prompt_examples .
Generar salidas :
- Genere las 10 salidas utilizando los modelos AI con las indicaciones de ingeniería.
- Guardar las salidas del modelo en un archivo llamado output_prompt_pattern.out en la carpeta scripts/results , donde prompt_pattern es un identificador que desea usar para especificar el patrón adoptado (por ejemplo, output_persona.out , output_few_shot.out ).
- Asegúrese de (nuevamente) el modelo ha generado el código en formato de una sola línea.
- Asegúrese de (nuevamente) tiene un archivo con 10 líneas (sin líneas vacías al final del archivo).
Calcule las métricas de similitud de salida :
- En la carpeta scripts , ejecute el script para calcular las métricas de similitud de salida entre las predicciones del modelo ( output_prompt_pattern.out ) y la referencia de la verdad del suelo ( reference.out ):
```
python output_similarity_metrics.py hypothesis_file
```
donde hypothesis_file es el archivo generado con un patrón de solicitud (por ejemplo, results/output_few_shot.out archivo).
- Las métricas se generarán en el archivo scripts/results/output_prompt_engineering_metrics.txt (por ejemplo, scripts/results/output_few_shot_metrics.txt archivo).
Compare los resultados :
- En la carpeta scripts , ejecute el script plot_metrics_comparison.py para comparar los resultados:
```
python plot_metrics_comparison.py file_metrics
```
  donde file_metrics es scripts/results/output_prompt_engineering_metrics.txt archivo.
- El script creará gráficos de barras para visualizar las diferencias entre las métricas de las diferentes salidas.

A continuación se muestra una imagen que muestra la comparación de métricas entre las salidas generadas sin ingeniería rápida y con ingeniería rápida de pocos disparos:

Comparación métrica

Siga estos pasos para aplicar ingeniería rápida y evaluar su impacto en la calidad de la generación de código.

Salidas guardadas

En la carpeta saved_outputs , encontrará ejemplos generados con ChatGPT-4O. Estos ejemplos ilustran cómo se ven las salidas del modelo con diferentes técnicas de ingeniería rápida aplicadas.