Inglês | 中文
? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio
? Faça perguntas ou discuta ideias no GitHub
Junte-se a nós em ? Discord ou WeChat
Confira o relatório técnico Yi
Cresça no Yi Learning Hub
? Aprenda no Yi Tech Blog
? Os modelos da série Yi são a próxima geração de modelos de linguagem grande de código aberto treinados do zero pela 01.AI.
? Visados como um modelo de linguagem bilíngue e treinados em corpus multilíngue 3T, os modelos da série Yi se tornam um dos LLM mais fortes do mundo, mostrando-se promissores em compreensão de linguagem, raciocínio de bom senso, compreensão de leitura e muito mais. Por exemplo,
O modelo Yi-34B-Chat ficou em segundo lugar (seguindo o GPT-4 Turbo) , superando outros LLMs (como GPT-4, Mixtral, Claude) no AlpacaEval Leaderboard (com base em dados disponíveis até janeiro de 2024).
O modelo Yi-34B ficou em primeiro lugar entre todos os modelos de código aberto existentes (como Falcon-180B, Llama-70B, Claude) em inglês e chinês em vários benchmarks, incluindo Hugging Face Open LLM Leaderboard (pré-treinado) e C-Eval (com base em dados disponíveis até novembro de 2023).
(Créditos ao Llama) Obrigado às comunidades de código aberto Transformer e Llama, pois reduzem os esforços necessários para construir do zero e permitem a utilização das mesmas ferramentas dentro do ecossistema de IA.
DR
Os modelos da série Yi adotam a mesma arquitetura do Llama, mas NÃO são derivados do Llama.
Tanto Yi quanto Llama são baseados na estrutura Transformer, que tem sido a arquitetura padrão para grandes modelos de linguagem desde 2018.
Baseado na arquitetura Transformer, o Llama se tornou uma nova pedra angular para a maioria dos modelos de código aberto de última geração devido à sua excelente estabilidade, convergência confiável e compatibilidade robusta. Isso posiciona o Llama como a estrutura fundamental reconhecida para modelos incluindo Yi.
Graças às arquiteturas Transformer e Llama, outros modelos podem aproveitar o seu poder, reduzindo o esforço necessário para construir do zero e permitindo a utilização das mesmas ferramentas dentro dos seus ecossistemas.
Porém, os modelos da série Yi NÃO são derivados do Llama, pois não utilizam os pesos do Llama.
Como a estrutura do Llama é empregada pela maioria dos modelos de código aberto, os principais fatores para determinar o desempenho do modelo são conjuntos de dados de treinamento, pipelines de treinamento e infraestrutura de treinamento.
Desenvolvendo-se de forma única e proprietária, Yi criou de forma independente seus próprios conjuntos de dados de treinamento de alta qualidade, pipelines de treinamento eficientes e infraestrutura de treinamento robusta inteiramente do zero. Este esforço levou a um excelente desempenho com os modelos da série Yi ficando logo atrás do GPT4 e ultrapassando o Llama na tabela de classificação Alpaca em dezembro de 2023.
[Voltar ao topo ⬆️]
Yi-9B-200K é de código aberto e está disponível ao público.Yi-9B é de código aberto e está disponível ao público.Yi-9B se destaca como o melhor desempenho entre uma variedade de modelos de código aberto de tamanho semelhante (incluindo Mistral-7B, SOLAR-10.7B, Gemma-7B, DeepSeek-Coder-7B-Base-v1.5 e mais), particularmente excelente em código, matemática, raciocínio de bom senso e compreensão de leitura.Yi-VL-34B e Yi-VL-6B , são de código aberto e estão disponíveis ao público.Yi-VL-34B ficou em primeiro lugar entre todos os modelos de código aberto existentes nos benchmarks mais recentes, incluindo MMMU e CMMMU (com base em dados disponíveis até janeiro de 2024).Yi-34B-ChatYi-34B-Chat-4bitsYi-34B-Chat-8bitsYi-6B-ChatYi-6B-Chat-4bitsYi-6B-Chat-8bitsVocê pode experimentar alguns deles interativamente em:
Yi-6B-200K e Yi-34B-200K , são de código aberto e estão disponíveis ao público.Yi-6B e Yi-34B , são de código aberto e estão disponíveis ao público.[Voltar ao topo ⬆️]
Os modelos Yi vêm em vários tamanhos e atendem a diferentes casos de uso. Você também pode ajustar os modelos Yi para atender às suas necessidades específicas.
Se você deseja implantar modelos Yi, certifique-se de atender aos requisitos de software e hardware.
| Modelo | Download |
|---|---|
| Yi-34B-Bate-papo | • ? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio |
| Yi-34B-Chat-4bits | • ? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio |
| Yi-34B-Bate-papo-8bits | • ? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio |
| Yi-6B-Bate-papo | • ? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio |
| Yi-6B-Chat-4bits | • ? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio |
| Yi-6B-Bate-papo-8bits | • ? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio |
- Os modelos da série de 4 bits são quantizados por AWQ.
- Os modelos da série de 8 bits são quantizados pelo GPTQ
- Todos os modelos quantizados têm baixa barreira de uso, pois podem ser implantados em GPUs de consumo (por exemplo, 3090, 4090).
| Modelo | Download |
|---|---|
| Yi-34B | • ? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio |
| Yi-34B-200K | • ? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio |
| Yi-9B | • ? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio |
| Yi-9B-200K | • ? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio |
| Yi-6B | • ? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio |
| Yi-6B-200K | • ? Abraçando o Rosto • ? Escopo do Modelo • ? modelo sábio |
- 200k equivale aproximadamente a 400.000 caracteres chineses.
- Se você quiser usar a versão anterior do Yi-34B-200K (lançada em 5 de novembro de 2023), execute git checkout 069cd341d60f4ce4b07ec394e82b79e94f656cf para baixar o peso.
| Modelo | Introdução | Janela de contexto padrão | Tokens pré-treinados | Data dos dados de treinamento |
|---|---|---|---|---|
| Modelos da série 6B | Eles são adequados para uso pessoal e acadêmico. | 4K | 3T | Até junho de 2023 |
| Modelos da série 9B | É o melhor em codificação e matemática nos modelos da série Yi. | Yi-9B é continuamente treinado com base em Yi-6B, usando tokens 0,8T. | ||
| Modelos da série 34B | Eles são adequados para fins pessoais, acadêmicos e comerciais (especialmente para pequenas e médias empresas). É uma solução econômica, acessível e equipada com capacidade emergente. | 3T |
Para modelos de bate-papo
No entanto, esta maior diversidade pode amplificar certas questões existentes, incluindo:
[Voltar ao topo ⬆️]
Dica : Se você quiser começar com o modelo Yi e explorar diferentes métodos de inferência, consulte o Yi Cookbook.
Selecione um dos seguintes caminhos para começar sua jornada com Yi!
Se você preferir implantar modelos Yi localmente,
?♀️ e você tiver recursos suficientes (por exemplo, NVIDIA A800 80GB), poderá escolher um dos seguintes métodos:
?♀️ e você tem recursos limitados (por exemplo, um MacBook Pro), pode usar llama.cpp.
Se preferir não implantar modelos Yi localmente, você pode explorar os recursos do Yi usando qualquer uma das opções a seguir.
Se quiser explorar mais recursos do Yi, você pode adotar um destes métodos:
APIs Yi (oficial Yi)
APIs Yi (réplica)
Se quiser conversar com Yi com opções mais personalizáveis (por exemplo, prompt do sistema, temperatura, penalidade de repetição, etc.), você pode tentar uma das seguintes opções:
Yi-34B-Chat-Playground (oficial Yi)
Yi-34B-Chat-Playground (réplica)
Se quiser bater um papo com Yi, você pode usar um destes serviços online, que oferecem uma experiência de usuário semelhante:
Yi-34B-Chat (oficial de Yi em Hugging Face)
Yi-34B-Chat (beta oficial do Yi)
[Voltar ao topo ⬆️]
Este tutorial orienta você em cada etapa da execução do Yi-34B-Chat localmente em um A800 (80G) e, em seguida, da realização de inferência.
Certifique-se de que o Python 3.10 ou uma versão posterior esteja instalado.
Se você deseja executar outros modelos Yi, consulte os requisitos de software e hardware.
Para configurar o ambiente e instalar os pacotes necessários, execute o seguinte comando.
git clone https://github.com/01-ai/Yi.git
cd yi
pip install -r requirements.txtVocê pode baixar os pesos e o tokenizer dos modelos Yi das seguintes fontes:
Você pode realizar inferência com Yi chat ou modelos básicos conforme abaixo.
Crie um arquivo chamado quick_start.py e copie o conteúdo a seguir nele.
from transformers import AutoModelForCausalLM , AutoTokenizer
model_path = '<your-model-path>'
tokenizer = AutoTokenizer . from_pretrained ( model_path , use_fast = False )
# Since transformers 4.35.0, the GPT-Q/AWQ model can be loaded using AutoModelForCausalLM.
model = AutoModelForCausalLM . from_pretrained (
model_path ,
device_map = "auto" ,
torch_dtype = 'auto'
). eval ()
# Prompt content: "hi"
messages = [
{ "role" : "user" , "content" : "hi" }
]
input_ids = tokenizer . apply_chat_template ( conversation = messages , tokenize = True , add_generation_prompt = True , return_tensors = 'pt' )
output_ids = model . generate ( input_ids . to ( 'cuda' ))
response = tokenizer . decode ( output_ids [ 0 ][ input_ids . shape [ 1 ]:], skip_special_tokens = True )
# Model response: "Hello! How can I assist you today?"
print ( response ) Execute quick_start.py .
python quick_start.pyEntão você pode ver uma saída semelhante à abaixo. ?
Hello ! How can I assist you today ? Yi-34B
As etapas são semelhantes ao pip - Realizar inferência com o modelo de chat Yi.
Você pode usar o arquivo existente text_generation.py .
python demo/text_generation.py --model < your-model-path >Então você pode ver uma saída semelhante à abaixo. ?
Dica : Deixe-me contar uma história interessante sobre o gato Tom e o rato Jerry,
Geração : Deixe-me contar uma história interessante sobre o gato Tom e o rato Jerry, que aconteceu na minha infância. Meu pai tinha uma casa grande com dois gatos morando dentro para matar ratos. Um dia, quando eu estava brincando sozinho em casa, encontrei um dos gatos deitado de costas perto da porta da cozinha, parecendo querer algo de nós, mas não conseguia se levantar porque havia muitas pessoas ao seu redor! Ele continuou tentando por vários minutos antes de finalmente desistir...
Yi-9B
Entrada
from transformers import AutoModelForCausalLM, AutoTokenizer
MODEL_DIR = " 01-ai/Yi-9B "
model = AutoModelForCausalLM.from_pretrained(MODEL_DIR, torch_dtype= " auto " )
tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, use_fast=False)
input_text = " # write the quick sort algorithm "
inputs = tokenizer(input_text, return_tensors= " pt " ).to(model.device)
outputs = model.generate( ** inputs, max_length=256)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))Saída
# write the quick sort algorithm
def quick_sort(arr):
if len(arr) < = 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
# test the quick sort algorithm
print(quick_sort([3, 6, 8, 10, 1, 2, 1]))[Voltar ao topo ⬆️]
Certifique-se de ter instalado o Docker e o nvidia-container-toolkit.
docker run -it --gpus all
-v <your-model-path>: /models
ghcr.io/01-ai/yi:latest
Como alternativa, você pode extrair a imagem do Yi Docker em registry.lingyiwanwu.com/ci/01-ai/yi:latest .
Você pode realizar inferência com Yi chat ou modelos básicos conforme abaixo.
As etapas são semelhantes ao pip - Realizar inferência com o modelo de chat Yi.
Observe que a única diferença é definir model_path = '<your-model-mount-path>' em vez de model_path = '<your-model-path>' .
As etapas são semelhantes ao pip - Realizar inferência com o modelo base Yi.
Observe que a única diferença é definir --model <your-model-mount-path>' em vez de model <your-model-path> .
conda-lock para gerar arquivos de bloqueio totalmente reproduzíveis para ambientes conda.micromamba para instalar essas dependências.Instale o micromamba seguindo as instruções disponíveis aqui.
Execute micromamba install -y -n yi -f conda-lock.yml para criar um ambiente conda chamado yi e instale as dependências necessárias.
O tutorial a seguir irá guiá-lo em cada etapa da execução de um modelo quantizado (Yi-chat-6B-2bits) localmente e, em seguida, realizar a inferência.
Este tutorial pressupõe que você use um MacBook Pro com 16 GB de memória e um chip Apple M2 Pro.
Certifique-se de que git-lfs esteja instalado em sua máquina.
llama.cpp Para clonar o repositório llama.cpp , execute o seguinte comando.
git clone [email protected]:ggerganov/llama.cpp.git2.1 Para clonar XeIaso/yi-chat-6B-GGUF apenas com ponteiros, execute o seguinte comando.
GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/XeIaso/yi-chat-6B-GGUF2.2 Para baixar um modelo Yi quantizado (yi-chat-6b.Q2_K.gguf), execute o seguinte comando.
git-lfs pull --include yi-chat-6b.Q2_K.ggufPara realizar inferência com o modelo Yi, você pode usar um dos métodos a seguir.
Método 1: realizar inferência no terminal
Método 2: realizar inferência na web
Para compilar llama.cpp usando 4 threads e, em seguida, realizar inferência, navegue até o diretório llama.cpp e execute o seguinte comando.
Pontas
Substitua
/Users/yu/yi-chat-6B-GGUF/yi-chat-6b.Q2_K.ggufpelo caminho real do seu modelo.Por padrão, o modelo opera no modo de conclusão.
Para opções adicionais de personalização de saída (por exemplo, prompt do sistema, temperatura, penalidade de repetição, etc.), execute
./main -hpara verificar descrições detalhadas e uso.
make -j4 && ./main -m /Users/yu/yi-chat-6B-GGUF/yi-chat-6b.Q2_K.gguf -p " How do you feed your pet fox? Please answer this question in 6 simple steps:nStep 1: " -n 384 -e
...
How do you feed your pet fox ? Please answer this question in 6 simple steps:
Step 1: Select the appropriate food for your pet fox. You should choose high-quality, balanced prey items that are suitable for their unique dietary needs. These could include live or frozen mice, rats, pigeons, or other small mammals, as well as fresh fruits and vegetables.
Step 2: Feed your pet fox once or twice a day, depending on the species and its individual preferences. Always ensure that they have access to fresh water throughout the day.
Step 3: Provide an appropriate environment for your pet fox. Ensure it has a comfortable place to rest, plenty of space to move around, and opportunities to play and exercise.
Step 4: Socialize your pet with other animals if possible. Interactions with other creatures can help them develop social skills and prevent boredom or stress.
Step 5: Regularly check for signs of illness or discomfort in your fox. Be prepared to provide veterinary care as needed, especially for common issues such as parasites, dental health problems, or infections.
Step 6: Educate yourself about the needs of your pet fox and be aware of any potential risks or concerns that could affect their well-being. Regularly consult with a veterinarian to ensure you are providing the best care.
...
Agora você fez uma pergunta ao modelo Yi com sucesso e obteve uma resposta! ?
Para inicializar um chatbot leve e rápido, execute o seguinte comando.
cd llama.cpp
./server --ctx-size 2048 --host 0.0.0.0 --n-gpu-layers 64 --model /Users/yu/yi-chat-6B-GGUF/yi-chat-6b.Q2_K.ggufEntão você pode obter uma saída como esta:
...
llama_new_context_with_model: n_ctx = 2048
llama_new_context_with_model: freq_base = 5000000.0
llama_new_context_with_model: freq_scale = 1
ggml_metal_init: allocating
ggml_metal_init: found device: Apple M2 Pro
ggml_metal_init: picking default device: Apple M2 Pro
ggml_metal_init: ggml.metallib not found, loading from source
ggml_metal_init: GGML_METAL_PATH_RESOURCES = nil
ggml_metal_init: loading ' /Users/yu/llama.cpp/ggml-metal.metal '
ggml_metal_init: GPU name: Apple M2 Pro
ggml_metal_init: GPU family: MTLGPUFamilyApple8 (1008)
ggml_metal_init: hasUnifiedMemory = true
ggml_metal_init: recommendedMaxWorkingSetSize = 11453.25 MB
ggml_metal_init: maxTransferRate = built-in GPU
ggml_backend_metal_buffer_type_alloc_buffer: allocated buffer, size = 128.00 MiB, ( 2629.44 / 10922.67)
llama_new_context_with_model: KV self size = 128.00 MiB, K (f16): 64.00 MiB, V (f16): 64.00 MiB
ggml_backend_metal_buffer_type_alloc_buffer: allocated buffer, size = 0.02 MiB, ( 2629.45 / 10922.67)
llama_build_graph: non-view tensors processed: 676/676
llama_new_context_with_model: compute buffer total size = 159.19 MiB
ggml_backend_metal_buffer_type_alloc_buffer: allocated buffer, size = 156.02 MiB, ( 2785.45 / 10922.67)
Available slots:
- > Slot 0 - max context: 2048
llama server listening at http://0.0.0.0:8080 Para acessar a interface do chatbot, abra seu navegador e digite http://0.0.0.0:8080 na barra de endereço.
Digite uma pergunta, como "Como você alimenta sua raposa de estimação? Responda a esta pergunta em 6 etapas simples" na janela de prompt e você receberá uma resposta correspondente.
[Voltar ao topo ⬆️]
Você pode criar uma demonstração de UI da web para modelos de chat Yi (observe que os modelos base Yi não são suportados neste cenário).
Passo 1: Prepare seu ambiente.
Etapa 2: Baixe o modelo Yi.
Etapa 3. Para iniciar um serviço web localmente, execute o seguinte comando.
python demo/web_demo.py -c < your-model-path >Você pode acessar a IU da web inserindo o endereço fornecido no console em seu navegador.
[Voltar ao topo ⬆️]
bash finetune/scripts/run_sft_Yi_6b.shDepois de terminar, você pode comparar o modelo ajustado e o modelo base com o seguinte comando:
bash finetune/scripts/run_eval.sh Por padrão, usamos um pequeno conjunto de dados do BAAI/COIG para ajustar o modelo base. Você também pode preparar seu conjunto de dados personalizado no seguinte formato jsonl :
{ "prompt" : " Human: Who are you? Assistant: " , "chosen" : " I'm Yi. " }E então monte-os no contêiner para substituir os padrão:
docker run -it
-v /path/to/save/finetuned/model/:/finetuned-model
-v /path/to/train.jsonl:/yi/finetune/data/train.json
-v /path/to/eval.jsonl:/yi/finetune/data/eval.json
ghcr.io/01-ai/yi:latest
bash finetune/scripts/run_sft_Yi_6b.shCertifique-se de ter conda. Se não, use
mkdir -p ~ /miniconda3
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~ /miniconda3/miniconda.sh
bash ~ /miniconda3/miniconda.sh -b -u -p ~ /miniconda3
rm -rf ~ /miniconda3/miniconda.sh
~ /miniconda3/bin/conda init bash
source ~ /.bashrcEm seguida, crie um ambiente conda:
conda create -n dev_env python=3.10 -y
conda activate dev_env
pip install torch==2.0.1 deepspeed==0.10 tensorboard transformers datasets sentencepiece accelerate ray==2.7Para o modelo Yi-6B, é recomendado um nó com 4 GPUs, cada uma com memória GPU maior que 60 GB.
Para o modelo Yi-34B, como o uso da técnica de descarregamento zero consome muita memória da CPU, tome cuidado para limitar o número de GPUs no treinamento de ajuste fino de 34B. Use CUDA_VISIBLE_DEVICES para limitar o número de GPUs (conforme mostrado em scripts/run_sft_Yi_34b.sh).
Uma configuração de hardware típica para ajuste fino do modelo 34B é um nó com 8 GPUs (limitado a 4 em execução por CUDA_VISIBLE_DEVICES=0,1,2,3), cada um com memória de GPU maior que 80 GB e memória total de CPU maior que 900 GB.
Baixe um modelo baseado em LLM para MODEL_PATH (6B e 34B). Uma pasta típica de modelos é como:
| -- $MODEL_PATH
| | -- config.json
| | -- pytorch_model-00001-of-00002.bin
| | -- pytorch_model-00002-of-00002.bin
| | -- pytorch_model.bin.index.json
| | -- tokenizer_config.json
| | -- tokenizer.model
| | -- ...Baixe um conjunto de dados do huggingface para o armazenamento local DATA_PATH, por exemplo, Dahoas/rm-static.
| -- $DATA_PATH
| | -- data
| | | -- train-00000-of-00001-2a1df75c6bce91ab.parquet
| | | -- test-00000-of-00001-8c7c51afc6d45980.parquet
| | -- dataset_infos.json
| | -- README.md finetune/yi_example_dataset possui conjuntos de dados de exemplo, que são modificados de BAAI/COIG
| -- $DATA_PATH
| --data
| -- train.jsonl
| -- eval.jsonl cd na pasta de scripts, copie e cole o script e execute. Por exemplo:
cd finetune/scripts
bash run_sft_Yi_6b.shPara o modelo base Yi-6B, definir training_debug_steps=20 e num_train_epochs=4 pode gerar um modelo de chat, que leva cerca de 20 minutos.
Para o modelo básico Yi-34B, a inicialização leva um tempo relativamente longo. Por favor, seja paciente.
cd finetune/scripts
bash run_eval.shEntão você verá a resposta tanto do modelo básico quanto do modelo ajustado.
[Voltar ao topo ⬆️]
python quantization/gptq/quant_autogptq.py
--model /base_model
--output_dir /quantized_model
--trust_remote_codeDepois de terminar, você pode avaliar o modelo resultante da seguinte forma:
python quantization/gptq/eval_quantized_model.py
--model /quantized_model
--trust_remote_codeGPT-Q é um método PTQ (Quantização Pós-Treinamento). Ele economiza memória e fornece possíveis acelerações, ao mesmo tempo que mantém a precisão do modelo.
Os modelos Yi podem ser quantizados GPT-Q sem muito esforço. Fornecemos um tutorial passo a passo abaixo.
Para executar o GPT-Q, usaremos AutoGPTQ e exllama. E os transformadores huggingface integraram ótimo e auto-gptq para realizar quantização GPTQ em modelos de linguagem.
O script quant_autogptq.py é fornecido para você realizar a quantização GPT-Q:
python quant_autogptq.py --model /base_model
--output_dir /quantized_model --bits 4 --group_size 128 --trust_remote_code Você pode executar um modelo quantizado usando eval_quantized_model.py :
python eval_quantized_model.py --model /quantized_model --trust_remote_codepython quantization/awq/quant_autoawq.py
--model /base_model
--output_dir /quantized_model
--trust_remote_codeDepois de terminar, você pode avaliar o modelo resultante da seguinte forma:
python quantization/awq/eval_quantized_model.py
--model /quantized_model
--trust_remote_codeAWQ é um método PTQ (Quantização Pós-Treinamento). É uma quantização de baixo peso (INT3/4) eficiente e precisa para LLMs.
Os modelos Yi podem ser quantizados em AWQ sem muito esforço. Fornecemos um tutorial passo a passo abaixo.
Para executar o AWQ, usaremos o AutoAWQ.
O script quant_autoawq.py é fornecido para você realizar a quantização AWQ:
python quant_autoawq.py --model /base_model
--output_dir /quantized_model --bits 4 --group_size 128 --trust_remote_code Você pode executar um modelo quantizado usando eval_quantized_model.py :
python eval_quantized_model.py --model /quantized_model --trust_remote_code[Voltar ao topo ⬆️]
Se você deseja implantar modelos Yi, certifique-se de atender aos requisitos de software e hardware.
Antes de usar modelos quantizados Yi, certifique-se de ter instalado o software correto listado abaixo.
| Modelo | Programas |
|---|---|
| Modelos quantizados Yi de 4 bits | AWQ e CUDA |
| Modelos quantizados Yi de 8 bits | GPTQ e CUDA |
Antes de implantar o Yi em seu ambiente, certifique-se de que seu hardware atenda aos seguintes requisitos.
| Modelo | VRAM mínimo | Exemplo de GPU recomendado |
|---|---|---|
| Yi-6B-Bate-papo | 15GB | 1 x RTX 3090 (24GB) 1 x RTX 4090 (24GB) 1 x A10 (24 GB) 1 x A30 (24 GB) |
| Yi-6B-Chat-4bits | 4GB | 1 x RTX 3060 (12GB) 1 x RTX 4060 (8GB) |
| Yi-6B-Chat-8bits | 8GB | 1 x RTX 3070 (8GB) 1 x RTX 4060 (8GB) |
| Yi-34B-Bate-papo | 72GB | 4x RTX 4090 (24GB) 1 x A800 (80 GB) |
| Yi-34B-Chat-4bits | 20 GB | 1 x RTX 3090 (24GB) 1 x RTX 4090 (24GB) 1 x A10 (24 GB) 1 x A30 (24 GB) 1 x A100 (40 GB) |
| Yi-34B-Bate-papo-8bits | 38GB | 2x RTX 3090 (24GB) 2x RTX 4090 (24 GB) 1 x A800 (40 GB) |
Abaixo estão detalhados os requisitos mínimos de VRAM em diferentes casos de uso de lote.
| Modelo | lote=1 | lote=4 | lote=16 | lote=32 |
|---|---|---|---|---|
| Yi-6B-Bate-papo | 12GB | 13 GB | 15GB | 18GB |
| Yi-6B-Chat-4bits | 4GB | 5GB | 7GB | 10GB |
| Yi-6B-Bate-papo-8bits | 7GB | 8GB | 10GB | 14GB |
| Yi-34B-Bate-papo | 65GB | 68 GB | 76 GB | > 80 GB |
| Yi-34B-Chat-4bits | 19GB | 20 GB | 30GB | 40 GB |
| Yi-34B-Bate-papo-8bits | 35GB | 37GB | 46GB | 58 GB |
| Modelo | VRAM mínimo | Exemplo de GPU recomendado |
|---|---|---|
| Yi-6B | 15GB | 1 x RTX 3090 (24GB) 1 x RTX 4090 (24GB) 1 x A10 (24GB) 1 x A30 (24GB) |
| Yi-6B-200K | 50GB | 1 x A800 (80GB) |
| Yi-9B | 20 GB | 1 x RTX 4090 (24 GB) |
| Yi-34B | 72 GB | 4x RTX 4090 (24GB) 1 x A800 (80 GB) |
| Yi-34B-200K | 200 GB | 4 x A800 (80 GB) |
[Voltar ao topo ⬆️]
Yi-34B e Yi-34B-Chat se resume à abordagem e aos resultados do ajuste fino.Yi-34B pode ser a sua escolha.Yi-34B-Chat pode ser sua melhor aposta. 
