Mon expérience avec LLama2 en tant que développeur et pirate informatique

Bienvenue sur mon article de blog où je partagerai mon parcours et mes idées sur le travail avec le modèle LLama2. LLama2 est un fantastique modèle d'IA développé par Meta, et il est passionnant d'explorer ses capacités qui rappellent GPT-3. Dans cet article, nous allons nous plonger dans différentes facettes de LLama2, y compris sa configuration, ses prérequis, ses applications, sa signification et même un aperçu de la façon dont nous pouvons l'entraîner nous-mêmes. Je suis ravi de vous faire découvrir mon expérience d'apprentissage avec LLama2, tout au long de mon travail sur mon projet HackBot .

Sujets à couvrir

• Qu'est-ce que LLama2 ?
• Comment commencer?
• Comment l'ai-je utilisé dans HackBot ?
• Comment entraîner le modèle ?
• Capacités et avantages.
• Keynotes finales.

Qu'est-ce que LLama2 ?

LLama2 est une technologie de pointe créée par Meta qui est classée comme un modèle d'IA en son cœur. Considérez-le comme un assistant très intelligent qui peut comprendre le langage humain et produire des réponses significatives, presque humaines. L'objectif de LLama2 est d'améliorer la facilité et le naturel des interactions entre les personnes et les ordinateurs.

Réfléchissez à la façon dont vous vous exprimez verbalement lorsque vous parlez à des amis ou rédigez des e-mails ; les personnes avec qui vous communiquez comprennent et réagissent. De fonctionnement similaire, LLama2 peut traiter d'énormes volumes de données textuelles et en tirer des leçons. Cela permet à LLama2 d'aider à une variété de tâches, telles que la fourniture d'informations et la réponse aux questions, ainsi que la rédaction de contenu et l'aide à la résolution de problèmes.

La caractéristique unique de LLama2 est qu'il a été créé dans un souci d'accessibilité. C'est comme avoir un instrument flexible qui peut être utilisé par n'importe qui avec différents niveaux de capacité technique. LLama2 offre une approche simple pour accéder au potentiel de l'intelligence artificielle, que vous soyez développeur, écrivain, étudiant ou quelqu'un qui s'y intéresse.

Essentiellement, LLama2 crée un domaine de possibilités où les ordinateurs peuvent interagir plus facilement et plus efficacement avec le langage humain. Vos interactions avec la technologie deviennent beaucoup plus productives et efficaces puisque c'est comme avoir un copain virtuel qui est constamment là pour vous aider dans les activités impliquant du texte et du langage.

Comment commencer?

Commençons par les premières étapes pour vous permettre de démarrer. Voici les tâches que vous devez prendre en compte pour que le code fonctionne.

Choisir votre langue :

Python était mon premier choix pour un compagnon de voyage fiable. C'est une excellente option pour interagir avec LLama2 en raison de son adaptabilité et de son utilisation intensive dans la communauté de programmation. Vous êtes en forme si vous connaissez déjà Python.

Configuration de l'essentiel :

• Accès au compte HuggingFace et au référentiel Lama :

  Vous devrez créer un compte sur HuggingFace, une plate-forme qui héberge plusieurs modèles et outils d'IA, pour commencer. Assurez-vous que votre compte est prêt. De plus, vous pouvez trouver les composants de LLama2 en acquérant l'accès au référentiel Lama de Meta.

  
  

• Installation C/C++ et Cmake : LLama2 a un composant appelé LLama-cpp, qui nécessite l'installation de C/C++ et Cmake sur votre système. Ces outils sont essentiels pour construire LLama-cpp, alors assurez-vous qu'ils sont configurés et prêts à l'emploi.

Connexion et préparation :

• Connexion Huggingface-cli : Avec les détails de votre compte HuggingFace en main, utilisez l'interface de ligne de commande HuggingFace pour vous connecter. Cette étape vous connecte à la plateforme HuggingFace à l'aide de votre jeton de compte, vous donnant accès aux ressources d'IA dont vous avez besoin. Le jeton peut être trouvé à l'aide de cette URL si vous n'en trouvez pas en générer un.

  
  

  Les commandes sont :

   $ huggingface-cli login Token: Your_Token

  
  

