Meu código Python é uma rede neural

• Humanos são ruins em gerenciar código espaguete
• Em projetos de pesquisa, muitas vezes é preciso escrever programas para extrair informações de dados brutos
• Os dados não seguem especificações claras
• Exemplos:
  • identificar empresas e executivos em artigos de notícias
  • rotular contratos de compras públicas por tipo de serviço
  • identificar código de programa em mensagens entre engenheiros

Detectando código de programa em mensagens

• Resolve o problema de detectar, durante a revisão de código, se uma mensagem faz referência a código de programa
• Mensagens de exemplo:
  • LGTM with render_ipa_alloc()
  • If the FTPSACK flag is set, then use a prespecified value
  • AFAICT there is nothing else to check (unless you can think of something)
  • Actually, debug_error() doesn’t return NULL, so we should use IS_ERROR() here
  • This fails to build on aarch64 even though it works without issue on amd64
  • I’ve added if (err) goto cleanup; but the code still leaks

Ideia de regras de decisão

• Uma abordagem que usa regras simples para distinguir código de programa de inglês comum
• Regras:
  1. Uma palavra seguida de parênteses é código
  2. Uma palavra toda em maiúsculas é código
  3. Uma palavra que não é inglês é código
• Pontos fortes e fracos de cada regra:
  • Regra 1: simples, mas perde casos positivos óbvios
  • Regra 2: classifica incorretamente siglas em maiúsculas como código de programa
  • Regra 3: classifica incorretamente termos de engenharia como código de programa

Algoritmo escrito à mão

• Conclui que um algoritmo simples pode funcionar bem o suficiente
• Decide em duas etapas se a mensagem contém código:
  1. pré-processamento: converter a mensagem em uma sequência de tokens
  2. inferência: aplicar regras à sequência de tokens para decidir se contém código
• Exemplo implementado em Python:

  from dataclasses import dataclass  
  
  Token = str  
  
  @dataclass  
  class State:  
      previous_was_identifier: bool = False  
      previous_was_open_paren: bool = False  
      previous_previous_was_identifier: bool = False  
      seen_code: bool = False  
  
  def contains_code(tokens: Iterable[Token]) -> bool:  
      state = State()  
      for token in tokens:  
          state = process(state, token)  
      return state.seen_code  
  
  def process(state: State, token: Token) -> State:  
      if state.seen_code:  
          return state  
      if (token == "close_paren" and state.previous_was_open_paren and state.previous_previous_was_identifier):  
          state.seen_code = True  
          return state  
      state.previous_previous_was_identifier = state.previous_was_identifier  
      state.previous_was_identifier = token in ("all_caps_identifier", "underscore_identifier", "misc_identifier")  
      state.previous_was_open_paren = token == "open_paren"  
      return state  
  

Ajuda das redes neurais

• É possível codificar contains_code e process como uma RNN, como uma máquina de estados
• Uma RNN pode ser usada para encontrar um algoritmo melhor

Ideia geral

• Uma RNN aproxima probabilidades condicionais
• Calcula um vetor de estado para cada token
• Classifica a mensagem com base no estado final

Código Python visto pela matemática

• Explica como uma RNN codifica a regra 1
• Representa cada token como um vetor binário
• Calcula o estado oculto para aplicar a regra

Treinamento da rede

• Para treinar a RNN, a função de ativação é trocada para ReLU
• É possível treinar usando PyTorch

Arquitetura com implementação mais eficiente

• Usa arquiteturas fornecidas pelo PyTorch, como a Elman RNN
• Na Elman RNN, cada camada oculta usa como entrada tanto a camada anterior quanto a camada atual

Arquitetura com gradientes mais estáveis

• Mensagens longas causam problemas porque os gradientes ficam próximos de 0
• Arquiteturas como GRU ou LSTM podem mostrar desempenho melhor

Disciplina orientada por dados

• RNNs lidam melhor com código espaguete
• Forçam uma disciplina orientada por dados, tornando o problema mais claro

Opinião do GN⁺

• Este artigo explica bem como usar RNNs para resolver problemas complexos
• Usar RNNs facilita a manutenção do código
• Ferramentas como PyTorch permitem uma implementação eficiente
• Vale considerar arquiteturas como GRU ou LSTM
• Uma abordagem orientada por dados é útil para resolver o problema

[GN⁺]

Opiniões no Hacker News

• Este texto não aborda muito testes nem dados de treinamento

  • A razão pela qual se acha que o código é compreendido é que suas propriedades generalizadas foram provadas informalmente
  • No caso de redes neurais, o problema é que não dá para saber como elas vão generalizar para novas entradas
  • Se for possível definir bem as propriedades, é possível escrever testes baseados em propriedades para gerar muitos dados de teste
  • Isso não é uma prova, mas pode ser um ponto de partida
  • Depender de código espaguete ou de redes neurais pode ser algo parecido
  • Em vez de treinar uma rede neural, é possível escrever testes baseados em propriedades
  • Ainda assim, parece mais fácil confiar no código, porque ele pode ser depurado

• Este texto é interessante se for lido como uma forma de construir uma rede neural para realizar uma tarefa prática

  • O autor lida com o problema difícil de analisar entradas arbitrárias
  • Para resolver isso, ele propõe uma rede neural, mas isso ainda é difícil de entender
  • Código que possa ser compreendido pode ser melhor do que código difícil de ler

• Existe o Teorema da Aproximação Universal para redes neurais

  • Porém, não existe nenhum teorema que diga que é possível aprender essas aproximações

• Este texto trata de conceitos matemáticos profundos sobre RNN, mas oferece ideias interessantes

  • A abordagem de processar a string de entrada caractere por caractere é poderosa
  • Você escreve uma lógica fina de entrada e saída, e o restante é tratado pelo algoritmo

• Há quem questione se as RNNs foram completamente substituídas pelos transformers

• Vale a pena dar uma olhada em Programação Genética (Genetic Programming)

  • Não exige matemática e otimiza recombinando programas como AST
  • É possível escolher o que otimizar (por exemplo: velocidade, tamanho do programa, minimização de estruturas complexas etc.)

• Este texto trata RNN como uma experiência de aprendizado e a compara com a RNN do PyTorch

  • Questiona por que seria necessário adicionar três camadas ocultas à rede

• RNNs podem executar computação arbitrária, mas não são práticas

  • Este texto trata de como aprender uma máquina de estados, e aprender o significado real de Python é difícil

• Há uma opinião de que as redes neurais vão parecer cada vez mais com código

  • Transformar modelos no estilo MOE em chamadas de função será a próxima grande inovação