Teste de codificação para Llama 3: Implementando persistência JSON

Ao construir um Twitter descentralizado em um post anterior, incluí alguns códigos que foram implementados Persistência JSON. Com o lançamento do Meta’s Lhama 3 este mês, pensei que seria uma boa oportunidade para explorar como um novo LLM pode ajudar na codificação.

Meta.AI é a interface de chat do Llama 3, que usaremos após desenvolver nossa solução de persistência. Enquanto escrevo isto (final de abril), o Meta.AI não está disponível globalmente, então pode ser necessário usar uma VPN para acessá-lo. Pode ser necessário usar um login do Facebook para algumas coisas, como geração de imagens, mas isso não parece ser uma necessidade.

Primeiro, verifiquei se estava realmente conversando com o Llama 3, embora isso não fosse totalmente conclusivo:

Ao analisar um LLM anterior (Lhama 2), pedi-lhe para fazer uma longa multiplicação que não conseguiu. No entanto, “falhou como um humano”. Vejamos como esse modelo progrediu:

Uma resposta rápida e muito mais bonita. Ainda errado; a resposta é 1.223.834.880. No entanto, não estamos aqui para nos preocupar com esta lacuna conhecida. Voltemos ao tópico principal: persistência com JSON.

Salvando com JSON

JSON é um formato de dados portátile embora menos eficiente que um formato binário nativo arbitrário, pode pelo menos ser verificado por humanos e implementado em qualquer lugar.

Como JSON pode lidar com tipos de valores básicos e algumas coleções, podemos, em geral, mapear nossos dados de instância para o formato JSON. Isso é conhecido como ordenação e é muito menos problemático hoje do que costumava ser. Se você deseja persistir (ou seja, salvar e carregar) as preferências do usuário, uma reviravolta no jogo ou apenas alguns dados úteis e antigos, o JSON está à sua volta.

Neste post usarei .NET e C#. Embora possamos nos sair bem com o System.Text.Json embutido, o NewtonSoft package é um pouco melhor, então vou chamar assim.

Primeiro, configurarei um projeto de console que usará o novo estilo de instruções de nível superior para eliminar a necessidade de principal declarações e outros clichês. Então, em um terminal:

Comecei com uma aula rápida de Carro, que escrevi diretamente em Program.cs. Usaremos isso como nosso objeto alvo:

Car car = new Car("Saab", "V90", Car.CarColor.Red); 
Console.WriteLine($"First car: {car}"); 

public class Car 
{ 
   public enum CarColor {Red, Blue, White}; 
   public string Brand; 
   public string Model; 
   public short MileageAtLastService; 

   public Car(string brand, string model, CarColor color) 
   { 
      this.Brand = brand; 
      this.Model = model; 
      this.MileageAtLastService = 0; 
      this.Color = color; 
    } 

    public void SetMileage(short mileage) => this.MileageAtLastService = mileage; 
    public override string ToString() => $"{Color} {Brand} {Model}" ; 
}

A saída do console depois de executar isso é:

First car: Red Saab V90

Para usar o pacote Newtonsoft.JSON na linha de comando, podemos simplesmente executar isto no terminal:

JsonMarshalling> dotnet add package Newtonsoft.Json

Você também pode usar a paleta no VS Code, embora às vezes eu ache isso um pouco pouco confiável. Agora que enviamos o código do objeto car para seu próprio arquivo, Car.cs, e namespace, CarClass, vamos fazer uma conversão simples em Program.cs:

using CarClass; 
using Newtonsoft.Json; 
const string OUTFILE = @".cars.json"; 

Car car = new Car("Saab", "V90", Car.CarColor.Red); 
Console.WriteLine($"First car: {car}"); 

string output = JsonConvert.SerializeObject(car); 
Console.WriteLine($"Serialised: {output}");

A saída para isso no terminal é:

Serialised: {"Brand":"Saab","Model":"V90","MileageAtLastService":0,"Color":0}

Ah, não funcionou? Mas está tudo bem. O enumeração usado para CarColor precisa ser tratado separadamente, pois não é um tipo reconhecido por JSON. Poderíamos escrever a conversão nós mesmos ou simplesmente deixá-la para o conversor existente, decorando a propriedade em Cars.cs:

using Newtonsoft.Json 
using Newtonsoft.Json.Converters; 
... 
(JsonConverter(typeof(StringEnumConverter))) 
public CarColor Color {get; set;} 
...

O resultado de saída agora está correto:

Serialised: {"Brand":"Saab","Model":"V90","MileageAtLastService":0,"Color":"Red"}

O que queremos trabalhar para uma viagem de ida e volta é persistir alguns carros em um arquivo JSON, restaurar e, em seguida, atualizar um aspecto (por exemplo, um serviço de garagem) e salvar novamente, finalmente verificando o JSON no arquivo. Primeiro, vamos verificar se podemos salvar uma lista em um arquivo:

using CarClass; 
using Newtonsoft.Json; 

