LLama para Economistas

Llama é um modelo de inteligência generativa (GPT), criada pela Meta, a companhia mãe do Facebook, Instagram, WhatsApp e Threads. Ao contrário de suas contrapartes pagas online (Chat GPT da Open AI, Gemini do Google Claude.AI da Anthropic, Copilot da Microsoft, Grok do X- antigo Twitter, dentre outros), a Llama oferece uma comodidade entre os GPTs, qual seja ele passível de download e uso na sua própria máquina. As vantagens disso envolvem não dispender recursos pagando por requisições de API e não ter os limites de tokens de input e output existentes nos GPTs comerciais. 

Assim, por exemplo, se você quer analisar o conteúdo de um arquivo pdf de 250 páginas, os GPTs comerciais podem te impedir de fazer isso, devido ao fato de isso estourar seus limites de tokens de inputs. Ao mesmo tempo, se você demanda uma resposta mais longa dos GPTs, esses limites de output, às vezes menores que os limites de input, podem também limitar seu trabalho. 

O presente texto tem por objetivo exibir a aplicação de uma instalação local da Llama para uma tarefa que se aplicada pelos GPTs comerciais encontrariam limitações imediatas no uso de tokens. Num primeiro momento, explico como a instalação da Llama deve ocorrer na sua máquina. Num segundo momento, exibo a tarefa preditiva de texto que irei aplicar o modelo aqui. Por fim, exibo o código e os resultados dessa aplicação. Todas essas análises foram realizadas num MacBook Air M1, com 8GB de memória RAM e 256GB de memória física, do tipo SSD NVMe. 

1. Instalação da LLama

# Guia de Instalação do Llama
Este guia fornecerá instruções passo a passo para instalar o Llama em seu computador pessoal.
## Pré-requisitos

Antes de começar, certifique-se de que seu sistema atende aos seguintes requisitos:
- Sistema operacional: Windows 10/11, macOS, ou Linux
- Mínimo de 16GB de RAM (recomendado 32GB)
- Espaço livre em disco: pelo menos 10GB
- Python 3.9 ou superior instalado
- Git instalado
## Passo 1: Preparar o Ambiente
1. Abra um terminal ou prompt de comando
2. Crie um novo diretório para o projeto:
```bash
mkdir llama-project
cd llama-project
```
3. Crie um ambiente virtual Python:
```bash
python -m venv llama-env
```
4. Ative o ambiente virtual:
- Windows:
```bash
llama-env\Scripts\activate
```
- macOS/Linux:
```bash
source llama-env/bin/activate
```
## Passo 2: Clonar o Repositório
Clone o repositório oficial do Llama:
```bash
git clone https://github.com/facebookresearch/llama.git
cd llama
```
## Passo 3: Instalar Dependências
Instale as dependências necessárias:
```bash
pip install -r requirements.txt
pip install torch torchvision torchaudio
```
## Passo 4: Baixar o Modelo
1. Acesse o site oficial da Meta AI para solicitar acesso aos modelos
2. Após receber aprovação, baixe o modelo desejado
3. Extraia os arquivos do modelo para a pasta `models` dentro do diretório do projeto
## Passo 5: Configuração Final

1. Crie um arquivo de configuração chamado `config.json`:
```json
{
    "model_path": "./models/llama-2-7b",
    "max_seq_len": 512,
    "max_batch_size": 32
}
```
2. Ajuste os parâmetros conforme necessário baseado em seu hardware
## Passo 6: Teste a Instalação
Execute o script de teste para verificar se tudo está funcionando corretamente:

```bash
python3 example.py
```
## Solução de Problemas Comuns
### Erro de CUDA não encontrado
- Verifique se você tem uma GPU NVIDIA compatível
- Instale os drivers CUDA mais recentes
- Reinstale o PyTorch com suporte a CUDA
### Erro de Memória Insuficiente
- Reduza o tamanho do batch no arquivo de configuração
- Feche outros programas que consumam muita memória
- Considere usar um modelo menor
### Problemas de Importação de Módulos
- Verifique se o ambiente virtual está ativado
- Confirme se todas as dependências foram instaladas corretamente
- Tente reinstalar as dependências
## Dicas de Otimização
1. Para melhor desempenho:
   - Use uma GPU NVIDIA com pelo menos 8GB de VRAM
   - Mantenha os drivers atualizados
   - Use SSD para armazenamento do modelo