• Installation de LLama-cpp : Llama-cpp est un classeur d'accès de bas niveau permettant à Lama et Python de travailler ensemble et nous offre plus de flexibilité.

  
  

  L'installation peut se faire de 2 manières :

  • L'installation directe de Python :

     pip install llama-cpp-python

  • L'option de compilation : Pour cela, vous devez consulter le fichier readme du module son complexe à expliquer : README.md

  
  

• Installation de Langchain : Langchain est un framework ouvert destiné à faciliter le développement d'applications de modèles LLM. Nous utiliserons notamment les modules LLamaCpp , PrompTemplate , CallbackManager et StreamingStdOutCallbackHandler pour cette tâche.

  
  

  La commande pour l'installation est :

   pip install langchain pip install langchainplus-sdk

Comment est-il utilisé dans le code Python ?

Maintenant, la question principale est de savoir comment est-il utilisé?

Pour répondre à cela, la partie intégration peut être divisée en étapes.

• Le téléchargement et la définition du modèle :

  • Pour cela, je me référerai au code de HackBot.

  • Après avoir appelé tous les modules essentiels, nous devons décider du nom du modèle et du dépôt à partir duquel nous voulons le télécharger.

     model_name_or_path = "localmodels/Llama-2-7B-Chat-ggml" model_basename = "llama-2-7b-chat.ggmlv3.q4_0.bin" model_path = hf_hub_download(repo_id=model_name_or_path, filename=model_basename)

    
    

  • Dans le code ci-dessus, le module llama utilisé est un modèle 7b ou 7 milliards de paramètres et la version Localmodels llama2.

  • Ensuite, le model_path est référencé par le chemin de téléchargement du modèle par le téléchargeur huggingface qui télécharge llama-2-7b-chat.ggmlv3.q4_0.bin du référentiel dans le système.

  • Le chemin est important car LlamaCpp fera référence à l'emplacement du modèle pour l'utiliser.

  
  

• Définissez un persona et un modèle d'invite :

   from langchain import PromptTemplate from langchain.callbacks.manager import CallbackManager from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler template = """ persona: {persona} You are a helpful, respectful, and honest cybersecurity analyst. Being a security analyst, you must scrutinize the details provided to ensure they are usable for penetration testing. Please ensure that your responses are socially unbiased and positive. If a question does not make any sense or is not factually coherent. If you don't know the answer to a question, please don't share false information. Keep your answers in English and do not divert from the question. If the answer to the asked question or query is complete, end your answer. Keep the answer accurate and do not skip details related to the query. Give your output in markdown format. """ prompt = PromptTemplate(template=template, input_variables=["persona"]) callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])

  • Nous devons donner un modèle de base à un lama à utiliser comme ses personnages, comme le définir comme un assistant personnel ou un analyste de la cybersécurité.

  • Le modèle définit comment le modèle fonctionnera et peut avoir beaucoup d'effet sur ce que sera le résultat final, il doit donc être écrit avec le plus grand soin.

  • L'invite est ensuite générée à l'aide du modèle de persona et du module PromptTemplate à l'aide du persona.

  • Le gestionnaire de callback permet d'afficher la sortie de l'IA et également de gérer les liens d'entrée et de sortie.

    
    

• Définir le module LlamaCpp :

   llm = LlamaCpp( model_path=model_path, input={"temperature": 0.75, "max_length": 3500, "top_p": 1}, callback_manager=callback_manager, max_tokens=3500, n_batch=3500, n_gpu_layers=60, verbose=False, n_ctx=3500, streaming=False, )

  • Le module LlamaCpp est le module de connexion qui relie le module LLM téléchargé.
  • Pour que le module fonctionne, nous devons le lier au chemin du modèle prédéfini lors du lancement du téléchargeur.
  • La longueur d'entrée maximale doit être définie dans la section des entrées et le nombre maximal de jetons doit être défini. Les jetons sont le texte de l'IA compris.
  • Ensuite, le lot, les couches GPU et ctx sont définis et le streaming est défini sur False pour qu'il n'affiche pas la sortie directement et qu'il puisse être stocké avec une variable pour garder la sortie finale propre.

