app.py

# Tamanho do vocabulário
vocab_size = 13
# Comprimento da sequência
sequence_length = 4
# Comprimento do resultado
result_length = 2
# Comprimento do contexto
context_length = sequence_length + result_length
# Parâmetros de configuração do modelo GPT-2
config = AutoConfig.from_pretrained("gpt2", 
                                    vocab_size = vocab_size, 
                                    n_ctx = context_length, 
                                    n_head = 4, 
                                    n_layer = 2) 

# Carrega o modelo
modelo = AutoModelForCausalLM.from_config(config)
# Função para calcular o tamanho do modelo
def model_size(model):
    return sum(t.numel() for t in modelo.parameters())
print(f'Tamanho do Modelo: {model_size(modelo)/1000**2:.1f}M parâmetros')
#Tamanho do Modelo: 15.0M parâmetros
#Este modelo tem 15 milhões de parâmetros em vez dos 111 milhões de parâmetros da configuração padrão "gpt2".

type(modelo)
transformers.models.gpt2.modeling_gpt2.GPT2LMHeadModel
# Salva o modelo em disco
modelo.save_pretrained("modelos/modelo_inicial")

# Definindo uma classe chamada NumberTokenizer, que é usada para tokenizar os números
class DSATokenizer:
    
    # Método construtor da classe, que é executado quando um objeto dessa classe é criado
    def __init__(self, numbers_qty = 10):
        
        # Lista de tokens possíveis que o tokenizador pode encontrar
        vocab = ['+', '=', '-1', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
        
        # Definindo a quantidade de números que o tokenizador pode lidar
        self.numbers_qty = numbers_qty
        
        # Definindo o token de preenchimento (padding)
        self.pad_token = '-1'
        
        # Criando um dicionário que mapeia cada token para um índice único
        self.encoder = {str(v):i for i,v in enumerate(vocab)}
        
        # Criando um dicionário que mapeia cada índice único de volta ao token correspondente
        self.decoder = {i:str(v) for i,v in enumerate(vocab)}
        
        # Obtendo o índice do token de preenchimento no encoder
        self.pad_token_id = self.encoder[self.pad_token]

    # Método para decodificar uma lista de IDs de token de volta para uma string
    def decode(self, token_ids):
        return ' '.join(self.decoder[t] for t in token_ids)

    # Método que é chamado quando o objeto da classe é invocado como uma função
    def __call__(self, text):
        # Dividindo o texto em tokens individuais e retornando uma lista dos IDs correspondentes
        return [self.encoder[t] for t in text.split()]
    

# Cria o objeto do tokenizador
tokenizer = DSATokenizer(vocab_size)
# Decoder do tokenizador
tokenizer.decoder

# Testando o tokenizador
tokenizer("1 + 1 = 2")

# Definindo uma classe chamada CriaDataset, que herda da classe Dataset do PyTorch
class CriaDataset(Dataset):

    # Método construtor da classe, que é executado quando um objeto dessa classe é criado
    def __init__(self, split, length = 6):
        
        # Verificando se a divisão do dataset (split) é 'treino' ou 'teste'
        assert split in {'treino', 'teste'}
        self.split = split
        self.length = length
    
    # Definindo o método len que retorna o tamanho do dataset. 
    # Nesse caso, o tamanho é fixo e igual a 1 milhão.
    def __len__(self):
        return 1000000 

    # Definindo o método getitem que é usado para obter um item específico do dataset
    def __getitem__(self, idx):

        # Criando uma lista com todos os números disponíveis que não são tokens de padding e são numéricos
        available_numbers = [int(n) for n in tokenizer.decoder.values() if n != tokenizer.pad_token and str(n).isnumeric()]
        
        # Selecionando aleatoriamente números da lista de números disponíveis para criar uma entrada (input)
        inp = torch.tensor(np.random.choice(available_numbers, size = result_length))
        
        # Calculando a soma dos números selecionados e criando um tensor
        sol = torch.tensor([int(i) for i in str(inp.sum().item())])
        
        # Preenchendo o tensor com zeros para que tenha o tamanho desejado
        sol = torch.nn.functional.pad(sol, (1 if sol.size()[0] == 1 else 0,0), 'constant', 0)

        # Concatenando a entrada e a solução em um tensor
        cat = torch.cat((inp, sol), dim = 0)

        # Criando os tensores de entrada e alvo para o treinamento do modelo
        x = cat[:-1].clone()
        y = cat[1:].clone()

        # Definindo o primeiro elemento do tensor alvo como o token de padding
        y[:1] = int(tokenizer.pad_token)

        # Transformando os tensores x e y em strings
        x = str(x[0].item()) + ' + ' + str(x[1].item()) + ' = ' + str(x[2].item())
        y = '-1 ' + str(y[0].item()) + ' -1 ' + str(y[1].item()) + ' ' + str(y[2].item())
        
        # Tokenizando as strings de entrada e alvo
        tokenized_input = tokenizer(x)
        tokenized_output = tokenizer(y)
        
        # Retornando os tensores de entrada e alvo como itens do dataset
        return torch.tensor(tokenized_input), torch.tensor(tokenized_output)
    
dataset_treino = CriaDataset('treino', length = sequence_length)
dataset_teste = CriaDataset('teste', length = sequence_length)
x, y = dataset_treino[0]
x

y

print(tokenizer.decode(x.numpy()))
print(tokenizer.decode(y.numpy()))

num_epochs = 2
batch_size = 100
optimizer = torch.optim.Adam(modelo.parameters())
dados = torch.utils.data.DataLoader(dataset_treino, shuffle = True, batch_size = batch_size)

import accelerate
from accelerate import Accelerator
accelerator = Accelerator()

modelo, optimizer, dados = accelerator.prepare(modelo, optimizer, dados)

modelo.train()


# Iniciando o loop para as épocas de treinamento
for epoch in range(num_epochs):

    # Iterando por cada batch (conjunto) de dados de entrada e alvos no dataset de treinamento
    for source, targets in dados:

        # Resetando os gradientes acumulados no otimizador
        optimizer.zero_grad()

        # Calculando a perda (loss) através da entropia cruzada entre as previsões do modelo e os alvos verdadeiros. 
        # Os tensores são "achatados" para que possam ser passados para a função de entropia cruzada. 
        # O índice do token de preenchimento (pad_token) é ignorado no cálculo da perda.
        loss = F.cross_entropy(modelo(source).logits.flatten(end_dim = 1), 
                               targets.flatten(end_dim = 1), 
                               ignore_index = tokenizer.pad_token_id)

        # Calculando os gradientes da perda em relação aos parâmetros do modelo
        accelerator.backward(loss)

        # Atualizando os parâmetros do modelo utilizando os gradientes calculados
        optimizer.step()

        # Recalculando a perda após a etapa de otimização. 
        loss = F.cross_entropy(modelo(source).logits.flatten(end_dim = 1), 
                               targets.flatten(end_dim = 1), 
                               ignore_index = tokenizer.pad_token_id)

    # Imprimindo a época atual e a perda após cada época de treinamento
    print(f'Epoch: {epoch+1}/{num_epochs} --- Erro: {loss.item()}')

# Definindo a função gera_solution com três parâmetros: input, solution_length e model
def faz_previsao(entrada, solution_length = 6, model = modelo):

    # Colocando o modelo em modo de avaliação. 
    model.eval()

    # Convertendo a entrada (string) em tensor utilizando o tokenizer. 
    # O tensor é uma estrutura de dados que o modelo de aprendizado de máquina pode processar.
    entrada = torch.tensor(tokenizer(entrada))

    # Enviando o tensor de entrada para o dispositivo de cálculo disponível (CPU ou GPU)
    entrada = entrada.to(accelerator.device)

    # Iniciando uma lista vazia para armazenar a solução
    solution = []

    # Loop que gera a solução de comprimento solution_length
    for i in range(solution_length):

        # Alimentando a entrada atual ao modelo e obtendo a saída
        saida = model(entrada)

        # Pegando o índice do maior valor no último conjunto de logits (log-odds) da saída, 
        # que é a previsão do modelo para o próximo token
        predicted = saida.logits[-1].argmax()

        # Concatenando a previsão atual com a entrada atual. 
        # Isso servirá como a nova entrada para a próxima iteração.
        entrada = torch.cat((entrada, predicted.unsqueeze(0)), dim = 0)

        # Adicionando a previsão atual à lista de soluções e convertendo o tensor em um número Python padrão
        solution.append(predicted.cpu().item())

    # Decodificando a lista de soluções para obter a string de saída e retornando-a
    return tokenizer.decode(solution)

# Definindo a função avalia_modelo com dois parâmetros: num_samples e log
def avalia_modelo(num_samples = 1000, log = False):

    # Iniciando um contador para as previsões corretas
    correct = 0

    # Loop que itera num_samples vezes
    for i in range(num_samples):

        # Obtendo a entrada e o alvo (resposta correta) do i-ésimo exemplo do conjunto de teste
        entrada, target = dataset_teste[i]

        # Convertendo os tensores de entrada e alvo em arrays numpy para processamento posterior
        entrada = entrada.cpu().numpy()
        target = target.cpu().numpy()

        # Decodificando a entrada e o alvo utilizando o tokenizer
        entrada = tokenizer.decode(entrada[:sequence_length])
        target = tokenizer.decode(target[sequence_length-1:])

        # Gerando a previsão utilizando a função faz_previsao
        predicted = faz_previsao(entrada, solution_length = result_length, model = modelo)
 
        # Se a previsão for igual ao alvo, incrementa o contador de previsões corretas
        if target == predicted:
            correct += 1
            # Se log for True, imprime detalhes do exemplo e a previsão correta
            if log:
                print(f'Acerto do Modelo: Input: {entrada} Target: {target} Previsão: {predicted}')
        else:
            # Se log for True, imprime detalhes do exemplo e a previsão errada
            if log:
                print(f'Erro do Modelo: Input: {entrada} Target: {target} Previsão: {predicted}')

    # Ao final do loop, calcula a acurácia (número de previsões corretas dividido pelo número total de exemplos) 
    print(f'Acurácia: {correct/num_samples}')

# Executa a função
avalia_modelo(num_samples = 10, log = True)

# Executa a função
avalia_modelo(num_samples = 1000, log = False)

type(modelo)

modelo.save_pretrained("modelos/modelo_final")



modelo_llm = AutoModelForCausalLM.from_pretrained("modelos/modelo_final")

# Definindo uma classe chamada NumberTokenizer, que é usada para tokenizar os números
class DSATokenizer:
    
    # Método construtor da classe, que é executado quando um objeto dessa classe é criado
    def __init__(self, numbers_qty = 10):
        
        # Lista de tokens possíveis que o tokenizador pode encontrar
        vocab = ['+', '=', '-1', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
        
        # Definindo a quantidade de números que o tokenizador pode lidar
        self.numbers_qty = numbers_qty
        
        # Definindo o token de preenchimento (padding)
        self.pad_token = '-1'
        
        # Criando um dicionário que mapeia cada token para um índice único
        self.encoder = {str(v):i for i,v in enumerate(vocab)}
        
        # Criando um dicionário que mapeia cada índice único de volta ao token correspondente
        self.decoder = {i:str(v) for i,v in enumerate(vocab)}
        
        # Obtendo o índice do token de preenchimento no encoder
        self.pad_token_id = self.encoder[self.pad_token]

    # Método para decodificar uma lista de IDs de token de volta para uma string
    def decode(self, token_ids):
        return ' '.join(self.decoder[t] for t in token_ids)

    # Método que é chamado quando o objeto da classe é invocado como uma função
    def __call__(self, text):
        # Dividindo o texto em tokens individuais e retornando uma lista dos IDs correspondentes
        return [self.encoder[t] for t in text.split()]

# Cria o objeto
tokenizer = DSATokenizer(13)

# Definindo a função gera_solution com três parâmetros: input, solution_length e model
def faz_previsao(entrada, solution_length = 6, model = modelo_llm):

    # Colocando o modelo em modo de avaliação. 
    model.eval()

    # Convertendo a entrada (string) em tensor utilizando o tokenizer. 
    # O tensor é uma estrutura de dados que o modelo de aprendizado de máquina pode processar.
    entrada = torch.tensor(tokenizer(entrada))

    # Iniciando uma lista vazia para armazenar a solução
    solution = []

    # Loop que gera a solução de comprimento solution_length
    for i in range(solution_length):

        # Alimentando a entrada atual ao modelo e obtendo a saída
        saida = model(entrada)

        # Pegando o índice do maior valor no último conjunto de logits (log-odds) da saída, 
        # que é a previsão do modelo para o próximo token
        predicted = saida.logits[-1].argmax()

        # Concatenando a previsão atual com a entrada atual. 
        # Isso servirá como a nova entrada para a próxima iteração.
        entrada = torch.cat((entrada, predicted.unsqueeze(0)), dim = 0)

        # Adicionando a previsão atual à lista de soluções e convertendo o tensor em um número Python padrão
        solution.append(predicted.cpu().item())

    # Decodificando a lista de soluções para obter a string de saída e retornando-a
    return tokenizer.decode(solution)

# Testa a função
faz_previsao('3 + 5 =', solution_length = 2)

# Função para retornar a função que faz a previsão
def funcsolve(entrada):
    return faz_previsao(entrada, solution_length = 2)


# Cria a web app
webapp = gr.Interface(fn = funcsolve, 
                      inputs = [gr.Textbox(label = "Dados de Entrada", 
                                           lines = 1, 
                                           info = "Os dados devem estar na forma: '1 + 2 =' com um único espaço entre cada caractere e apenas números de um dígito são permitidos.")],
                      outputs = [gr.Textbox(label = "Resultado (Previsão do Modelo)", lines = 1)],
                      title = "Deploy de LLM Após o Fine-Tuning",
                      description = "Digite os dados de entrada e clique no botão Submit para o modelo fazer a previsão.",
                      examples = ["5 + 3 =", "2 + 9 ="]) 


webapp.launch()