const string OUTFILE = @"./cars.json"; 
List<Car> cars = new List<Car>(); 
Car car = new Car("Saab", "V90", Car.CarColor.Red); 
Console.WriteLine($"First car: {car}"); 
cars.Add(car); 

car = new Car("Volkswagen", "Polo", Car.CarColor.White); 
Console.WriteLine($"Uncle's car: {car}"); 
cars.Add(car); 
string output = JsonConvert.SerializeObject(cars); 
File.WriteAllText(OUTFILE, output);

O arquivo produzido está correto, contendo dois objetos JSON:

Vamos generalizar a parte da persistência e colocá-la em seu próprio arquivo de projeto:

using CarClass; 
using Newtonsoft.Json; 
namespace PersistenceServices 
{ 
   public static class Persistence 
   { 
      const string JSONFILE = @"./cars.json"; 
      public static void WriteCarsToFile(List<Car> cars) 
      {  
         WriteToFile(cars); 
      } 

      public static List<Car> ReadCarsFromFile() 
      { 
         return ReadFromFile<Car>(JSONFILE); 
      } 
      
      private static void WriteToFile<T>(List<T> list) 
      { 
         string jsonString = JsonConvert.SerializeObject(list, Formatting.Indented); 
         File.WriteAllText(JSONFILE, jsonString); 
      } 

      private static List<T> ReadFromFile<T>(string filename) 
      { 
         List<T>? list = null; 
         if (File.Exists(filename)) 
         { 
            string jsonString = File.ReadAllText(filename); 
            list = JsonConvert.DeserializeObject<List<T>>(jsonString); 
         } 
         else Console.WriteLine("No existing file found for " + filename); 
         
         return list ?? new List<T>(); 
      } 
   } 
}

Observe que os dois métodos que realmente chamam JsonConvert não precisa saber nada sobre o tipo que está sendo convertido; eles funcionam com qualquer lista genérica de tipos.

Aqui está a viagem de ida e volta, que altera a quilometragem de serviço do segundo carro:

using CarClass; 
using Newtonsoft.Json; 
using PersistenceServices; 

List<Car> cars = new List<Car>(); 
Car car = new Car("Saab", "V90", Car.CarColor.Red); 
Console.WriteLine($"First car: {car}"); 
cars.Add(car); 

car = new Car("Volkswagen", "Polo", Car.CarColor.White); 
Console.WriteLine($"Uncle's car: {car}"); cars.Add(car); 
Persistence.WriteCarsToFile(cars); 

List<Car> cars2 = Persistence.ReadCarsFromFile(); 
cars2.Last().MileageAtLastService = 2500; 

Persistence.WriteCarsToFile(cars2);

O arquivo resultante está formatado corretamente:.

OK, então criamos alguma persistência para um arquivo simples usando JSON, usando um pacote específico. Acabamos com estes arquivos em nosso espaço de trabalho do projeto:

Agora vamos tentar ver até onde podemos chegar com o Lhama 3. Vamos detalhar o que fizemos.

• Criou uma classe simples para representar um carro próprio.
• Transformei em json.
• Usei o formato JSON para salvar e carregar em um arquivo local.

Então primeiro vamos pedir uma aula de carro. A consulta é “Crie uma classe C# que represente um carro próprio com estes atributos: marca, marca, milhas desde o último serviço e cor”.

Ótimo. Também deu exemplos de uso da classe e configuração das propriedades. Vejamos se conseguimos convencê-lo a tornar a propriedade da cor uma enumeração:

Foi o que aconteceu! Mesmo com meu erro ortográfico no pedido!

Agora vamos ver se ele pode usar JSON para converter. Vamos forçá-lo a usar o Newtonsoft.json também.

Ele acha que esta será a saída:

Claro, já sabemos que isso não funcionará como está. Precisamos consertar o enum. Poderíamos tentar dizer isso ao Lhama, mas só sabemos que não é correto porque já estivemos aqui antes. Porém, vamos buscar a vitória.

A boa notícia é que o Llama 3 foi rápido, bem formatado e bom com os requisitos básicos.

• Isso nos permitiu trabalhar no código de forma contínua ao longo do tempo em um único thread.
• Ele entendeu como usar um pacote nomeado arbitrariamente.
• Ele criou corretamente instâncias de exemplo de Carro, bem como algumas belas cores de carros.
• As respostas estão bem formatadas.

O que deu errado foi um detalhe que eu já havia trabalhado com antecedência. Isso nos deixa praticamente no mesmo lugar em que estivemos o tempo todo com a codificação LLM: ela pode criar rapidamente um modelo de trabalho que podemos adaptar, mas terá imprecisões que exigirão correção. Isso significa que é uma ferramenta de inicialização útil para um desenvolvedor em atividade mas ainda não é uma espécie de criador de soluções mágicas.

O post Teste de codificação para Llama 3: Implementando a persistência JSON apareceu pela primeira vez em The New Stack.