Analisando Bugs em Frameworks de Aprendizado Profundo

Frameworks de aprendizado profundo (DLFs) são ferramentas que ajudam desenvolvedores a criar aplicações de inteligência artificial (IA). Eles são importantes porque permitem que os usuários projetem, treinem e testem modelos que aprendem com dados. À medida que esses frameworks ficam mais populares, eles estão sendo usados em uma variedade de aplicações.

Um desafio que os desenvolvedores enfrentam é que a maioria dos DLFs usa várias linguagens de programação (PLs). Por exemplo, frameworks como TensorFlow costumam usar tanto Python quanto C++. Quando várias linguagens estão envolvidas, podem surgir bugs que são difíceis de rastrear. Entender esses bugs, especialmente os relacionados ao uso de múltiplas linguagens, é importante para desenvolver melhores frameworks.

Neste estudo, analisamos de perto 1.497 bugs encontrados em três DLFs: MXNet, PyTorch e TensorFlow. Ao analisar esses bugs, os classificamos em diferentes tipos, examinamos seus impactos no desenvolvimento e exploramos como bugs que envolvem múltiplas linguagens diferem daqueles que não envolvem.

#A Importância dos DLFs

Os DLFs desempenham um papel crucial no desenvolvimento de aplicações de IA. Eles fornecem blocos de construção essenciais para trabalhar com modelos de aprendizado profundo. À medida que o uso de IA continua crescendo, a necessidade de DLFs confiáveis e eficazes se torna ainda mais significativa. Bugs nesses frameworks podem levar a problemas que impactam sua confiabilidade, o que, por sua vez, pode afetar a qualidade e o desempenho geral das aplicações de IA.

Para que um framework seja confiável, é necessário entender a natureza dos bugs que aparecem. Estudos anteriores sobre bugs em DLFs podem ser categorizados em dois grupos:

1. Bugs no próprio framework, como falhas de design ou erros de codificação.
2. Bugs que surgem da maneira como os usuários interagem com o framework, como problemas de desempenho.

Ambas as categorias são importantes para serem abordadas a fim de criar DLFs robustos.

#Classificação de Bugs em DLFs

Na nossa investigação, classificamos 1.497 bugs do MXNet, PyTorch e TensorFlow em 12 tipos distintos. Esses tipos ajudam a entender melhor onde ocorrem os problemas e o que pode precisar de conserto.

1. Bugs de Design de Algoritmo: Questões relacionadas a erros em como os algoritmos são formulados dentro do framework.
2. Bugs de Build: Problemas que surgem durante o processo de compilação ou preparação do framework para uso.
3. Bugs de Código: Erros de lógica ou falhas no código escrito que podem levar a comportamentos inesperados.
4. Bugs de Dados: Problemas que acontecem com o processamento de dados antes de serem alimentados em um modelo.
5. Bugs de Implantação: Questões que surgem ao mover ou compartilhar um modelo treinado em diferentes ambientes.
6. Bugs de Documentação: Erros ou omissões na documentação do framework que podem confundir os usuários.
7. Bugs de Memória: Erros relacionados ao uso de memória do framework, resultando muitas vezes em travamentos ou lentidão.
8. Bugs de Desempenho: Questões que levam a uma velocidade ou eficiência insatisfatória nas operações do framework.
9. Bugs de Processador: Problemas que ocorrem quando um modelo opera em certos processadores ou configurações de hardware.
10. Bugs de Teste: Falhas no processo de teste, como casos de teste ausentes ou erros no código de exemplo.
11. Bugs de Compatibilidade de Versão: Problemas que surgem devido a mudanças na versão do framework que levam a problemas de compatibilidade.
12. Bugs de Visualização: Erros que ocorrem ao tentar visualizar resultados de modelos construídos usando o framework.

Classificando os bugs, os desenvolvedores podem identificar quais tipos são mais comuns e priorizar a correção deles.

#Impactos dos Bugs no Desenvolvimento

Descobrimos que diferentes tipos de bugs têm impactos variados no desenvolvimento dos DLFs. Para medir esses impactos, analisamos três áreas principais: quanto tempo os bugs ficam abertos antes de serem corrigidos, quão complexas são as mudanças de código necessárias para corrigir os bugs e quanto de comunicação é necessária entre os desenvolvedores durante a correção.