2. Para uso em CPU:
   - Ajuste o tamanho do batch para menor
   - Considere usar modelos quantizados
   - Aumente o tamanho da memória virtual se necessário
## Próximos Passos
Após a instalação bem-sucedida, você pode:
1. Experimentar diferentes modelos do Llama
2. Ajustar os parâmetros de geração
3. Integrar o Llama em seus próprios projetos
4. Explorar técnicas de otimização e fine-tuning
## Recursos Adicionais
- Documentação oficial do Llama
- Fórum da comunidade
- Exemplos de código e aplicações
- Guias de otimização e fine-tuning
## Suporte
Se encontrar problemas durante a instalação:
1. Consulte a documentação oficial
2. Verifique issues no GitHub
3. Participe do fórum da comunidade
4. Reporte bugs no repositório oficial

2. Classificação Temática de Estudos que empregam Modelos Quantitativos de Comércio

2.1. Busca no Google

Nesta fase, selecionamos os estudos que usaremos para realizar a classificação. A questão a ser respondida é a seguinte: no universo dos papers analisados, quantos deles: (i) mencionam o método exact-hat algebra?; (ii) usam o método exact-hat algebra? A busca no Google Scholar é a seguinte: “quantitative trade model” e consideramos as 15 primeiras respostas válidas como nossa amostra para esse exercício. Os artigos considerados são listados ao fim desse tutorial. Este é só um exemplo e a Llama local no seu computador te permite ganhos pronunciados se você precisar repetir esse tipo de atividade para 100,200 artigos.

2.2. Código no R

O código do R é composto de algumas etapas: (i) ele lê o arquivo pdf, tokeniza-o, o envia ao Llama junto com a query e em seguida tem a resposta em formatos de tokens que precisam ser novamente organizados segundo uma função própria do R. O código comentado e completo segue abaixo:

# Instalação dos pacotes necessários
required_packages <- c("pdftools", "httr", "jsonlite", "stringr", "dplyr", "tidyr")
new_packages <- required_packages[!(required_packages %in% installed.packages()[,"Package"])]
if(length(new_packages)) install.packages(new_packages)

# Carregamento das bibliotecas necessárias
library(pdftools)   # Para leitura de PDFs
library(httr)       # Para requisições HTTP
library(jsonlite)   # Para manipulação de JSON
library(stringr)    # Para manipulação de strings
library(dplyr)      # Para manipulação de dados
library(tidyr)      # Para organização de dados

#' Função para pré-processamento do texto
#' @param text String de texto a ser pré-processada
#' @return Texto pré-processado
preprocess_text <- function(text) {
  # Converte para minúsculas
  text <- tolower(text)
  
  # Remove caracteres especiais
  text <- stringr::str_replace_all(text, "[^[:alnum:][:space:]]", " ")
  
  # Normaliza espaços
  text <- stringr::str_squish(text)
  
  return(text)
}

#' Função para tokenização do texto
#' @param text String de texto a ser tokenizada
#' @return Vetor de tokens
tokenize_text <- function(text) {
  tokens <- unlist(stringr::str_split(text, "\\s+"))
  return(tokens)
}

#' Verifica se o serviço Ollama está rodando
#' @return Booleano indicando se o serviço está disponível
check_ollama_connection <- function() {
  tryCatch({
    response <- httr::GET("http://localhost:11434/api/tags")
    return(httr::status_code(response) == 200)
  }, error = function(e) {
    return(FALSE)
  })
}

