Minha experiência com LLama2 como desenvolvedor e hacker

Bem-vindo à minha postagem no blog, onde compartilharei minha jornada e ideias sobre como trabalhar com o modelo LLama2. O LLama2 é um fantástico modelo de IA desenvolvido pela Meta, e é emocionante explorar seus recursos que lembram o GPT-3. Nesta postagem, vamos nos aprofundar em diferentes facetas do LLama2, incluindo sua configuração, pré-requisitos, aplicativos, significado e até mesmo uma espiada em como podemos treiná-lo nós mesmos. Estou emocionado em levá-lo através de minha experiência de aprendizado com o LLama2, tudo adquirido enquanto trabalhava em meu projeto HackBot .

Tópicos a cobrir

• O que é LLama2?
• Como começar?
• Como eu usei no HackBot?
• Como treinar o modelo?
• Capacidades e vantagens.
• Palestras finais.

O que é LLama2?

LLama2 é uma tecnologia de ponta criada pela Meta que é classificada como um modelo de IA em seu coração. Pense nisso como um assistente muito inteligente que pode compreender a linguagem humana e produzir respostas significativas, quase humanas. O objetivo do LLama2 é melhorar a facilidade e naturalidade das interações entre pessoas e computadores.

Considere como você se expressa verbalmente quando fala com amigos ou escreve e-mails; as pessoas com quem você está se comunicando entendem e reagem. Semelhante em operação, o LLama2 pode processar enormes volumes de dados de texto e aprender com eles. Isso permite que o LLama2 ajude em uma variedade de tarefas, como fornecer informações e responder a perguntas, além de escrever conteúdo e ajudar na solução de problemas.

A característica única do LLama2 é que ele foi criado pensando na acessibilidade. É como ter um instrumento flexível que pode ser usado por qualquer pessoa com diferentes níveis de habilidade técnica. O LLama2 fornece uma abordagem simples para acessar o potencial da inteligência artificial, seja você um desenvolvedor, escritor, estudante ou apenas alguém interessado nisso.

Em essência, o LLama2 cria um mundo de possibilidades onde os computadores podem interagir de forma mais fácil e eficaz com a linguagem humana. Suas interações com a tecnologia tornam-se muito mais produtivas e eficientes, pois é como ter um amigo virtual que está sempre presente para ajudá-lo nas atividades que envolvem texto e linguagem.

Como começar?

Vamos começar com os primeiros passos para você começar. A seguir estão as tarefas que você deve considerar para que o código funcione.

Escolhendo seu idioma:

Python foi minha primeira escolha para um companheiro de viagem confiável. É uma ótima opção para interagir com o LLama2 devido à sua adaptabilidade e amplo uso na comunidade de programação. Você está em boa forma se já estiver familiarizado com o Python.

Configurando o essencial:

• Conta HuggingFace e acesso ao repositório Lama:

  Você precisará criar uma conta no HuggingFace, uma plataforma que abriga vários modelos e ferramentas de IA, para começar. Certifique-se de que sua conta está preparada. Além disso, você pode encontrar os componentes para LLama2 adquirindo acesso ao repositório Lama da Meta.

  
  

• Instalação de C/C++ e Cmake: LLama2 possui um componente chamado LLama-cpp, que requer a instalação de C/C++ e Cmake em seu sistema. Essas ferramentas são essenciais para criar o LLama-cpp, portanto, certifique-se de que estejam configuradas e prontas para uso.

Fazendo Login e Preparando-se:

• Huggingface-cli Login: Com os detalhes da sua conta HuggingFace em mãos, use a interface de linha de comando HuggingFace para fazer login. Esta etapa conecta você à plataforma HuggingFace usando o token da sua conta, concedendo acesso aos recursos de IA de que você precisa. O token pode ser encontrado usando este URL se você não encontrar um para gerar um.

  
  

  Os comandos são:

   $ huggingface-cli login Token: Your_Token

  
  

• Instalando o LLama-cpp: O Llama-cpp é um fichário de acesso de baixo nível para o llama e o Python trabalharem juntos e nos fornecer mais flexibilidade.

  
  

  A instalação pode ser feita de 2 formas:

  • A instalação direta do Python:

     pip install llama-cpp-python

  • A opção de compilação: Para isso, você precisa verificar o readme do módulo que é complexo para explicar: README.md

  
  

• Instalando Langchain : Langchain é uma estrutura aberta destinada a facilitar o desenvolvimento de aplicativos de modelo LLM. Usaremos os módulos LLamaCpp , PrompTemplate , CallbackManager e StreamingStdOutCallbackHandler em particular para esta tarefa.

  
  

  O comando para a instalação é:

   pip install langchain pip install langchainplus-sdk