Maintenant, en implémentant cela, nous avons créé un backbone de chatbot ou un connecteur et en l'utilisant, nous pouvons démarrer une conversation active avec le modèle d'IA.

Comment l'ai-je utilisé dans HackBot ?

HackBot était ma tentative de créer un bot de discussion spécifique à la cybersécurité et cet outil possède des fonctionnalités telles que des données d'analyse, des outils d'analyse de données de journal et des capacités d'analyse de code.

• Boucle d'interaction de chat :

   while True: try: prompt_in = Prompt.ask('> ') # ... except KeyboardInterrupt: pass

  
  

  Cette boucle crée un environnement interactif dans lequel l'utilisateur peut saisir des commandes ou des invites. Le code attend l'entrée de l'utilisateur à l'aide de Prompt.ask('> ') et gère les exceptions telles que KeyboardInterrupt (Ctrl+C) sans planter le programme. Cette boucle garantit que le chatbot reste réactif et peut interagir en permanence avec l'utilisateur.

  
  

• Traitement des commandes utilisateur :

   if prompt_in == 'quit_bot': quit() elif prompt_in == 'clear_screen': clearscr() pass elif prompt_in == 'bot_banner': # ... elif prompt_in == 'save_chat': # ... elif prompt_in == 'static_code_analysis': # ... elif prompt_in == 'vuln_analysis': # ... elif prompt_in == 'contact_dev': # ... elif prompt_in == 'help_menu': # ... else: # ...

  Dans la boucle, l'entrée de l'utilisateur est comparée à différents mots-clés de commande. En fonction de l'entrée, le code exécute les actions correspondantes. Par exemple, si l'utilisateur saisit 'quit_bot', la fonction quit() est appelée pour quitter le programme. Si l'utilisateur saisit 'clear_screen', la fonction clearscr() efface l'écran de la console. Une logique similaire est appliquée à d'autres commandes.

  
  

• Génération de réponses IA :

   else: prompt = prompt_in print(Print_AI_out(prompt)) pass

  Si l'entrée de l'utilisateur ne correspond à aucune des commandes prédéfinies, elle est traitée comme une invite pour l'IA. L'entrée est affectée à la variable prompt et la fonction Print_AI_out(prompt) est appelée pour générer une réponse AI basée sur l'invite fournie. La réponse générée par l'IA est ensuite imprimée sur la console.

  
  

• Enregistrement de l'historique des discussions :

   def save_chat(chat_history: list[Any, Any]) -> None: f = open('chat_history.json', 'w+') f.write(json.dumps(chat_history)) f.close

  La fonction save_chat the est chargée de sauvegarder l'historique des conversations, qui comprend à la fois les invites de l'utilisateur et les réponses générées par l'IA, dans un fichier JSON nommé "chat_history.json". Cette fonction sérialise les données de la liste chat_history au format JSON et les écrit dans le fichier.

  
  

• Analyse de vulnérabilité et analyse de code statique :

   elif prompt_in == 'static_code_analysis': print(Markdown('----------')) language_used = Prompt.ask('Language Used> ') file_path = Prompt.ask('File Path> ') print(Markdown('----------')) print(static_analysis(language_used, file_path)) pass elif prompt_in == 'vuln_analysis': print(Markdown('----------')) scan_type = Prompt.ask('Scan Type > ') file_path = Prompt.ask('File Path > ') print(Markdown('----------')) print(vuln_analysis(scan_type, file_path)) pass

  Ces sections gèrent les commandes utilisateur pour effectuer une analyse de code statique et une analyse de vulnérabilité. L'utilisateur est invité à fournir des informations telles que la langue utilisée ou le type d'analyse, ainsi qu'un chemin d'accès au fichier. La fonction d'analyse correspondante ( static_analysis ou vuln_analysis ) est alors appelée avec les données fournies, et l'IA génère des réponses qui incluent les résultats d'analyse.

  
  

