- A Meta divulgou o Code Llama, um modelo especializado em código baseado no Llama 2, disponibilizado gratuitamente para uso em pesquisa e comercial, sob a mesma licença comunitária
- O Code Llama aceita tanto código quanto prompts em linguagem natural e oferece suporte a geração, conclusão e depuração de código, cobrindo Python, C++, Java, PHP, TypeScript, C#, Bash e mais
- Os tamanhos do modelo são 7B, 13B, 34B e 70B; os menores favorecem menor latência, enquanto 34B e 70B buscam oferecer melhor suporte para programação
- São oferecidos o modelo base, um modelo especializado em Python e a variante Instruct, ajustada para compreender instruções em linguagem natural; para geração real de código, o uso do Instruct é recomendado
- Em sua própria avaliação, o Code Llama 34B registrou HumanEval 53,7% e MBPP 56,2%; a abordagem busca estimular a avaliação da comunidade e a melhoria de vulnerabilidades por meio de um modelo público especializado em código
Forma de lançamento e atualização do 70B
- A Meta divulgou o Code Llama, um grande modelo de linguagem capaz de gerar código a partir de prompts de texto
- O Code Llama mira desempenho de ponta entre os LLMs públicos voltados para código, com foco em tornar o fluxo de trabalho de desenvolvedores mais rápido e eficiente e reduzir a barreira de entrada para quem está aprendendo a programar
- Ele é oferecido gratuitamente para pesquisa e uso comercial, sendo distribuído sob a mesma licença comunitária do Llama 2
- Em uma atualização de 29 de janeiro de 2024, foi adicionado o Code Llama 70B, o maior e mais capaz da família Code Llama
- CodeLlama - 70B: modelo base de código
- CodeLlama - 70B - Python: modelo 70B especializado em Python
- Code Llama - 70B - Instruct: modelo 70B ajustado para compreender instruções em linguagem natural
Um modelo do Llama 2 ajustado para tarefas de código
- O Code Llama é uma versão especializada em código do Llama 2, treinada adicionalmente com um conjunto de dados voltado para código
- Ele aceita como entrada tanto código quanto prompts em linguagem natural e pode ser usado em várias tarefas de programação
- geração de código
- geração de linguagem natural sobre código
- conclusão de código
- depuração
- Um exemplo de prompt seria um pedido em linguagem natural como “escreva uma função que imprima a sequência de Fibonacci”
- Os idiomas suportados incluem Python, C++, Java, PHP, TypeScript (JavaScript), C# e Bash
Tamanhos do modelo, dados de treinamento e escolha de latência
- O Code Llama é oferecido em tamanhos de 7B, 13B, 34B e 70B parâmetros
- Com exceção do 70B, os modelos foram treinados com 500B tokens de código e dados relacionados a código, enquanto o 70B foi treinado com 1T tokens
- Os modelos base e Instruct de 7B e 13B foram treinados com o recurso fill-in-the-middle (FIM), permitindo inserir novo código no meio de código existente
- Isso dá suporte a tarefas como conclusão instantânea de código
- Cada tamanho de modelo tem características diferentes de custo de serving e latência
- O modelo 7B pode ser servido em uma única GPU
- Os modelos 34B e 70B oferecem os melhores resultados e melhor suporte para programação
- Os modelos 7B e 13B, por serem mais rápidos, são mais adequados para tarefas que exigem baixa latência, como conclusão de código em tempo real
- Os modelos Code Llama oferecem geração estável com até 100.000 tokens de contexto
- Todos os modelos foram treinados com sequências de 16.000 tokens
- Eles mostraram melhorias com entradas de até 100.000 tokens
- Sequências de entrada longas ajudam não apenas na geração de programas longos, mas também a fornecer ao modelo mais contexto de uma base de código, aumentando a relevância do resultado gerado
- Na depuração de grandes bases de código, pode ser difícil identificar todo o código relacionado a um problema específico, então o desenvolvedor pode fornecer blocos inteiros grandes de código ao modelo
Três variantes: base, Python e Instruct
- A família Code Llama inclui, além do modelo base, um modelo especializado em Python e a variante Instruct
- O Code Llama - Python é um modelo especializado na linguagem, ajustado adicionalmente com 100B tokens de código Python
- Python é a linguagem mais frequentemente usada em benchmarks de geração de código
- Python e PyTorch têm papel importante na comunidade de IA
- O Code Llama - Instruct é uma variante que passou por ajuste de instruções e alinhamento
- O treinamento continuou usando entradas de instruções em linguagem natural e saídas esperadas
- Ele foi projetado para entender melhor os resultados que as pessoas esperam em um prompt
- Para geração real de código, é recomendado usar o Code Llama - Instruct
- Isso porque ele foi ajustado para gerar respostas úteis e seguras em linguagem natural
- O Code Llama e o Code Llama - Python não são recomendados para tarefas gerais de linguagem natural
- Os dois modelos não foram projetados para seguir instruções em linguagem natural
- O Code Llama é voltado a tarefas especializadas em código e não é adequado como modelo base para outras tarefas
- Os usuários devem seguir a licença e a política de uso aceitável
Benchmarks e avaliação de segurança
- Para avaliar o desempenho do Code Llama, a Meta usou os benchmarks HumanEval e MBPP
- Em benchmarks próprios, o Code Llama apresentou desempenho superior ao de LLMs open source especializados em código e ao Llama 2
- O Code Llama 34B registrou HumanEval 53,7% e MBPP 56,2%
- Foi a pontuação mais alta em comparação com outras soluções públicas de ponta
- Foi avaliado como estando em nível equivalente ao ChatGPT
- Antes do lançamento, várias medidas de segurança foram aplicadas, e o processo de red team quantificou o risco de geração de código malicioso
- Foram criados prompts que pediam claramente código malicioso
- As respostas do Code Llama foram comparadas e pontuadas em relação às respostas do ChatGPT (GPT3.5 Turbo)
- Nos resultados, o Code Llama forneceu respostas mais seguras
- Mais detalhes do red team com especialistas em IA responsável, engenharia de segurança ofensiva, desenvolvimento de malware e engenharia de software podem ser consultados no artigo de pesquisa
Materiais públicos e uso responsável
- Desenvolvedores já usam LLMs em várias tarefas, desde escrever novo software até depurar código existente
- O Code Llama busca tornar o fluxo de trabalho de desenvolvedores mais eficiente, para que possam focar mais em trabalho humano do que em tarefas repetitivas
- A Meta vê que os LLMs para programação podem se beneficiar bastante de uma abordagem aberta tanto em inovação quanto em segurança
- Um modelo público especializado em código permite que a comunidade avalie suas capacidades, encontre problemas e corrija vulnerabilidades
- A receita de treinamento do Code Llama está disponível no repositório GitHub
- Os pesos do modelo estão disponíveis na página do Llama
- O artigo de pesquisa inclui detalhes de desenvolvimento, métodos de benchmark, limitações, desafios conhecidos, medidas de mitigação e temas para investigação futura
- O Responsible Use Guide também foi atualizado para fornecer diretrizes para desenvolver modelos downstream de forma responsável
- definição de políticas de conteúdo e medidas de mitigação
- preparação de dados
- ajuste fino do modelo
- avaliação e melhoria de desempenho
- resposta a riscos nos níveis de entrada e saída
- construção de transparência e mecanismos de reporte na interação com usuários
- Os desenvolvedores devem avaliar os modelos com benchmarks especializados em código e realizar pesquisas de segurança sobre casos de uso como geração de malware, vírus de computador e código malicioso
- Também é recomendado usar conjuntos de dados de segurança para avaliação automática e humana, além de red team com base em prompts adversariais
Próximos passos e materiais de referência
- O Code Llama foi projetado para apoiar engenheiros de software em vários setores, como pesquisa, indústria, projetos open source, ONGs e empresas
- Ainda há muitos casos de uso além do que os modelos base e Instruct podem oferecer
- A Meta espera que o Code Llama incentive outras pessoas a usar o Llama 2 para criar novas ferramentas para pesquisa e produtos comerciais
- Materiais relacionados
1 comentários
Opiniões no Hacker News
Funciona quase imediatamente com llama.cpp, então dá para testar facilmente localmente: https://github.com/ggerganov/llama.cpp/issues/2766
Ao rodar o CodeLlama-7b-Python com quantização q4_0, para o prompt em Python “imprima os 10 primeiros números primos”, ele gerou um código plausível incluindo
print_primes,is_primeemainÉ interessante imaginar como os modelos maiores vão se sair, especialmente depois de ajustes pela comunidade e com contexto/prompts melhores
Em
primes_upto(limit: int), marcando números compostos com um array booleano e imprimindo apenas os 10 primeiros comitertools.islice, sai2 3 5 7 11 13 17 19 23 29print("1, 2, 3, 5, 7, 11... and so on!O Llama2 também saiu há mais de um mês, mas estou há semanas aguardando acesso, e este modelo passa pelo mesmo formulário, então não espero muito
Gostaria de saber se receberam por outro caminho
Claro que é quase uma questão de definição, e pode haver comunidades ou áreas que considerem 1 como primo, mas esse tipo de sutileza aparece ao usar modelos de linguagem
¹) https://www.google.com/search?q=is+1+a+prime+number
Pessoalmente, o ponto central é que ele oferece geração estável com contexto de até 100.000 tokens
Todos os modelos foram treinados com sequências de 16.000 tokens, e dizem que mostram melhorias mesmo com entradas de até 100.000 tokens
Mas, lendo o artigo, a precisão na recuperação de informações essenciais piora bastante depois de 16k tokens, então ainda é preciso ver quão útil o contexto de 100k será na prática
O artigo menciona o Unnatural Code Llama, que supera outros modelos/ajustes finos em todos os benchmarks, exceto por perder por pouco para o Code Llama Python no MBPP pass@100 e por perder por pouco para o GPT-4 no HumanEval pass@1
A Meta apenas diz que não vai liberar esse modelo depois, sem explicar, então fico curioso para saber por que não lançariam um modelo que parece tão impressionante
Usar simplesmente camadas Transformer com largura de 100k seria inviável em custo; que truque será que usaram?
Até mesmo o modelo 7B do Code Llama parece competitivo com o Codex, o modelo por trás do Copilot
https://ai.meta.com/blog/code-llama-large-language-model-cod...
O GitHub também já disse várias vezes, com o “Copilot X”, que está migrando para o GPT-4[1][2]
[0] https://github.blog/2023-07-28-smarter-more-efficient-coding...
[1] https://github.com/features/preview/copilot-x
[2] https://github.blog/2023-07-20-github-copilot-chat-beta-now-...
Enquanto programo, mantenho o 7B sempre aberto em uma aba do terminal para perguntas do tipo “como faço essa coisa aleatória?”, e pessoalmente ele quase substituiu o Google/Stack Overflow
Code Llama Python é muito interessante porque foi ajustado especificamente para Python
Fico curioso para saber se seria possível criar LLMs específicos de áreas, como um modelo bom em Rust em geral, um bom em Linux em geral, um bom em genômica em geral, um bom em modelagem física em geral, e fazê-los conversar entre si para resolver problemas em colaboração
Parece um futuro bem maluco em que as máquinas realmente trabalham
Mas provavelmente seria um esquema com alguns modelos grandes, em vez de muitos modelos pequenos
Alguns meses atrás houve uma tentativa parecida para scripts do Godot, e dizem que ficou bastante boa: https://github.com/minosvasilias/godot-dodo
Acho que não houve mais tentativas porque o Llama básico não era tão bom em programação em comparação com seus outros pontos fortes, e coisas como o Starcoder acabaram ficando relativamente ofuscadas
Se ainda não conhece, vale pesquisar por Society of Mind
C é de nível suficientemente baixo e, ainda assim, em raros momentos continua legível
O melhor modelo, Unnatural Code Llama, não foi divulgado
Provavelmente porque foi treinado com dados baseados no GPT-4, o que poderia violar os termos de uso da OpenAI
Segundo o artigo “Unnatural”[1], dados “unnatural” são gerados com a ajuda de algum LLM e, se possível, é natural querer usar o melhor LLM disponível
[1] https://arxiv.org/pdf/2212.09689.pdf
TheBloke não está de brincadeira[1]
Acho que as versões quantizadas devem sair ainda hoje, e estou bem empolgado para testar um modelo 34B Python quantizado em 4 bits, que deve caber certinho em uma 3090
[1] https://huggingface.co/TheBloke/CodeLlama-13B-Python-fp16
ollama run codellama:7b-instructhttps://ollama.ai/blog/run-code-llama-locally
Mais modelos continuam sendo publicados agora: https://ollama.ai/library/codellama
Para rodar o Code Llama localmente, é possível baixar e executar a versão quantizada de 7B parâmetros com a ferramenta open source Ollama: https://github.com/jmorganca/ollama
ollama run codellama "write a python function to add two numbers"Modelos para preenchimento, modelos Python e modelos com uma variedade maior de quantidades de parâmetros também devem ser adicionados em breve
Uma janela de contexto de 100.000 tokens não é ruim, mas fico curioso sobre que contexto um modelo de código embutido vai escolher ao lidar com codebases maiores que 100K tokens
Também fico me perguntando se, sabendo que ferramentas assim serão amplamente usadas e que a dependência delas vai aumentar, passaremos a ter novas coisas a considerar ao programar
Será que deveríamos comentar mais ou menos, escrever código mais curto e menos legível para usar menos tokens, mudar a estrutura de arquivos ou as convenções de nomes — enfim, fico curioso sobre como teremos de nos adaptar para aproveitar ao máximo essas ferramentas
Dá para tornar o código independente de contexto e reduzi-lo para usar menos tokens, mas isso o deixaria mais confuso tanto para humanos quanto para modelos de linguagem
No extremo, se você usar apenas funções e variáveis de uma letra como
i,j,k, o modelo não vai conseguir inferir nada e vai inventar bobagens aleatóriasA solução é decompor tarefas grandes em pequenos módulos de caixa-preta e APIs, como já fazemos ao gerenciar complexidade, escondendo implementações que consomem muitos tokens e tornando-as irrelevantes para o uso
Se você der ao LLM a assinatura da função, uma boa descrição e alguns exemplos de uso, ele consegue usar a função sem conhecer a implementação
Concisão só prejudica a capacidade do LLM de processar código e não resolve o problema do tamanho do contexto; mesmo no melhor caso, isso não escala
100k tokens é bastante coisa, então não há necessidade de fazer isso
Essas informações podem ser compactadas de uma forma adequada para mostrar ao LLM
Por exemplo, para gerar a implementação de um método dentro de uma classe C++, você poderia fornecer ao LLM uma versão compactada dos arquivos de cabeçalho que o compilador veria ao compilar aquela classe
Remover espaços em branco e comentários e reduzir macros pode economizar muitos tokens
Cabeçalhos da biblioteca padrão talvez possam ser omitidos, já que o LLM provavelmente os conhece bem pelo processo de ajuste fino
Um arquivo C++ pré-processado comum pode atingir o limite de 100K mesmo com alguma otimização, então é indispensável ter um middleware que faça um refinamento adicional antes de passá-lo ao LLM
O modelo faz inferências e sugestões melhores
O mesmo vale para dados: dados devidamente etiquetados e nomes de campos descritivos tornam as respostas do LLM muito mais úteis
No fundo, espero que a disseminação dessas ferramentas finalmente faça meus colegas desenvolvedores comentarem o código e pararem de usar nomes de variáveis de três letras
O método para escolher quais arquivos passar ao GPT-4 era baseado em embeddings
Eu escolhia arquivos que pareciam mais relevantes usando os embeddings de cada arquivo e um processamento simples em cima do embedding criado a partir da instrução
Não era perfeito, mas era suficiente na maior parte do tempo para codebases de médio porte, e não era adequado para codebases muito grandes
Por causa dessa implementação, comecei a tornar os arquivos mais curtos e mover conteúdo para outros arquivos
Arquivos com mais de mil linhas consumiam toda a janela de contexto, o que pesava bastante; com uma janela de 100k isso deve ser menos problemático, mas acho que, de qualquer forma, é melhor manter os arquivos curtos
Também há métodos mais inteligentes, como embeddar e passar funções/classes individuais em vez de arquivos inteiros, então alguém deve criar algo melhor em breve
Provavelmente quase não será necessário mudar padrões de programação para aproveitar IA
Juntar código dividido em um grande arquivo, reduzir comentários e remover espaços em branco é algo que um pré-processador para LLM pode fazer
O Copilot funcionou bem até agora, mas a interface é uma limitação
Ele parece saber apenas prever o próximo fragmento de texto
Fico curioso para saber quem está criando uma IA de código que sugira refatorações como “estas linhas se repetem, então seria melhor extraí-las para uma função” ou “esta estrutura ficaria mais fácil de usar se fosse alterada assim”
No Cody.dev, é possível criar embeddings para o repositório inteiro, então dá para ter um contexto muito maior sobre a base de código e o problema que se quer resolver
A propósito, entrei na Sourcegraph algumas semanas atrás
Acho que ainda não há nada robusto
Basta destacar o código e pedir; ele também oferece suporte ao uso do Code Llama: https://continue.dev/docs/walkthroughs/codellama
O IntelliJ IDEA já sugere ambas localmente, de bom grado
Ele consegue encontrar grandes blocos de código duplicado e refatorá-los automaticamente para uma função, e também tem muitas inspeções que sugerem refatorações para deixar o código mais claro
Da última vez que ouvi falar, estava em beta e não funcionava bem
Mesmo na página de exemplos, o brush “add types” é rigoroso demais, porque
aebviram alvos de verificação contranull, e o “fix simple bug” é quase só a correção de um erro de digitaçãoDo ponto de vista de um iniciante completo que nunca rodou modelos assim por conta própria, fico curioso sobre qual hardware é necessário
Não consegui encontrar isso direito no README
Gosto muito da ideia de poder usar modelos assim sem enviar o código-fonte para uma grande empresa de tecnologia
Basta instalar o app e executar alguns comandos no shell
Provavelmente este modelo também estará disponível em breve e, então, acho que poderá ser usado junto com a extensão Continue para VS Code
É um pouco lento, mas parece que swap suficiente virou um substituto viável para a grande quantidade de RAM necessária
O Ollama diz que são necessários 32 GB para executar o modelo 13B, mas estou rodando o modelo
llama2:13bem um MBP de 16 GBO 7B roda até em uma torradeira inteligente
Caso contrário, a inferência em CPU com llama.cpp deve funcionar na maioria das máquinas