#' Classifica o documento exacthatusendo a API do Ollama
#' @param text Texto a ser classificado
#' @return Lista contendo resultados da classificação
classify_document <- function(text) {
  # Prepara o prompt com as instruções
  prompt <- "INSTRUCTION:
YOU MUST ANSWER EXACTLY IN THIS FORMAT:
FORMAT:

First line: exacthat (SIM or NÃO)
Second line: exacthatuse (SIM or NÃO)
Third line onwards: text of maximum 150 words justifying the answers

VALID RESPONSE EXAMPLE:
SIM
NÃO
The article mentions the exact-hat algebra method in its literature review, citing it as one of the existing approaches for equilibrium analysis. However, the article does not apply this method in its empirical analysis, opting instead to use a different approach based on spatial econometrics.
RULES:

Answer if the text mentions any of these variations: exacthat algebra, exact-hat algebra, exact hat algebra, or any combination of these terms with different spacing or hyphenation
Answer if the text effectively uses any of the above variations of exact hat algebra as an analytical method
Justify your answers in up to 150 words

TEXT:
"
  
  # Limita o tamanho do texto e combina com o prompt
  text_limited <- substr(text, 1, 100000)
  full_prompt <- paste0(prompt, text_limited)
  
  # Prepara a requisição para a API
  url <- "http://localhost:11434/api/generate"
  body <- list(
    model = "llama3.2:latest",
    prompt = full_prompt,
    stream = FALSE
  )
  
  tryCatch({
    # Faz a requisição para a API
    response <- httr::POST(
      url,
      body = jsonlite::toJSON(body, auto_unbox = TRUE),
      httr::add_headers("Content-Type" = "application/json")
    )
    
    # Verifica se a requisição foi bem-sucedida
    if (httr::status_code(response) == 200) {
      # Processa a resposta
      result <- httr::content(response, "parsed")$response
      print(paste("Resposta bruta:", result))  # Saída para debug
      
      # Divide a resposta em linhas
      lines <- unlist(strsplit(result, "\n"))
      
      # Extrai as classificações e explicação
      exacthat <- trimws(toupper(lines[1])) == "SIM"
      exacthatuse <- trimws(toupper(lines[2])) == "SIM"
      
      # Obtém a explicação (todas as linhas após as duas primeiras)
      explanation <- paste(lines[-(1:2)], collapse = "\n")
      
      return(list(
        exacthat = exacthat,
        exacthatuse = exacthatuse,
        explanation = explanation
      ))
    } else {
      return(list(
        exacthat = FALSE,
        exacthatuse = FALSE,
        explanation = "Erro: Falha na requisição da API",
        error = "Falha na requisição da API"
      ))
    }
  }, error = function(e) {
    return(list(
      exacthat = FALSE,
      exacthatuse = FALSE,
      explanation = paste("Erro:", as.character(e)),
      error = as.character(e)
    ))
  })
}

#' Processa um único documento PDF
#' @param file_path Caminho para o arquivo PDF
#' @return Lista contendo resultados da análise
process_document <- function(file_path) {
  tryCatch({
    # Verifica conexão com Ollama
    if (!check_ollama_connection()) {
      stop("Não foi possível conectar ao Ollama. Verifique se o serviço está rodando.")
    }
    
    # Lê o PDF
    text <- pdftools::pdf_text(file_path)
    text <- paste(text, collapse = " ")
    
    # Pré-processa o texto
    processed_text <- preprocess_text(text)
    tokens <- tokenize_text(processed_text)
    
    # Classifica o documento
    classification <- classify_document(processed_text)
    
    # Retorna resultados
    return(list(
      file_path = file_path,
      exacthat = classification$exacthat,
      exacthatuse = classification$exacthatuse,
      explanation = classification$explanation,
      token_count = length(tokens),
      sample_tokens = head(tokens, 10),
      status = "success"
    ))
  }, error = function(e) {
    return(list(
      file_path = file_path,
      status = "error",
      error_message = as.character(e)
    ))
  })
}

#' Processa múltiplos documentos PDF
#' @param file_paths Vetor com caminhos dos arquivos PDF
#' @param output_file Caminho para arquivo CSV de saída (opcional)
#' @return Data frame com resultados
process_multiple_documents <- function(file_paths, output_file = NULL) {
  # Processa todos os documentos
  results <- lapply(file_paths, process_document)
  
  # Converte resultados para data frame
  results_df <- bind_rows(lapply(results, function(x) {
    if (x$status == "success") {
      data.frame(
        file_path = x$file_path,
        status = x$status,
        exacthat = as.numeric(x$exacthat),  # Converte para 1/0
        exacthatuse = as.numeric(x$exacthatuse),            # Converte para 1/0
        explanation = x$explanation,
        token_count = x$token_count,
        sample_tokens = paste(x$sample_tokens, collapse = ", ")
      )
    } else {
      data.frame(
        file_path = x$file_path,
        status = x$status,
        exacthat = NA,
        exacthatuse = NA,
        explanation = NA,
        token_count = NA,
        sample_tokens = NA,
        error_message = x$error_message
      )
    }
  }))
  
  # Salva em CSV se o arquivo de saída for especificado
  if (!is.null(output_file)) {
    write.csv(results_df, output_file, row.names = FALSE)
  }
  
  return(results_df)
}