• Analyse de vulnérabilité : dans la section vuln_analysis , le code suivant invite l'utilisateur à saisir :

   scan_type = Prompt.ask('Scan Type > ') file_path = Prompt.ask('File Path > ')

  
  

  Ici, la fonction Prompt.ask est utilisée pour demander des informations à l'utilisateur de manière interactive. L'utilisateur est invité à entrer le type d'analyse et le chemin du fichier pour les données qui doivent être analysées. Ces données sont essentielles pour l'analyse de la vulnérabilité. Une fois que l'utilisateur a fourni ces entrées, l'analyse est lancée à l'aide d'une invite qui intègre l'entrée de l'utilisateur :

   prompt = f""" **Objective:** You are a Universal Vulnerability Analyzer powered by the Llama2 model. Your main objective is to analyze any provided scan data or log data to identify potential vulnerabilities in the target system or network. You can use the scan type or the scanner type to prepare a better report. **Instructions:** # ... (rest of the instructions) **Input Data:** You will receive the scan file data or log file data in the required format as input. Ensure the data is correctly parsed and interpreted for analysis. **Output Format:** The vulnerability analysis report should be organized as mentioned in the "Comprehensive Report" section. Please perform the vulnerability analysis efficiently, considering the security implications and accuracy, and generate a detailed report that helps users understand the potential risks and take appropriate actions. --- Provide the scan type: {scan_type} Provide the scan data or log data that needs to be analyzed: {file_data} """

  
  

  Dans cette invite, les espaces réservés {scan_type} et {file_data} sont remplacés par les valeurs réelles saisies par l'utilisateur. Cette invite dynamique est ensuite transmise au modèle LLama2 pour générer une réponse IA qui fournit des résultats d'analyse basés sur le type d'analyse fourni et les données de fichier.

  
  

• Analyse de code statique : de même, dans la section static_code_analysis , le code invite l'utilisateur à saisir :

   language_used = Prompt.ask('Language Used> ') file_path = Prompt.ask('File Path> ')

  
  

  L'utilisateur est invité à fournir le langage de programmation utilisé et le chemin du fichier pour le code qui doit être analysé. Ces entrées sont cruciales pour effectuer une analyse de code statique. Tout comme dans la section d'analyse de vulnérabilité, une invite incorporant l'entrée de l'utilisateur est construite pour le modèle LLama2 :

   prompt = f""" **Objective:** Analyze the given programming file details to identify and report bugs, vulnerabilities, and syntax errors. Additionally, search for potential exposure of sensitive information such as API keys, passwords, and usernames. **File Details:** - Programming Language: {language_used} - File Name: {file_path} - File Data: {file_data} """

  
  

  Ici, les espaces réservés {language_used} et {file_path} sont remplacés par les valeurs réelles fournies par l'utilisateur. Cette invite dynamique est ensuite utilisée pour générer une réponse IA qui présente les résultats de l'analyse en fonction du langage de programmation et des données de fichier saisies par l'utilisateur.

  
  

  Dans les deux cas, l'utilisation d'invites dynamiques garantit que les réponses générées par LLama2 sont contextuellement pertinentes et adaptées à l'analyse spécifique demandée par l'utilisateur.

• Coordonnées et menu d'aide :

   elif prompt_in == 'contact_dev': console.print(Panel( Align.center( Group(Align.center(Markdown(contact_dev))), vertical="middle", ), title= "Dev Contact", border_style="red" ), style="bold green" ) pass elif prompt_in == 'help_menu': console.print(Panel( Align.center( Group(Align.center(Markdown(help_menu))), vertical="middle", ), title= "Help Menu", border_style="red" ), style="bold green" ) pass

  
  

  Ces sections gèrent les commandes pour afficher les informations de contact du développeur ( contact_dev ) et le menu d'aide répertoriant les commandes disponibles ( help_menu ). Lorsque les utilisateurs saisissent ces commandes, les informations correspondantes sont affichées dans un panneau bien formaté à l'aide de la bibliothèque Rich.

  
  

• Exécution de la fonction principale :

   if __name__ == "__main__": main()

  La fonction main , qui englobe l'intégralité de l'interaction de chat et de la logique de gestion, n'est exécutée que si le script est exécuté directement (non importé en tant que module). Cette ligne garantit que la fonctionnalité principale du chatbot est exécutée lorsque le script est exécuté.