Como é usado no código Python?

Agora a questão principal é como ele é usado?

Para responder que a parte de integração pode ser dividida em etapas.

• O modelo de download e definição:

  • Para isso, estarei me referindo ao código do HackBot.

  • Depois de chamar todos os módulos essenciais, devemos decidir o nome do modelo e o repositório do qual queremos baixá-lo.

     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)

    
    

  • No código acima, o módulo llama usado é um modelo de 7b ou 7 bilhões de parâmetros e a versão Localmodels llama2.

  • Em seguida, o model_path é referido pelo caminho de download do modelo pelo downloader huggingface, que baixa llama-2-7b-chat.ggmlv3.q4_0.bin do repositório para o sistema.

  • O caminho é importante, pois o LlamaCpp se referirá ao local do modelo para usá-lo.

  
  

• Defina uma persona e um modelo de prompt:

   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()])

  • Temos que fornecer um modelo básico para uma lhama usar como suas personas, como defini-la como assistente pessoal ou analista de segurança cibernética.

  • O modelo define como o modelo funcionará e pode ter muito efeito sobre qual será o resultado final, portanto, deve ser escrito com o máximo cuidado.

  • O prompt é então gerado usando a persona modelo e o módulo PromptTemplate usando a persona.

  • O gerenciador de retorno de chamada é usado para exibir a saída do AI e também gerenciar os links de entrada e saída.

    
    

• Defina o módulo 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, )

  • O módulo LlamaCpp é o módulo de conexão que liga o módulo LLM baixado.
  • Para que o módulo funcione, precisamos vinculá-lo com o caminho do modelo que é pré-definido quando iniciamos o downloader.
  • O comprimento máximo de entrada deve ser definido na seção de entradas e os tokens máximos devem ser tokens definidos que o texto do AI entende.
  • Em seguida, o lote, as camadas de GPU e ctx são definidos e o streaming é definido como Falso para não mostrar a saída diretamente e para que possa ser armazenado com uma variável para manter a saída final limpa.

Agora, ao implementar isso, criamos um backbone de chatbot ou um conector e, usando isso, podemos iniciar uma conversa ativa com o modelo de IA.

Como eu usei no HackBot?

O HackBot foi minha tentativa de criar um bot de bate-papo específico para segurança cibernética e essa ferramenta possui recursos como dados de varredura, ferramentas de análise de dados de log e recursos de análise de código.

• Ciclo de interação de bate-papo:

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

  
  

  Esse loop cria um ambiente interativo onde o usuário pode inserir comandos ou prompts. O código espera pela entrada do usuário usando Prompt.ask('> ') e lida com exceções como KeyboardInterrupt (Ctrl+C) sem travar o programa. Esse loop garante que o chatbot permaneça responsivo e possa interagir continuamente com o usuário.

  
  

• Comandos do usuário de processamento:

   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: # ...

  Dentro do loop, a entrada do usuário é verificada em relação a diferentes palavras-chave de comando. Dependendo da entrada, o código executa as ações correspondentes. Por exemplo, se o usuário inserir 'quit_bot', a função quit() será chamada para sair do programa. Se o usuário inserir 'clear_screen', a função clearscr() limpa a tela do console. Lógica semelhante é aplicada a outros comandos.

  
  

• Gerando respostas de IA:

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

  Se a entrada do usuário não corresponder a nenhum dos comandos predefinidos, ela será tratada como um prompt para o AI. A entrada é atribuída à variável prompt e a função Print_AI_out(prompt) é chamada para gerar uma resposta AI com base no prompt fornecido. A resposta gerada pela IA é então impressa no console.

  
  

• Salvando histórico de bate-papo:

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

  A função save_chat é responsável por salvar o histórico da conversa, que inclui os prompts do usuário e as respostas geradas pela IA, em um arquivo JSON chamado 'chat_history.json'. Essa função serializa os dados na lista chat_history no formato JSON e os grava no arquivo.

  
  

• Análise de Vulnerabilidade e Análise de Código Estático:

   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

  Essas seções lidam com os comandos do usuário para realizar análise de código estático e análise de vulnerabilidade. O usuário é solicitado a fornecer informações como o idioma usado ou o tipo de digitalização e um caminho de arquivo. A função de análise correspondente ( static_analysis ou vuln_analysis ) é chamada com os dados fornecidos e a IA gera respostas que incluem os resultados da análise.

  
  