# Exemplo de uso
# Substitua o caminho abaixo pelo caminho correto dos seus arquivos
files <- list.files("path_dos_arquivos_pdf", full.names = TRUE)
results <- process_multiple_documents(files, "resultados_analise.csv")
print(results)

3. Resultados

3.1. Tipo de Resposta Gerada

Os resultados a seguir se referem a Mei (2020) e são usados como exemplo:

exacthat:0

exacthatuse:0

Resumo Curto

The text appears to be discussing various aspects of international trade, economic policy, and game theory. Here are some possible summary points:

1. **Trade models**: The text discusses different types of trade models, including infinite punishment, finite punishment, and punishment with finite periods.
2. **Nash equilibrium**: The authors discuss the concept of Nash equilibrium in repeated games, where countries cooperate on tariffs to maximize their welfare.
3. **Sustainability of cooperative equilibria**: The text explores the conditions under which cooperative equilibria are sustainable, including the minimum patience parameter βj and the length of the punishment phase kj.
4. **Tariff data**: The authors use various sources of tariff data, including the Global Trade Analysis Project (GTAP) database and the US export data.
5. **Trade policy analysis**: The text discusses the importance of quantitative trade policy analysis in understanding the impact of trade policies on economic outcomes.
Please let me know if you have any specific questions or topics you’d like me to help with. I’ll do my best to assist you!

4. Conclusão

Esta foi simplesmente uma aplicação curta do Llama para uma tarefa de natureza de revisão de literatura. Ainda assim, em poucos minutos, é possível extrair-se informação de muitos dados de forma ordenada. Alternativas mais arcaicas de levantamento desse tipo de informação envolvem esforços pronunciados em termos intelectuais e de tempo. O exemplo exibido aqui pode ser usado com uma primeira filtragem para esse tipo de trabalho mais demorado. Ao mesmo tempo, este exemplo apenas uma das possibilidades que uma GPT local abre em termos analíticos e de processo. 

5. Referências Bibliográficas

Adao, R., Costinot, A., & Donaldson, D. (2022). Putting quantitative trade models to the test: Evidence from the Trump tariffs. mimeo.

Bekkers, E., & Koopman, R. B. (2022). Simulating the trade effects of the COVID‐19 pandemic: Scenario analysis based on quantitative trade modelling. The World Economy45(2), 445-467.

Bekkers, E., & Rojas‐Romagosa, H. (2019). The welfare effects of free trade agreements in quantitative trade models: A comparison of studies about Transatlantic Trade and Investment Partnership. The World Economy42(1), 87-121.

Blank, S., Egger, P. H., Merlo, V., & Wamser, G. (2022). A structural quantitative analysis of services trade de-liberalization. Journal of International Economics137, 103605.

Che, Z., Che, J., & Wang, S. (2024). The gains from changes in internal trade costs: A quantitative analysis of China. Journal of Regional Science.

Egger, P. H., & Erhardt, K. (2024). Heterogeneous effects of tariff and nontariff trade‐policy barriers in quantitative general equilibrium. Quantitative Economics15(2), 453-487.

Felbermayr, G., Gröschl, J. K., & Heiland, I. (2018). Undoing Europe in a new quantitative trade model (No. 250). Ifo working paper.

Huang, X., & Chen, X. (2022). A quantitative model of international trade based on deep neural network. Computational Intelligence and Neuroscience2022(1), 9811358.

Krebs, O., & Pflüger, M. (2018). How deep is your love? A quantitative spatial analysis of the transatlantic trade partnership. Review of International Economics26(1), 171-222.

Mei, Y. (2020). Sustainable cooperation in international trade: A quantitative analysis. Journal of International Economics123, 103305.

Lee, K. Y. (2018). A quantitative trade model with unemployment. KIEP Research Paper. Working paper, 18-04.

Ritel, M. (2022). A Quantitative Analysis of Trade Cooperation Over Three Decades. Available at SSRN 4252542.

Thoenig, M. (2023). Trade policy in the shadow of war: A quantitative toolkit for geoeconomics. Centre for Economic Policy Research.

Walter, T. (2022). Applied policy research through the lens of new quantitative trade models.

Yu, Z., Han, J., Shi, X., & Yang, Y. (2024). Estimates of the trade and global value chain (GVC) effects of China’s Pilot Free Trade Zones: a research based on the quantitative trade model. Journal of the Asia Pacific Economy, 1-48.

Scroll to top