Vous pouvez voir et essayer l'intégralité du chatbot depuis mon dépôt Github : Lien

Comment entraîner le modèle ?

La formation d'un modèle d'IA est un processus de transformation qui nécessite planification et précision. Voici un guide étape par étape pour terminer le processus.

Prérequis :

• Tensor Power : Un système puissant avec une capacité de traitement de tenseur importante préparera le terrain pour le succès. Assurez-vous que votre équipement peut gérer la puissance de traitement nécessaire à la formation de modèles d'IA.

  
  

• Ensemble de données : un ensemble de données correspondant au format d'entraînement de l'IA accélérera la courbe d'apprentissage de votre modèle. Une formation efficace dépend de données de haute qualité, ce qui affecte la précision et la compétence du modèle.

  
  

• Autotrain Advanced : Donnez-vous accès à cette ressource de formation indispensable à l'intelligence artificielle. La procédure de formation est rationalisée par ce programme, qui automatise les procédures cruciales et augmente la productivité.

  
  

Le processus de formation :

• Préparation des données : pour garantir l'exactitude et l'uniformité, organisez et prétraitez votre ensemble de données. Avoir des données propres et organisées est la clé pour obtenir les meilleurs résultats d'entraînement.

  
  

• Initialisation du modèle : choisissez le meilleur modèle pré-formé à utiliser comme point de départ. La convergence est accélérée et le processus de formation est relancé.

  
  

• Réglage fin : ajustez les hyperparamètres tels que le taux d'apprentissage, la taille du lot et les paramètres de l'optimiseur pour affiner les paramètres. Pour équilibrer les performances du modèle et la vitesse de convergence, ajustez ces paramètres.

  
  

• Itérations d'entraînement : exécutez l'ensemble de données dans le modèle plusieurs fois (époques) pour commencer l'entraînement. Le modèle améliore sa compréhension à chaque itération, améliorant sa propension à la prédiction.

  
  

• Validation et test : utilisez un ensemble de données de validation distinct pour valider en continu le développement de votre modèle. La capacité de généralisation du modèle est évaluée par des tests sur de nouvelles données.

  
  

• Analyse et surveillance : portez une attention particulière aux mesures de formation. Des indicateurs tels que les courbes de perte, les tendances de précision et d'autres mesures fournissent des informations sur le développement du modèle.

  
  

• Optimisation et ajustement : ajustez stratégiquement les hyperparamètres en fonction des résultats de la surveillance. Pour obtenir les performances souhaitées, affinez le modèle de manière itérative.

  
  

• Évaluation et déploiement : Effectuez une évaluation approfondie de l'ensemble de données de test du modèle final. Si vous êtes satisfait des résultats, utilisez le modèle formé dans des applications pratiques.

  
  

L'ensemble de données :

L'ensemble de données peut être à la fois celui qui est pré-construit comme ceux disponibles dans les ensembles de données huggingface sous les ensembles de données spécifiques à la génération de texte disponibles. Pour les ensembles de données personnalisés, assurez-vous de suivre ces étapes :

• Le jeu de données doit inclure au moins 3 colonnes.
• La première colonne doit être le nom, la seconde peut être une description et la troisième et dernière une invite avec la demande et la réponse de l'IA.

Voici un exemple de format d'ensemble de données que vous pouvez utiliser : data.csv

C'est juste 1 type.

Une fois que vous avez votre ensemble de données, il est temps de former votre IA en fonction de la puissance GPU dont vous disposez et de la taille de votre ensemble de données, le temps correspond également en conséquence. Nous pouvons maintenant utiliser les modules avancés d'autotrain de huggingface pour entraîner l'IA.

Nous pouvons installer autotrain-advanced en utilisant cette commande :

 pip install autotrain-advanced

Et cette commande pour entraîner l'IA :

 autotrain llm --train --project_name your_project_name --model TinyPixel/Llama-2-7B-bf16-sharded --data_path your_data_set --use_peft --use_int4 --learning_rate 2e-4 --train_batch_size 2 --num_train_epochs 3 --trainer sft --model_max_length 2048 --push_to_hub --repo_id your_repo_id -