• Análise de Vulnerabilidade: Na seção vuln_analysis , o código a seguir solicita a entrada do usuário:

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

  
  

  Aqui, a função Prompt.ask é usada para solicitar informações interativamente ao usuário. O usuário é solicitado a inserir o tipo de verificação e o caminho do arquivo para os dados que precisam ser analisados. Essas entradas são essenciais para a análise de vulnerabilidade. Depois que o usuário fornece essas entradas, a análise é iniciada usando um prompt que incorpora a entrada do usuário:

   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} """

  
  

  Nesse prompt, os espaços reservados {scan_type} e {file_data} são substituídos pelos valores reais inseridos pelo usuário. Esse prompt dinâmico é então passado para o modelo LLama2 para gerar uma resposta AI que fornece resultados de análise com base no tipo de varredura e dados de arquivo fornecidos.

  
  

• Análise de código estático: Da mesma forma, na seção static_code_analysis , o código solicita que o usuário insira:

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

  
  

  O usuário é solicitado a fornecer a linguagem de programação utilizada e o caminho do arquivo para o código que precisa ser analisado. Essas entradas são cruciais para realizar a análise de código estático. Assim como na seção de análise de vulnerabilidade, um prompt incorporando a entrada do usuário é construído para o modelo 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} """

  
  

  Aqui, os espaços reservados {language_used} e {file_path} são substituídos pelos valores reais fornecidos pelo usuário. Esse prompt dinâmico é usado para gerar uma resposta de IA que apresenta os resultados da análise com base na linguagem de programação e nos dados de arquivo inseridos pelo usuário.

  
  

  Em ambos os casos, o uso de prompts dinâmicos garante que as respostas geradas pelo LLama2 sejam contextualmente relevantes e adaptadas à análise específica solicitada pelo usuário.

• Informações de contato e menu de ajuda:

   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

  
  

  Essas seções manipulam os comandos para exibir informações de contato para o desenvolvedor ( contact_dev ) e o menu de ajuda listando os comandos disponíveis ( help_menu ). Quando os usuários inserem esses comandos, as informações correspondentes são exibidas em um painel bem formatado usando a biblioteca Rich.

  
  

• Execução da função principal:

   if __name__ == "__main__": main()

  A função main , que engloba toda a lógica de interação e manuseio do chat, é executada apenas se o script estiver sendo executado diretamente (não importado como um módulo). Essa linha garante que a funcionalidade principal do chatbot seja executada quando o script for executado.

Você pode visualizar e experimentar todo o chatbot no meu repositório do Github: Link

Como treinar o modelo?

O treinamento de um modelo de IA é um processo transformacional que exige planejamento e precisão. Aqui está um guia passo a passo para concluir o processo.

Pré-requisitos :

• Tensor Power: Um sistema forte com uma capacidade considerável de processamento de tensores preparará o cenário para o sucesso. Certifique-se de que seu equipamento possa lidar com o poder de processamento necessário para o treinamento do modelo de IA.

  
  

• Conjunto de dados: um conjunto de dados que corresponde ao formato de treinamento de IA acelerará a curva de aprendizado do seu modelo. O treinamento eficaz depende de dados de alta qualidade, o que afeta a precisão e a competência do modelo.

  
  

• Autotrain Advanced : Dê a si mesmo acesso a este recurso de treinamento essencial para inteligência artificial. O procedimento de treinamento é agilizado por este programa, que automatiza procedimentos cruciais e aumenta a produtividade.

  
  

O processo de treinamento:

• Preparação de dados: para garantir precisão e uniformidade, organize e pré-processe seu conjunto de dados. Ter dados limpos e organizados é a chave para obter os melhores resultados de treinamento.

  
  

• Inicialização do modelo: escolha o melhor modelo pré-treinado para usar como ponto de partida. A convergência é acelerada e o processo de treinamento é iniciado.

  
  

• Ajuste fino: ajuste hiperparâmetros como taxa de aprendizado, tamanho do lote e configurações do otimizador para ajustar os parâmetros. Para equilibrar o desempenho do modelo e a velocidade de convergência, ajuste esses parâmetros.

  
  

• Iterações de treinamento: execute o conjunto de dados por meio do modelo várias vezes (épocas) para iniciar o treinamento. O modelo melhora sua compreensão a cada iteração, melhorando sua propensão para predição.

  
  

• Validação e Teste: Utilize um conjunto de dados de validação distinto para validar continuamente o desenvolvimento do seu modelo. A capacidade de generalização do modelo é avaliada por meio de testes com novos dados.

  
  

• Analisando e monitorando: preste muita atenção às métricas de treinamento. Indicadores como curvas de perda, tendências de precisão e outras métricas oferecem informações sobre o desenvolvimento do modelo.

  
  

• Otimização e ajuste fino: ajuste os hiperparâmetros estrategicamente com base nas descobertas do monitoramento. Para obter o desempenho desejado, refine o modelo iterativamente.

  
  