#Tempo Aberto dos Bugs

Tempo aberto se refere a quanto tempo um bug existe antes de ser resolvido. Bugs podem levar bastante tempo para serem consertados dependendo da sua complexidade. Por exemplo, bugs de implantação costumam levar mais tempo para serem resolvidos em comparação com bugs de build. Na nossa análise, descobrimos que bugs de implantação, documentação e memória tendem a ficar abertos por mais tempo, enquanto bugs de build geralmente são resolvidos mais rápido.

#Complexidade das Mudanças de Código

A complexidade das mudanças de código reflete o quão desafiador é para os desenvolvedores implementar correções. Examinamos três indicadores de complexidade:

• Linhas de Código Modificadas (LOCM): Quantas linhas no código precisam ser alteradas para consertar um bug.
• Número de Arquivos Modificados (NOFM): O total de diferentes arquivos que são afetados pela correção do bug.
• Entropia: Uma medida de incerteza ou confusão no processo de correção de bugs.

Bugs de memória, bugs de design de algoritmo e bugs de implantação foram encontrados como os que exigiam mais linhas de código a serem modificadas em todos os três frameworks. Em contrapartida, bugs de desempenho geralmente precisavam da menor modificação.

#Complexidade da Comunicação

Complexidade de comunicação olha para quantos desenvolvedores estão envolvidos e quanto de discussão é necessária para resolver os bugs. Bugs de memória, implementação e processador foram identificados como os que têm a maior complexidade em termos de comunicação. Isso significa que esses bugs costumam exigir a contribuição de vários membros da equipe para serem resolvidos.

#Bugs de Múltiplas Linguagens de Programação

Olhamos especificamente para bugs que envolvem o uso de múltiplas linguagens de programação, que chamamos de bugs de múltiplas linguagens de programação (MPL). Esses bugs podem ser mais difíceis de resolver do que os bugs de uma única linguagem (SPL).

Na nossa análise:

• 28,6% dos bugs no MXNet eram bugs MPL.
• 31,4% dos bugs no PyTorch eram bugs MPL.
• 16,0% dos bugs no TensorFlow eram bugs MPL.

A combinação de Python e C/C++ foi encontrada como a mais comum para consertar esses bugs. Essa combinação é popular entre os desenvolvedores pois permite o uso das funcionalidades amigáveis do Python enquanto aproveita o desempenho do C/C++.

#Comparação de Bugs MPL e SPL

Ao comparar bugs MPL e SPL, descobrimos que corrigir bugs MPL frequentemente requer mais mudanças de código do que bugs SPL. Além disso, nenhum indicador mostrou que bugs MPL eram mais fáceis de corrigir. Na verdade, eles tendiam a levar mais tempo para serem resolvidos e envolver mais discussão na equipe, especialmente no PyTorch.

#Conclusão e Direções Futuras

Neste estudo, examinamos bugs em três grandes frameworks de aprendizado profundo-MXNet, PyTorch e TensorFlow. Ao classificar 1.497 bugs em 12 tipos, fornecemos insights valiosos sobre seus impactos no desenvolvimento e os desafios impostos pelo uso de múltiplas linguagens de programação.

1. Classificação de Bugs: O estudo identificou com sucesso 12 tipos diferentes de bugs, destacando bugs de dados como os mais comuns entre todos os DLFs.
2. Impacto no Desenvolvimento: Bugs de implantação e memória são particularmente problemáticos, frequentemente exigindo mais tempo e esforço para serem corrigidos.
3. Bugs MPL: Uma porção significativa dos bugs lidava com múltiplas linguagens de programação, o que complica o processo de correção.

Olhando para o futuro, pretendemos expandir nossa pesquisa coletando mais dados sobre bugs e criando modelos para prever sua ocorrência. Também estamos interessados em estudar bugs MPL em outros domínios de software para desenvolver descobertas mais generalizadas.

Ao entender e lidar com esses bugs de forma eficaz, os desenvolvedores podem melhorar a qualidade dos frameworks de aprendizado profundo e, no final das contas, das aplicações de IA que dependem deles.