OpenNMT py

Anúncio: Opennmt-Py não é mais apoiado ativamente.

Iniciamos um novo projeto eole disponível no github

É um spin-off do OpenNMT-Py em termos de recursos, mas renovamos muitas coisas.

O EOLE lida com NMT, LLM, Codificadores, bem como um novo conceito de estimador dentro de um modelo NMT, consulte este post e esta notícia

Se você é um desenvolvedor, mude agora. Se você for apenas um usuário, publicaremos as primeiras versões PY-PI em breve.

Opennmt-Py: Tradução da máquina neural de código aberto e modelos de idiomas (grandes)

Opennmt-Py é a versão pytorch do projeto OpenNMT, uma estrutura de tradução para máquina neural de código aberto (MIT) (e além!). Ele foi projetado para ser amigável para pesquisar novas idéias em tradução, modelagem de idiomas, resumo e muitas outras tarefas de PNL. Algumas empresas provaram que o código está pronto para a produção.

Adoramos contribuições! Veja os problemas marcados com as contribuições de boas -vindas.

Antes de levantar um problema, leia os requisitos e os exemplos completos de documentação.

A menos que haja um bug, use o fórum ou o Gitter para fazer perguntas.

---

Para iniciantes:

Há um tuto passo a passo e explicado (graças a Yasmin Moslem): Tutorial

Tente ler e/ou seguir antes de levantar questões de iniciantes.

Caso contrário, você pode apenas dar uma olhada nas etapas rápidas

---

Novo:

• Você precisará de Pytorch v2 de preferência v2.2, que corrige alguns problemas de scaled_dot_product_attention
• Apoio ao LLM com conversores para: llama (+ Mistral), Openllama, Redpajama, MPT-7b, Falcon.
• Suporte para quantização de 8 bits e 4 bits, juntamente com os adaptadores LORA, com ou sem o check -inging.
• Você pode Finetune 7B e 13B modelos em um único RTX 24 GB com quantização de 4 bits.
• A inferência pode ser forçada em 4/8 bits usando a mesma quantização da camada que na Finetuning.
• Paralelismo do tensor quando o modelo não se encaixa na memória de uma GPU (treinamento e inferência)
• Depois que seu modelo estiver no FinetUned, você poderá executar a inferência com o OpenNMT-Py ou mais rápido com o CTRANSLATE2.
• Script de avaliação MMLU, consulte os resultados aqui

Para todas as casas de uso, incluindo o NMT, agora você pode usar multiqueriais em vez de atenção múltipla (mais rápida no treinamento e inferência) e remover vieses de todos os módulos lineares (QKV, bem como feedforward).

Se você usou versões anteriores do OpenNMT-Py, pode verificar o Changelog ou as mudanças de ruptura

---

Tutoriais:

• Como replicar Vicuna com um modelo de idioma de 7b ou 13b (ou lhama aberto, MPT-7B, Redpajama): Tuto Vicuna
• Como Finetune NLLB-200 com seu conjunto de dados: Tuto FineTune NLLB-200
• Como criar um servidor de repouso Opennmt-Py simples: REST TUTO REST
• Como criar uma interface da web simples: Tuto Straminit
• Replicar o experimento WMT17 EN-DE: WMT17 ENDE

---

Configurar

Usando o docker

Para facilitar a configuração e a reprodutibilidade, algumas imagens do Docker são disponibilizadas no Registro do Container Github: https://github.com/opennmt/opennmt-py/pkgs/container/openmt-py

Você pode adaptar o fluxo de trabalho e criar sua própria imagem, dependendo de necessidades específicas usando build.sh e Dockerfile no diretório docker do repositório.

 docker pull ghcr.io/opennmt/opennmt-py:3.4.3-ubuntu22.04-cuda12.1

Exemplo Oneliner para executar um contêiner e abrir uma casca de bash nele

 docker run --rm -it --runtime=nvidia ghcr.io/opennmt/opennmt-py:test-ubuntu22.04-cuda12.1

Nota: Você precisa ter o NVIDIA Container Toolkit (anteriormente NVIDIA-Docker) para aproveitar corretamente os recursos CUDA/GPU.

Dependendo das suas necessidades, você pode adicionar várias sinalizações:

• -p 5000:5000 para encaminhar alguma porta exposta do seu contêiner para o seu host;
• -v /some/local/directory:/some/container/directory para montar algum diretório local para algum diretório de contêineres;
• --entrypoint some_command para executar diretamente algum comando específico como o ponto de entrada do contêiner (em vez do shell padrão padrão);

Instalando localmente

Opennmt-py requer:

• Python> = 3.8
• Pytorch> = 2.0 <2.2

Instale OpenNMT-py a partir do pip :

pip install OpenNMT-py

ou da fonte:

git clone https://github.com/OpenNMT/OpenNMT-py.git
cd OpenNMT-py
pip install -e .

NOTA: Se você encontrar um MemoryError durante a instalação, tente usar pip com --no-cache-dir .

(Opcional) Alguns recursos avançados (por exemplo, modelos pré -treinados ou transformações específicas) requerem pacotes extras, você pode instalá -los com:

pip install -r requirements.opt.txt

Instalação manual de algumas dependências

O Apex é altamente recomendável ter desempenho rápido (especialmente o Legacy Fusedadam Optimizer e FusedrmsNorm)

git clone https://github.com/NVIDIA/apex
cd apex
pip3 install -v --no-build-isolation --config-settings --build-option= " --cpp_ext --cuda_ext --deprecated_fused_adam --xentropy --fast_multihead_attn " ./
cd ..

Flash Atenção:

A partir de outubro de 2023, a atenção flash 1 foi upsa para Pytorch V2, mas é recomendável usar o Flash Atenção 2 com v2.3.1 para obter suporte de atenção à janela deslizante.

Ao usar POSPOSIÇÕES POSPONEGRÁVEIS position_encoding=True ou rotativo com max_relative_positions=-1 OpenNmt-Py tentará usar um caminho otimizado do produto de ponto.

Se você quiser usar a atenção do flash, precisará instalá -lo manualmente primeiro:

pip install flash-attn --no-build-isolation

Se o Flash Atenção 2 não estiver instalado, usaremos F.scaled_dot_product_attention do Pytorch 2.x

Ao usar max_relative_positions > 0 ou Alibi max_relative_positions=-2 Opennmt-py usará seu código herdado para multiplicações de matriz.

Flash Ateption e F.scaled_dot_product_attention são um pouco mais rápido e salva alguma memória da GPU.

Awq:

Se você deseja executar a inferência ou quantizar um modelo AWQ, precisará de autoawq.

Para autoawq: pip install autoawq

Documentação e Perguntas frequentes

Documentação HTML completa

Perguntas frequentes

Agradecimentos

O OpenNMT-PY é executado como um projeto colaborativo de código aberto. O projeto foi incubado por Systran e Harvard NLP em 2016 em Lua e transportado para Pytorch em 2017.

Mantenedores atuais (desde 2018):

François Hernandez Vincent Nguyen (semente)

Citação

Se você estiver usando o OpenNMT-PY para trabalho acadêmico, cite o documento de demonstração inicial do sistema publicado na ACL 2017:

 @misc{klein2018opennmt,
      title={OpenNMT: Neural Machine Translation Toolkit}, 
      author={Guillaume Klein and Yoon Kim and Yuntian Deng and Vincent Nguyen and Jean Senellart and Alexander M. Rush},
      year={2018},
      eprint={1805.11462},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}