• Avaliação e implantação: conduza uma avaliação completa do conjunto de dados de teste do modelo final. Se estiver satisfeito com os resultados, use o modelo treinado em aplicações práticas.

  
  

O conjunto de dados:

O conjunto de dados pode ser um pré-criado como os disponíveis em conjuntos de dados huggingface nos conjuntos de dados específicos de geração de texto disponíveis. Para conjuntos de dados personalizados, certifique-se de seguir estas etapas:

• O conjunto de dados deve incluir pelo menos 3 colunas.
• A primeira coluna deve ser o Nome, a segunda pode ser uma Descrição e a terceira e última deve ser um prompt com a solicitação e a resposta do AI.

Aqui está um exemplo de formato de conjunto de dados que você pode usar: data.csv

Este é apenas 1 tipo.

Depois de ter seu conjunto de dados, é hora de treinar sua IA com base em quanto poder de GPU você tem e quão grande é seu conjunto de dados, o tempo também corresponde de acordo. Agora podemos usar módulos avançados de autotrain de huggingface para treinar a IA.

Podemos instalar o autotrain-advanced usando este comando:

 pip install autotrain-advanced

E este comando para treinar a 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 -

Você pode alterar o project_name de your_project_name para o nome real do projeto, o modelo de TinyPixel/Llama-2-7B-bf16-sharded para o modelo de lhama que você está interessado em treinar e o data_path para . se for um conjunto de dados personalizado ou huggingface/dataset o ID do repositório do conjunto de dados, se for de huggingface.

Pretendo treinar um modelo Llama ou qualquer modelo LLM que eu possa colocar em minhas mãos para ser um assistente de segurança cibernética completo para automatizar a maioria de nossas tarefas como hackers que seria uma bênção ter.

Capacidades e Vantagens

Então, falando sobre capacidades, a Meta lançou trabalhos de pesquisa para o Llama com vários benchmarks. De acordo com os artigos, os modelos Llama variam de parâmetros 7B a 65B e têm desempenho competitivo em comparação com outros modelos de linguagem grandes. Por exemplo, o Llama-13B supera o GPT-3 na maioria dos benchmarks, apesar de ser 10 vezes menor. O modelo de parâmetro 65B de Llama também é competitivo com outros modelos de linguagem grandes, como Chinchilla ou PaLM-540B. Os artigos também mencionam que um modelo menor treinado por mais tempo pode ser mais barato na inferência. Ele afirma que o desempenho de um modelo 7B continua a melhorar mesmo após os tokens 1T. No entanto, o documento não fornece valores numéricos específicos para as diferenças de desempenho entre os modelos Llama.

Outras fontes afirmam que os modelos Llama são mais versáteis e rápidos em comparação com os modelos GPT e também os modelos PaLM, tornando-o um dos melhores modelos de IA disponíveis para uso. Mas para hacking ou qualquer tarefa específica de segurança, isso requer muito treinamento ou informações pessoais. Não é fácil gerar um modelo de treinamento para isso, mas uma vez treinado, isso pode mudar o jogo.

Palestras Finais

• Eficiência incomparável: a IA transformou processos que costumavam levar horas e agora são concluídos em segundos, aumentando a produtividade e liberando tempo crucial.
• Tomada de decisão aprimorada: a análise baseada em IA oferece decisões inteligentes baseadas em dados, aprimorando a precisão e a previsão em várias disciplinas.
• Experiências personalizadas: a IA cria experiências adaptadas às preferências de uma pessoa, desde sugestões personalizadas até plataformas para aprendizado adaptativo.
• Automatização de operações monótonas: a integração perfeita da IA libera tempo para projetos mais inovadores e estratégicos.
• Soluções inovadoras: a IA promove inovações em saúde, meio ambiente e outras áreas, lidando com problemas complicados de maneira mais eficaz.

A viagem ao mundo da inteligência artificial foi incrivelmente esclarecedora, demonstrando o incrível impacto da automação e integração. Aprecio profundamente como a IA está mudando a forma como trabalhamos e interagimos depois de ver seus recursos em vários setores. Minha experiência de aprendizado foi uma revelação, desde observar a automação perfeita de operações regulares até experimentar a incorporação da IA na vida diária. Aprendi que automação e integração são mais do que apenas ideias técnicas à medida que aprendo mais sobre as complexidades da IA; em vez disso, agem como catalisadores da inovação. Com esse insight recém-descoberto, agora posso ver um mundo em que o potencial da IA para melhorar a eficiência e a colaboração é ilimitado.

Fontes

• Artigo de meta pesquisa
• YT-vídeo em sintonia fina
• Postagem média sobre implantação de lhama

Contatos

Você pode entrar em contato comigo pelo LinkedIn . Se você tiver alguma dúvida, pode comentar abaixo.

Obrigado por ler.