Inglés | 中文
? Cara de abrazo • ? ModeloScope • ? modelo sabio
? Haga preguntas o discuta ideas en GitHub
Únase a nosotros en ? Discordia o WeChat
Consulte el informe de Yi Tech
Crecer en Yi Learning Hub
? Aprenda en el blog de Yi Tech
? Los modelos de la serie Yi son la próxima generación de modelos de lenguaje grande de código abierto entrenados desde cero por 01.AI.
? Diseñados como modelo de lenguaje bilingüe y entrenados en corpus multilingües 3T, los modelos de la serie Yi se convierten en uno de los LLM más sólidos del mundo, mostrando promesas en comprensión del lenguaje, razonamiento de sentido común, comprensión de lectura y más. Por ejemplo,
El modelo Yi-34B-Chat quedó en segundo lugar (después de GPT-4 Turbo) , superando a otros LLM (como GPT-4, Mixtral, Claude) en la tabla de clasificación de AlpacaEval (según los datos disponibles hasta enero de 2024).
El modelo Yi-34B ocupó el primer lugar entre todos los modelos de código abierto existentes (como Falcon-180B, Llama-70B, Claude) tanto en inglés como en chino en varios puntos de referencia, incluido Hugging Face Open LLM Leaderboard (pre-entrenado) y C-Eval. (basado en datos disponibles hasta noviembre de 2023).
(Créditos a Llama) Gracias a las comunidades de código abierto Transformer y Llama, ya que reducen los esfuerzos necesarios para construir desde cero y permiten la utilización de las mismas herramientas dentro del ecosistema de IA.
TL;DR
Los modelos de la serie Yi adoptan la misma arquitectura de modelo que Llama pero NO son derivados de Llama.
Tanto Yi como Llama se basan en la estructura Transformer, que ha sido la arquitectura estándar para modelos de lenguaje grandes desde 2018.
Basado en la arquitectura Transformer, Llama se ha convertido en una nueva piedra angular para la mayoría de los modelos de código abierto de última generación debido a su excelente estabilidad, convergencia confiable y compatibilidad sólida. Esto posiciona a Llama como el marco fundamental reconocido para modelos que incluyen a Yi.
Gracias a las arquitecturas Transformer y Llama, otros modelos pueden aprovechar su potencia, reduciendo el esfuerzo necesario para construir desde cero y permitiendo la utilización de las mismas herramientas dentro de sus ecosistemas.
Sin embargo, los modelos de la serie Yi NO son derivados de Llama, ya que no utilizan los pesos de Llama.
Como la estructura de Llama es empleada por la mayoría de los modelos de código abierto, los factores clave para determinar el rendimiento del modelo son los conjuntos de datos de entrenamiento, los canales de entrenamiento y la infraestructura de entrenamiento.
Al desarrollarse de una manera única y patentada, Yi ha creado de forma independiente sus propios conjuntos de datos de capacitación de alta calidad, canales de capacitación eficientes y una infraestructura de capacitación sólida completamente desde cero. Este esfuerzo ha dado lugar a un rendimiento excelente, con los modelos de la serie Yi ubicándose justo detrás de GPT4 y superando a Llama en la clasificación de Alpaca en diciembre de 2023.
[Volver al inicio ⬆️]
Yi-9B-200K es de código abierto y está disponible para el público.Yi-9B es de código abierto y está disponible para el público.Yi-9B se destaca como el de mejor desempeño entre una gama de modelos de código abierto de tamaño similar (incluidos Mistral-7B, SOLAR-10.7B, Gemma-7B, DeepSeek-Coder-7B-Base-v1.5 y más). sobresaliendo particularmente en código, matemáticas, razonamiento de sentido común y comprensión lectora.Yi-VL-34B y Yi-VL-6B , son de código abierto y están disponibles para el público.Yi-VL-34B ocupó el primer lugar entre todos los modelos de código abierto existentes en los últimos puntos de referencia, incluidos MMMU y CMMMU (según los datos disponibles hasta enero de 2024).Yi-34B-ChatYi-34B-Chat-4bitsYi-34B-Chat-8bitsYi-6B-ChatYi-6B-Chat-4bitsYi-6B-Chat-8bitsPuedes probar algunos de ellos de forma interactiva en:
Yi-6B-200K y Yi-34B-200K , son de código abierto y están disponibles para el público.Yi-6B y Yi-34B , son de código abierto y están disponibles para el público.[Volver al inicio ⬆️]
Los modelos Yi vienen en varios tamaños y se adaptan a diferentes casos de uso. También puede ajustar los modelos Yi para satisfacer sus necesidades específicas.
Si desea implementar modelos Yi, asegúrese de cumplir con los requisitos de software y hardware.
| Modelo | Descargar |
|---|---|
| Yi-34B-Chat | • ? Cara de abrazo • ? ModeloScope • ? modelo sabio |
| Yi-34B-Chat-4bits | • ? Cara de abrazo • ? ModeloScope • ? modelo sabio |
| Yi-34B-Chat-8bits | • ? Abrazando la cara • ? ModeloScope • ? modelo sabio |
| Yi-6B-Chat | • ? Cara de abrazo • ? ModeloScope • ? modelo sabio |
| Yi-6B-Chat-4bits | • ? Cara de abrazo • ? ModeloScope • ? modelo sabio |
| Yi-6B-Chat-8bits | • ? Cara de abrazo • ? ModeloScope • ? modelo sabio |
- Los modelos de la serie de 4 bits están cuantificados por AWQ.
- Los modelos de la serie de 8 bits están cuantificados por GPTQ
- Todos los modelos cuantificados tienen una barrera baja para su uso, ya que se pueden implementar en GPU de consumo (por ejemplo, 3090, 4090).
| Modelo | Descargar |
|---|---|
| Yi-34B | • ? Cara de abrazo • ? ModeloScope • ? modelo sabio |
| Yi-34B-200K | • ? Cara de abrazo • ? ModeloScope • ? modelo sabio |
| Yi-9B | • ? Cara de abrazo • ? ModeloScope • ? modelo sabio |
| Yi-9B-200K | • ? Cara de abrazo • ? ModeloScope • ? modelo sabio |
| Yi-6B | • ? Cara de abrazo • ? ModeloScope • ? modelo sabio |
| Yi-6B-200K | • ? Abrazando la cara • ? ModeloScope • ? modelo sabio |
- 200k equivalen aproximadamente a 400.000 caracteres chinos.
- Si desea utilizar la versión anterior del Yi-34B-200K (lanzada el 5 de noviembre de 2023), ejecute git checkout 069cd341d60f4ce4b07ec394e82b79e94f656cf para descargar el peso.
| Modelo | Introducción | Ventana de contexto predeterminada | Fichas previamente entrenadas | Fecha de datos de entrenamiento |
|---|---|---|---|---|
| Modelos de la serie 6B | Son adecuados para uso personal y académico. | 4k | 3T | Hasta junio de 2023 |
| Modelos de la serie 9B | Es el mejor en codificación y matemáticas de los modelos de la serie Yi. | Yi-9B se entrena continuamente basándose en Yi-6B, utilizando tokens de 0,8T. | ||
| Modelos de la serie 34B | Son adecuados para fines personales, académicos y comerciales (particularmente para pequeñas y medianas empresas). Es una solución rentable, asequible y equipada con capacidad emergente. | 3T |
Para modelos de chat
Sin embargo, esta mayor diversidad podría amplificar ciertos problemas existentes, entre ellos:
[Volver al inicio ⬆️]
Consejo : si desea comenzar con el modelo Yi y explorar diferentes métodos de inferencia, consulte el Libro de cocina de Yi.
¡Selecciona uno de los siguientes caminos para comenzar tu viaje con Yi!
Si prefiere implementar modelos Yi localmente,
?♀️ y tienes recursos suficientes (por ejemplo, NVIDIA A800 80GB), puedes elegir uno de los siguientes métodos:
?♀️ y tienes recursos limitados (por ejemplo, una MacBook Pro), puedes usar llama.cpp.
Si prefiere no implementar modelos de Yi localmente, puede explorar las capacidades de Yi utilizando cualquiera de las siguientes opciones.
Si desea explorar más funciones de Yi, puede adoptar uno de estos métodos:
API de Yi (oficial de Yi)
API de Yi (réplica)
Si desea chatear con Yi con opciones más personalizables (por ejemplo, aviso del sistema, temperatura, penalización por repetición, etc.), puede probar una de las siguientes opciones:
Yi-34B-Chat-Playground (oficial de Yi)
Yi-34B-Chat-Playground (réplica)
Si desea chatear con Yi, puede utilizar uno de estos servicios en línea, que ofrecen una experiencia de usuario similar:
Yi-34B-Chat (funcionario de Yi en Hugging Face)
Yi-34B-Chat (beta oficial de Yi)
[Volver al inicio ⬆️]
Este tutorial lo guía a través de cada paso para ejecutar Yi-34B-Chat localmente en un A800 (80G) y luego realizar la inferencia.
Asegúrese de que esté instalado Python 3.10 o una versión posterior.
Si desea ejecutar otros modelos de Yi, consulte los requisitos de software y hardware.
Para configurar el entorno e instalar los paquetes necesarios, ejecute el siguiente comando.
git clone https://github.com/01-ai/Yi.git
cd yi
pip install -r requirements.txtPuede descargar los pesos y el tokenizador de los modelos Yi de las siguientes fuentes:
Puede realizar inferencias con Yi chat o modelos base como se muestra a continuación.
Cree un archivo llamado quick_start.py y copie el siguiente contenido en él.
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 ) Ejecute quick_start.py .
python quick_start.pyLuego podrá ver un resultado similar al que se muestra a continuación. ?
Hello ! How can I assist you today ? Yi-34B
Los pasos son similares a pip: realizar inferencia con el modelo de chat Yi.
Puede utilizar el archivo existente text_generation.py .
python demo/text_generation.py --model < your-model-path >Luego podrá ver un resultado similar al que se muestra a continuación. ?
Pregunta : Déjame contarte una historia interesante sobre el gato Tom y el ratón Jerry.
Generación : Déjame contarte una historia interesante sobre el gato Tom y el ratón Jerry, que sucedió en mi infancia. Mi padre tenía una casa grande y dentro vivían dos gatos que mataban ratones. Un día, cuando estaba jugando solo en casa, encontré a uno de los gatos acostado boca arriba cerca de la puerta de nuestra cocina, parecía como si quisiera algo de nosotros pero no podía levantarse porque había demasiada gente a su alrededor. Siguió intentándolo durante varios minutos antes de finalmente darse por vencido...
Yi-9B
Aporte
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))Producción
# 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]))[Volver al inicio ⬆️]
Asegúrese de haber instalado Docker y nvidia-container-toolkit.
docker run -it --gpus all
-v <your-model-path>: /models
ghcr.io/01-ai/yi:latest
Alternativamente, puede extraer la imagen de Yi Docker desde registry.lingyiwanwu.com/ci/01-ai/yi:latest .
Puede realizar inferencias con Yi chat o modelos base como se muestra a continuación.
Los pasos son similares a pip: realizar inferencias con el modelo de chat Yi.
Tenga en cuenta que la única diferencia es establecer model_path = '<your-model-mount-path>' en lugar de model_path = '<your-model-path>' .
Los pasos son similares a pip: realizar inferencias con el modelo base de Yi.
Tenga en cuenta que la única diferencia es establecer --model <your-model-mount-path>' en lugar de model <your-model-path> .
conda-lock para generar archivos de bloqueo totalmente reproducibles para entornos conda.micromamba para instalar estas dependencias.Instale micromamba siguiendo las instrucciones disponibles aquí.
Ejecute micromamba install -y -n yi -f conda-lock.yml para crear un entorno conda llamado yi e instalar las dependencias necesarias.
El siguiente tutorial lo guiará a través de cada paso para ejecutar un modelo cuantificado (Yi-chat-6B-2bits) localmente y luego realizar la inferencia.
Este tutorial supone que utilizas una MacBook Pro con 16 GB de memoria y un chip Apple M2 Pro.
Asegúrese de git-lfs esté instalado en su máquina.
llama.cpp Para clonar el repositorio llama.cpp , ejecute el siguiente comando.
git clone [email protected]:ggerganov/llama.cpp.git2.1 Para clonar XeIaso/yi-chat-6B-GGUF con solo punteros, ejecute el siguiente comando.
GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/XeIaso/yi-chat-6B-GGUF2.2 Para descargar un modelo Yi cuantificado (yi-chat-6b.Q2_K.gguf), ejecute el siguiente comando.
git-lfs pull --include yi-chat-6b.Q2_K.ggufPara realizar inferencias con el modelo Yi, puede utilizar uno de los siguientes métodos.
Método 1: realizar inferencia en la terminal
Método 2: realizar inferencia en la web
Para compilar llama.cpp usando 4 subprocesos y luego realizar la inferencia, navegue hasta el directorio llama.cpp y ejecute el siguiente comando.
Consejos
Reemplace
/Users/yu/yi-chat-6B-GGUF/yi-chat-6b.Q2_K.ggufcon la ruta real de su modelo.De forma predeterminada, el modelo funciona en modo de finalización.
Para opciones adicionales de personalización de salida (por ejemplo, aviso del sistema, temperatura, penalización por repetición, etc.), ejecute
./main -hpara verificar las descripciones detalladas y el 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.
...
¡Ahora ha hecho con éxito una pregunta al modelo Yi y ha obtenido una respuesta! ?
Para inicializar un chatbot ligero y rápido, ejecute el siguiente 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.ggufEntonces puedes obtener un resultado como este:
...
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 acceder a la interfaz del chatbot, abra su navegador web e ingrese http://0.0.0.0:8080 en la barra de direcciones.
Ingrese una pregunta, como "¿Cómo alimenta a su zorro mascota? Responda esta pregunta en 6 sencillos pasos" en la ventana emergente y recibirá la respuesta correspondiente.
[Volver al inicio ⬆️]
Puede crear una demostración de interfaz de usuario web para los modelos de chat Yi (tenga en cuenta que los modelos base Yi no son compatibles en este escenario).
Paso 1: Prepare su entorno.
Paso 2: descarga el modelo Yi.
Paso 3. Para iniciar un servicio web localmente, ejecute el siguiente comando.
python demo/web_demo.py -c < your-model-path >Puede acceder a la interfaz de usuario web ingresando la dirección proporcionada en la consola en su navegador.
[Volver al inicio ⬆️]
bash finetune/scripts/run_sft_Yi_6b.shUna vez terminado, puede comparar el modelo ajustado y el modelo base con el siguiente comando:
bash finetune/scripts/run_eval.sh De forma predeterminada, utilizamos un pequeño conjunto de datos de BAAI/COIG para ajustar el modelo base. También puede preparar su conjunto de datos personalizado en el siguiente formato jsonl :
{ "prompt" : " Human: Who are you? Assistant: " , "chosen" : " I'm Yi. " }Y luego móntelos en el contenedor para reemplazar los predeterminados:
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.shAsegúrate de tener conda. Si no, usa
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 ~ /.bashrcLuego, crea un entorno 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 el modelo Yi-6B, se recomienda un nodo con 4 GPU, cada una con una memoria de GPU superior a 60 GB.
Para el modelo Yi-34B, debido a que el uso de la técnica de descarga cero consume mucha memoria de la CPU, tenga cuidado de limitar la cantidad de GPU en el entrenamiento de ajuste fino de 34B. Utilice CUDA_VISIBLE_DEVICES para limitar la cantidad de GPU (como se muestra en scripts/run_sft_Yi_34b.sh).
Una configuración de hardware típica para ajustar el modelo 34B es un nodo con 8 GPU (limitado a 4 en ejecución por CUDA_VISIBLE_DEVICES=0,1,2,3), cada uno con una memoria de GPU superior a 80 GB y una memoria total de CPU superior a 900 GB.
Descargue un modelo base LLM en MODEL_PATH (6B y 34B). Una carpeta típica de modelos es 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
| | -- ...Descargue un conjunto de datos de huggingface al almacenamiento local DATA_PATH, por ejemplo, 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 tiene conjuntos de datos de ejemplo, que se modifican desde BAAI/COIG
| -- $DATA_PATH
| --data
| -- train.jsonl
| -- eval.jsonl cd en la carpeta de scripts, copie y pegue el script y ejecútelo. Por ejemplo:
cd finetune/scripts
bash run_sft_Yi_6b.shPara el modelo base Yi-6B, configurar Training_debug_steps=20 y num_train_epochs=4 puede generar un modelo de chat, lo que demora aproximadamente 20 minutos.
Para el modelo base Yi-34B, la inicialización lleva un tiempo relativamente largo. Por favor tenga paciencia.
cd finetune/scripts
bash run_eval.shLuego verá la respuesta tanto del modelo base como del modelo ajustado.
[Volver al inicio ⬆️]
python quantization/gptq/quant_autogptq.py
--model /base_model
--output_dir /quantized_model
--trust_remote_codeUna vez terminado, puede evaluar el modelo resultante de la siguiente manera:
python quantization/gptq/eval_quantized_model.py
--model /quantized_model
--trust_remote_codeGPT-Q es un método PTQ (cuantización posterior al entrenamiento). Ahorra memoria y proporciona posibles aceleraciones manteniendo la precisión del modelo.
Los modelos Yi se pueden cuantificar con GPT-Q sin mucho esfuerzo. Proporcionamos un tutorial paso a paso a continuación.
Para ejecutar GPT-Q, usaremos AutoGPTQ y exllama. Y los transformadores Huggingface han integrado óptimo y auto-gptq para realizar la cuantificación GPTQ en modelos de lenguaje.
Se proporciona el script quant_autogptq.py para que pueda realizar la cuantificación GPT-Q:
python quant_autogptq.py --model /base_model
--output_dir /quantized_model --bits 4 --group_size 128 --trust_remote_code Puede ejecutar un modelo cuantificado utilizando 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_codeUna vez terminado, puede evaluar el modelo resultante de la siguiente manera:
python quantization/awq/eval_quantized_model.py
--model /quantized_model
--trust_remote_codeAWQ es un método PTQ (cuantización post-entrenamiento). Es una cuantificación de peso de bits bajos (INT3/4) eficiente y precisa para LLM.
Los modelos Yi se pueden cuantificar AWQ sin mucho esfuerzo. Proporcionamos un tutorial paso a paso a continuación.
Para ejecutar AWQ, usaremos AutoAWQ.
Se proporciona el script quant_autoawq.py para que pueda realizar la cuantificación AWQ:
python quant_autoawq.py --model /base_model
--output_dir /quantized_model --bits 4 --group_size 128 --trust_remote_code Puede ejecutar un modelo cuantificado utilizando eval_quantized_model.py :
python eval_quantized_model.py --model /quantized_model --trust_remote_code[Volver al inicio ⬆️]
Si desea implementar modelos Yi, asegúrese de cumplir con los requisitos de software y hardware.
Antes de utilizar los modelos cuantificados de Yi, asegúrese de haber instalado el software correcto que se detalla a continuación.
| Modelo | Software |
|---|---|
| Modelos cuantificados de Yi de 4 bits | AWQ y CUDA |
| Modelos cuantificados Yi de 8 bits | GPTQ y CUDA |
Antes de implementar Yi en su entorno, asegúrese de que su hardware cumpla con los siguientes requisitos.
| Modelo | VRAM mínima | Ejemplo de GPU recomendada |
|---|---|---|
| Yi-6B-Chat | 15GB | 1 RTX 3090 (24 GB) 1 RTX 4090 (24 GB) 1 A10 (24 GB) 1 A30 (24 GB) |
| Yi-6B-Chat-4bits | 4GB | 1 RTX 3060 (12 GB) 1 RTX 4060 (8GB) |
| Yi-6B-Chat-8bits | 8GB | 1 RTX 3070 (8GB) 1 RTX 4060 (8GB) |
| Yi-34B-Chat | 72GB | 4 RTX 4090 (24 GB) 1 A800 (80 GB) |
| Yi-34B-Chat-4bits | 20 GB | 1 RTX 3090 (24 GB) 1 RTX 4090 (24 GB) 1 A10 (24 GB) 1 A30 (24 GB) 1 A100 (40 GB) |
| Yi-34B-Chat-8bits | 38GB | 2 RTX 3090 (24 GB) 2 RTX 4090 (24 GB) 1 A800 (40 GB) |
A continuación se detallan los requisitos mínimos de VRAM en diferentes casos de uso por lotes.
| Modelo | lote = 1 | lote = 4 | lote = 16 | lote = 32 |
|---|---|---|---|---|
| Yi-6B-Chat | 12GB | 13GB | 15GB | 18GB |
| Yi-6B-Chat-4bits | 4GB | 5GB | 7GB | 10GB |
| Yi-6B-Chat-8bits | 7GB | 8GB | 10GB | 14GB |
| Yi-34B-Chat | 65GB | 68GB | 76GB | > 80GB |
| Yi-34B-Chat-4bits | 19GB | 20 GB | 30 GB | 40GB |
| Yi-34B-Chat-8bits | 35GB | 37GB | 46GB | 58GB |
| Modelo | VRAM mínima | Ejemplo de GPU recomendada |
|---|---|---|
| Yi-6B | 15GB | 1 RTX 3090 (24 GB) 1 RTX 4090 (24 GB) 1 A10 (24 GB) 1 A30 (24 GB) |
| Yi-6B-200K | 50 GB | 1 A800 (80 GB) |
| Yi-9B | 20 GB | 1 RTX 4090 (24 GB) |
| Yi-34B | 72GB | 4 RTX 4090 (24 GB) 1 A800 (80 GB) |
| Yi-34B-200K | 200GB | 4 A800 (80 GB) |
[Volver al inicio ⬆️]
Yi-34B y Yi-34B-Chat se reduce al enfoque y los resultados del ajuste.Yi-34B podría ser su opción.Yi-34B-Chat podría ser su mejor opción. 