Vous pouvez changer le project_name de your_project_name au nom de votre projet réel, le modèle de TinyPixel/Llama-2-7B-bf16-sharded au modèle de lama que vous souhaitez former et le data_path à . s'il s'agit d'un ensemble de données personnalisé ou huggingface/dataset l'ID de dépôt de l'ensemble de données s'il provient de huggingface.

Mon objectif est de former un modèle Llama ou tout modèle LLM sur lequel je peux mettre la main pour devenir un assistant complet en cybersécurité afin d'automatiser la majorité de nos tâches en tant que pirates informatiques, ce qui serait une bénédiction.

Capacités et avantages

Donc, en parlant de capacités, Meta a publié des documents de recherche pour Llama avec plusieurs références. Selon les articles, les modèles Llama vont de paramètres 7B à 65B et ont des performances compétitives par rapport aux autres grands modèles de langage. Par exemple, Llama-13B surpasse GPT-3 sur la plupart des benchmarks, bien qu'il soit 10 fois plus petit. Le modèle à 65 paramètres B de Llama est également compétitif avec d'autres grands modèles de langage tels que Chinchilla ou PaLM-540B. Les articles mentionnent également qu'un modèle plus petit formé plus longtemps peut finalement être moins cher à l'inférence. Il indique que les performances d'un modèle 7B continuent de s'améliorer même après les jetons 1T. Cependant, le document ne fournit pas de valeurs numériques spécifiques pour les différences de performances entre les modèles Llama.

D'autres sources affirment que les modèles Llama sont plus polyvalents et rapides que les modèles GPT et également les modèles PaLM, ce qui en fait l'un des meilleurs modèles d'IA à utiliser. Mais pour le piratage ou toute tâche spécifique à la sécurité, cela nécessite beaucoup de formation ou d'apports personnels. Il n'est pas facile de générer un modèle de formation pour cela, mais une fois formé, cela peut changer la donne.

Discours liminaires finaux

• Efficacité inégalée : l'IA a transformé des processus qui prenaient des heures et qui se terminent désormais en quelques secondes, augmentant la productivité et libérant un temps crucial.
• Prise de décision améliorée : les analyses basées sur l'IA offrent des décisions intelligentes basées sur les données, améliorant la précision et la prévoyance dans une variété de disciplines.
• Expériences personnalisées : l'IA crée des expériences adaptées aux préférences d'une personne, des suggestions personnalisées aux plateformes d'apprentissage adaptatif.
• Automatisation des opérations monotones : l'intégration transparente de l'IA libère du temps pour des projets plus innovants et stratégiques.
• Solutions innovantes : l'IA promeut les innovations dans les domaines de la santé, de l'environnement et d'autres domaines, en s'attaquant plus efficacement aux problèmes complexes.

Le voyage dans le monde de l'intelligence artificielle a été incroyablement éclairant, démontrant l'incroyable impact de l'automatisation et de l'intégration. J'ai une profonde appréciation de la façon dont l'IA change notre façon de travailler et d'interagir après avoir vu ses capacités dans une variété d'industries. Mon expérience d'apprentissage a été une révélation, de l'observation de l'automatisation transparente des opérations régulières à l'expérience de l'intégration de l'IA dans la vie quotidienne. J'ai appris que l'automatisation et l'intégration sont plus que de simples idées techniques au fur et à mesure que j'en apprends davantage sur les complexités de l'IA ; elles agissent plutôt comme catalyseurs de l'innovation. Grâce à ces nouvelles connaissances, je peux maintenant voir un monde dans lequel le potentiel de l'IA pour améliorer l'efficacité et la collaboration est illimité.

Sources

• Méta-document de recherche
• YT-vidéo sur le réglage fin
• Publication moyenne sur le déploiement de lamas

Contacts

Vous pouvez me contacter via LinkedIn . Si vous avez des inquiétudes, vous pouvez commenter ci-dessous.

Merci d'avoir lu.