25 abr 2024
Guía sobre cómo ejecutar OpenELM - Nuevos modelos de IA presentados por Apple
Últimamente, Apple ha presentado ocho modelos de lenguaje de código abierto, los modelos OpenELM (Open-source Efficient Language Models). Lo que los hace especiales es que se ejecutan directamente en el dispositivo y no en servidores en la nube. Y en esta breve guía, te mostraremos cómo ejecutarlos y usarlos.
Regístrese en solo un minuto.
Apple ha introducido ocho modelos de lenguaje de código abierto conocidos como OpenELM (Open-source Efficient Language Models). Únicos por su capacidad para operar directamente en dispositivos en lugar de depender de servidores en la nube, estos modelos marcan un avance significativo en la tecnología de IA. Esta guía te mostrará cómo configurar y utilizar estos innovadores modelos de IA de Apple.
Modelos de Lenguaje Eficiente de Apple
Los desarrolladores ahora tienen acceso a estos grandes modelos de lenguaje, que pueden ser fácilmente descargados e implementados a través del Hugging Face Hub. Es importante señalar que cuatro de los modelos OpenELM fueron entrenados con la biblioteca CoreNet, un recurso también lanzado por Apple para el entrenamiento de redes neuronales profundas.
Los otros cuatro modelos (Instruct) están diseñados como herramientas instructivas, capaces de interpretar y responder a instrucciones directas. Esta completa gama de modelos, junto con marcos de entrenamiento y evaluación integrales, está disponible en conjuntos de datos públicos. Estos incluyen protocolos de entrenamiento detallados, diversos puntos de control y diversas configuraciones de pre-entrenamiento.
La familia OpenELM incluye varios modelos adaptados a diferentes necesidades. Haz clic para obtener más detalles sobre los modelos.
Ejecución de OpenELM a través de HuggingFace
Instalación
Para ayudarte a comenzar, hemos proporcionado una función de muestra en generate_openelm.py para generar resultados a partir de los modelos OpenELM a través de Hugging Face Hub. Para probar el modelo, simplemente ejecuta el siguiente comando:
python generate_openelm.py --model [MODEL_NAME] --hf_access_token [HF_ACCESS_TOKEN] --prompt 'Once upon a time there was' --generate_kwargs repetition_penalty=1.2Para acceder a tu token de Hugging Face, por favor siga este enlace.
Además, puedes personalizar la función generate con varios argumentos. Por ejemplo, para mejorar la velocidad de inferencia, considera usar el argumento prompt_lookup_num_tokens para generación especulativa de tokens de búsqueda.
python generate_openelm.py --model [MODEL_NAME] --hf_access_token [HF_ACCESS_TOKEN] --prompt 'Once upon a time there was' --generate_kwargs repetition_penalty=1.2 prompt_lookup_num_tokens=10O, para un modelo asistente, utiliza un modelo más pequeño a través del argumento assistant_model como se muestra a continuación:
python generate_openelm.py --model [MODEL_NAME] --hf_access_token [HF_ACCESS_TOKEN] --prompt 'Once upon a time there was' --generate_kwargs repetition_penalty=1.2 --assistant_model [SMALLER_MODEL_NAME]Configuración
Asegúrate de instalar las dependencias necesarias:
# install public lm-eval-harness
harness_repo="public-lm-eval-harness"
git clone https://github.com/EleutherAI/lm-evaluation-harness ${harness_repo}
cd ${harness_repo}
# use main branch on 03-15-2024, SHA is dc90fec
git checkout dc90fec
pip install -e .
cd ..
# 66d6242 is the main branch on 2024-04-01
pip install datasets@git+https://github.com/huggingface/datasets.git@66d6242
pip install tokenizers>=0.15.2 transformers>=4.38.2 sentencepiece>=0.2.0Evaluación de OpenELM
# OpenELM-270M
hf_model=OpenELM-270M
# this flag is needed because lm-eval-harness set add_bos_token to False by default, but OpenELM uses LLaMA tokenizer which requires add_bos_token to be True
tokenizer=meta-llama/Llama-2-7b-hf
add_bos_token=True
batch_size=1
mkdir lm_eval_output
shot=0
task=arc_challenge,arc_easy,boolq,hellaswag,piqa,race,winogrande,sciq,truthfulqa_mc2
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.log
shot=5
task=mmlu,winogrande
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.log
shot=25
task=arc_challenge,crows_pairs_english
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.log
shot=10
task=hellaswag
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.logConclusión: Consideraciones para el uso de los modelos OpenELM
La introducción de modelos OpenELM por Apple marca un avance significativo, ofreciendo a la comunidad de investigación modelos de lenguaje de última generación. Estas herramientas están entrenadas en conjuntos de datos públicamente disponibles y se proporcionan sin garantías de seguridad. Esto puede conducir a salidas que podrían ser inexactas, perjudiciales o sesgadas. Por lo tanto, es crucial que tanto los usuarios como los desarrolladores realicen extensas pruebas de seguridad y establezcan mecanismos de filtrado robustos para satisfacer sus necesidades únicas y garantizar un uso responsable.
Stay up to date
on the latest AI news by ChatLabs
25 abr 2024
Guía sobre cómo ejecutar OpenELM - Nuevos modelos de IA presentados por Apple
Últimamente, Apple ha presentado ocho modelos de lenguaje de código abierto, los modelos OpenELM (Open-source Efficient Language Models). Lo que los hace especiales es que se ejecutan directamente en el dispositivo y no en servidores en la nube. Y en esta breve guía, te mostraremos cómo ejecutarlos y usarlos.
Regístrese en solo un minuto.
Apple ha introducido ocho modelos de lenguaje de código abierto conocidos como OpenELM (Open-source Efficient Language Models). Únicos por su capacidad para operar directamente en dispositivos en lugar de depender de servidores en la nube, estos modelos marcan un avance significativo en la tecnología de IA. Esta guía te mostrará cómo configurar y utilizar estos innovadores modelos de IA de Apple.
Modelos de Lenguaje Eficiente de Apple
Los desarrolladores ahora tienen acceso a estos grandes modelos de lenguaje, que pueden ser fácilmente descargados e implementados a través del Hugging Face Hub. Es importante señalar que cuatro de los modelos OpenELM fueron entrenados con la biblioteca CoreNet, un recurso también lanzado por Apple para el entrenamiento de redes neuronales profundas.
Los otros cuatro modelos (Instruct) están diseñados como herramientas instructivas, capaces de interpretar y responder a instrucciones directas. Esta completa gama de modelos, junto con marcos de entrenamiento y evaluación integrales, está disponible en conjuntos de datos públicos. Estos incluyen protocolos de entrenamiento detallados, diversos puntos de control y diversas configuraciones de pre-entrenamiento.
La familia OpenELM incluye varios modelos adaptados a diferentes necesidades. Haz clic para obtener más detalles sobre los modelos.
Ejecución de OpenELM a través de HuggingFace
Instalación
Para ayudarte a comenzar, hemos proporcionado una función de muestra en generate_openelm.py para generar resultados a partir de los modelos OpenELM a través de Hugging Face Hub. Para probar el modelo, simplemente ejecuta el siguiente comando:
python generate_openelm.py --model [MODEL_NAME] --hf_access_token [HF_ACCESS_TOKEN] --prompt 'Once upon a time there was' --generate_kwargs repetition_penalty=1.2Para acceder a tu token de Hugging Face, por favor siga este enlace.
Además, puedes personalizar la función generate con varios argumentos. Por ejemplo, para mejorar la velocidad de inferencia, considera usar el argumento prompt_lookup_num_tokens para generación especulativa de tokens de búsqueda.
python generate_openelm.py --model [MODEL_NAME] --hf_access_token [HF_ACCESS_TOKEN] --prompt 'Once upon a time there was' --generate_kwargs repetition_penalty=1.2 prompt_lookup_num_tokens=10O, para un modelo asistente, utiliza un modelo más pequeño a través del argumento assistant_model como se muestra a continuación:
python generate_openelm.py --model [MODEL_NAME] --hf_access_token [HF_ACCESS_TOKEN] --prompt 'Once upon a time there was' --generate_kwargs repetition_penalty=1.2 --assistant_model [SMALLER_MODEL_NAME]Configuración
Asegúrate de instalar las dependencias necesarias:
# install public lm-eval-harness
harness_repo="public-lm-eval-harness"
git clone https://github.com/EleutherAI/lm-evaluation-harness ${harness_repo}
cd ${harness_repo}
# use main branch on 03-15-2024, SHA is dc90fec
git checkout dc90fec
pip install -e .
cd ..
# 66d6242 is the main branch on 2024-04-01
pip install datasets@git+https://github.com/huggingface/datasets.git@66d6242
pip install tokenizers>=0.15.2 transformers>=4.38.2 sentencepiece>=0.2.0Evaluación de OpenELM
# OpenELM-270M
hf_model=OpenELM-270M
# this flag is needed because lm-eval-harness set add_bos_token to False by default, but OpenELM uses LLaMA tokenizer which requires add_bos_token to be True
tokenizer=meta-llama/Llama-2-7b-hf
add_bos_token=True
batch_size=1
mkdir lm_eval_output
shot=0
task=arc_challenge,arc_easy,boolq,hellaswag,piqa,race,winogrande,sciq,truthfulqa_mc2
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.log
shot=5
task=mmlu,winogrande
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.log
shot=25
task=arc_challenge,crows_pairs_english
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.log
shot=10
task=hellaswag
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.logConclusión: Consideraciones para el uso de los modelos OpenELM
La introducción de modelos OpenELM por Apple marca un avance significativo, ofreciendo a la comunidad de investigación modelos de lenguaje de última generación. Estas herramientas están entrenadas en conjuntos de datos públicamente disponibles y se proporcionan sin garantías de seguridad. Esto puede conducir a salidas que podrían ser inexactas, perjudiciales o sesgadas. Por lo tanto, es crucial que tanto los usuarios como los desarrolladores realicen extensas pruebas de seguridad y establezcan mecanismos de filtrado robustos para satisfacer sus necesidades únicas y garantizar un uso responsable.
Stay up to date
on the latest AI news by ChatLabs
25 abr 2024
Guía sobre cómo ejecutar OpenELM - Nuevos modelos de IA presentados por Apple
Últimamente, Apple ha presentado ocho modelos de lenguaje de código abierto, los modelos OpenELM (Open-source Efficient Language Models). Lo que los hace especiales es que se ejecutan directamente en el dispositivo y no en servidores en la nube. Y en esta breve guía, te mostraremos cómo ejecutarlos y usarlos.
Regístrese en solo un minuto.
Apple ha introducido ocho modelos de lenguaje de código abierto conocidos como OpenELM (Open-source Efficient Language Models). Únicos por su capacidad para operar directamente en dispositivos en lugar de depender de servidores en la nube, estos modelos marcan un avance significativo en la tecnología de IA. Esta guía te mostrará cómo configurar y utilizar estos innovadores modelos de IA de Apple.
Modelos de Lenguaje Eficiente de Apple
Los desarrolladores ahora tienen acceso a estos grandes modelos de lenguaje, que pueden ser fácilmente descargados e implementados a través del Hugging Face Hub. Es importante señalar que cuatro de los modelos OpenELM fueron entrenados con la biblioteca CoreNet, un recurso también lanzado por Apple para el entrenamiento de redes neuronales profundas.
Los otros cuatro modelos (Instruct) están diseñados como herramientas instructivas, capaces de interpretar y responder a instrucciones directas. Esta completa gama de modelos, junto con marcos de entrenamiento y evaluación integrales, está disponible en conjuntos de datos públicos. Estos incluyen protocolos de entrenamiento detallados, diversos puntos de control y diversas configuraciones de pre-entrenamiento.
La familia OpenELM incluye varios modelos adaptados a diferentes necesidades. Haz clic para obtener más detalles sobre los modelos.
Ejecución de OpenELM a través de HuggingFace
Instalación
Para ayudarte a comenzar, hemos proporcionado una función de muestra en generate_openelm.py para generar resultados a partir de los modelos OpenELM a través de Hugging Face Hub. Para probar el modelo, simplemente ejecuta el siguiente comando:
python generate_openelm.py --model [MODEL_NAME] --hf_access_token [HF_ACCESS_TOKEN] --prompt 'Once upon a time there was' --generate_kwargs repetition_penalty=1.2Para acceder a tu token de Hugging Face, por favor siga este enlace.
Además, puedes personalizar la función generate con varios argumentos. Por ejemplo, para mejorar la velocidad de inferencia, considera usar el argumento prompt_lookup_num_tokens para generación especulativa de tokens de búsqueda.
python generate_openelm.py --model [MODEL_NAME] --hf_access_token [HF_ACCESS_TOKEN] --prompt 'Once upon a time there was' --generate_kwargs repetition_penalty=1.2 prompt_lookup_num_tokens=10O, para un modelo asistente, utiliza un modelo más pequeño a través del argumento assistant_model como se muestra a continuación:
python generate_openelm.py --model [MODEL_NAME] --hf_access_token [HF_ACCESS_TOKEN] --prompt 'Once upon a time there was' --generate_kwargs repetition_penalty=1.2 --assistant_model [SMALLER_MODEL_NAME]Configuración
Asegúrate de instalar las dependencias necesarias:
# install public lm-eval-harness
harness_repo="public-lm-eval-harness"
git clone https://github.com/EleutherAI/lm-evaluation-harness ${harness_repo}
cd ${harness_repo}
# use main branch on 03-15-2024, SHA is dc90fec
git checkout dc90fec
pip install -e .
cd ..
# 66d6242 is the main branch on 2024-04-01
pip install datasets@git+https://github.com/huggingface/datasets.git@66d6242
pip install tokenizers>=0.15.2 transformers>=4.38.2 sentencepiece>=0.2.0Evaluación de OpenELM
# OpenELM-270M
hf_model=OpenELM-270M
# this flag is needed because lm-eval-harness set add_bos_token to False by default, but OpenELM uses LLaMA tokenizer which requires add_bos_token to be True
tokenizer=meta-llama/Llama-2-7b-hf
add_bos_token=True
batch_size=1
mkdir lm_eval_output
shot=0
task=arc_challenge,arc_easy,boolq,hellaswag,piqa,race,winogrande,sciq,truthfulqa_mc2
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.log
shot=5
task=mmlu,winogrande
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.log
shot=25
task=arc_challenge,crows_pairs_english
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.log
shot=10
task=hellaswag
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.logConclusión: Consideraciones para el uso de los modelos OpenELM
La introducción de modelos OpenELM por Apple marca un avance significativo, ofreciendo a la comunidad de investigación modelos de lenguaje de última generación. Estas herramientas están entrenadas en conjuntos de datos públicamente disponibles y se proporcionan sin garantías de seguridad. Esto puede conducir a salidas que podrían ser inexactas, perjudiciales o sesgadas. Por lo tanto, es crucial que tanto los usuarios como los desarrolladores realicen extensas pruebas de seguridad y establezcan mecanismos de filtrado robustos para satisfacer sus necesidades únicas y garantizar un uso responsable.
Stay up to date
on the latest AI news by ChatLabs
25 abr 2024
Guía sobre cómo ejecutar OpenELM - Nuevos modelos de IA presentados por Apple
Últimamente, Apple ha presentado ocho modelos de lenguaje de código abierto, los modelos OpenELM (Open-source Efficient Language Models). Lo que los hace especiales es que se ejecutan directamente en el dispositivo y no en servidores en la nube. Y en esta breve guía, te mostraremos cómo ejecutarlos y usarlos.
Regístrese en solo un minuto.
Apple ha introducido ocho modelos de lenguaje de código abierto conocidos como OpenELM (Open-source Efficient Language Models). Únicos por su capacidad para operar directamente en dispositivos en lugar de depender de servidores en la nube, estos modelos marcan un avance significativo en la tecnología de IA. Esta guía te mostrará cómo configurar y utilizar estos innovadores modelos de IA de Apple.
Modelos de Lenguaje Eficiente de Apple
Los desarrolladores ahora tienen acceso a estos grandes modelos de lenguaje, que pueden ser fácilmente descargados e implementados a través del Hugging Face Hub. Es importante señalar que cuatro de los modelos OpenELM fueron entrenados con la biblioteca CoreNet, un recurso también lanzado por Apple para el entrenamiento de redes neuronales profundas.
Los otros cuatro modelos (Instruct) están diseñados como herramientas instructivas, capaces de interpretar y responder a instrucciones directas. Esta completa gama de modelos, junto con marcos de entrenamiento y evaluación integrales, está disponible en conjuntos de datos públicos. Estos incluyen protocolos de entrenamiento detallados, diversos puntos de control y diversas configuraciones de pre-entrenamiento.
La familia OpenELM incluye varios modelos adaptados a diferentes necesidades. Haz clic para obtener más detalles sobre los modelos.
Ejecución de OpenELM a través de HuggingFace
Instalación
Para ayudarte a comenzar, hemos proporcionado una función de muestra en generate_openelm.py para generar resultados a partir de los modelos OpenELM a través de Hugging Face Hub. Para probar el modelo, simplemente ejecuta el siguiente comando:
python generate_openelm.py --model [MODEL_NAME] --hf_access_token [HF_ACCESS_TOKEN] --prompt 'Once upon a time there was' --generate_kwargs repetition_penalty=1.2Para acceder a tu token de Hugging Face, por favor siga este enlace.
Además, puedes personalizar la función generate con varios argumentos. Por ejemplo, para mejorar la velocidad de inferencia, considera usar el argumento prompt_lookup_num_tokens para generación especulativa de tokens de búsqueda.
python generate_openelm.py --model [MODEL_NAME] --hf_access_token [HF_ACCESS_TOKEN] --prompt 'Once upon a time there was' --generate_kwargs repetition_penalty=1.2 prompt_lookup_num_tokens=10O, para un modelo asistente, utiliza un modelo más pequeño a través del argumento assistant_model como se muestra a continuación:
python generate_openelm.py --model [MODEL_NAME] --hf_access_token [HF_ACCESS_TOKEN] --prompt 'Once upon a time there was' --generate_kwargs repetition_penalty=1.2 --assistant_model [SMALLER_MODEL_NAME]Configuración
Asegúrate de instalar las dependencias necesarias:
# install public lm-eval-harness
harness_repo="public-lm-eval-harness"
git clone https://github.com/EleutherAI/lm-evaluation-harness ${harness_repo}
cd ${harness_repo}
# use main branch on 03-15-2024, SHA is dc90fec
git checkout dc90fec
pip install -e .
cd ..
# 66d6242 is the main branch on 2024-04-01
pip install datasets@git+https://github.com/huggingface/datasets.git@66d6242
pip install tokenizers>=0.15.2 transformers>=4.38.2 sentencepiece>=0.2.0Evaluación de OpenELM
# OpenELM-270M
hf_model=OpenELM-270M
# this flag is needed because lm-eval-harness set add_bos_token to False by default, but OpenELM uses LLaMA tokenizer which requires add_bos_token to be True
tokenizer=meta-llama/Llama-2-7b-hf
add_bos_token=True
batch_size=1
mkdir lm_eval_output
shot=0
task=arc_challenge,arc_easy,boolq,hellaswag,piqa,race,winogrande,sciq,truthfulqa_mc2
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.log
shot=5
task=mmlu,winogrande
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.log
shot=25
task=arc_challenge,crows_pairs_english
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.log
shot=10
task=hellaswag
lm_eval --model hf \
--model_args pretrained=${hf_model},trust_remote_code=True,add_bos_token=${add_bos_token},tokenizer=${tokenizer} \
--tasks ${task} \
--device cuda:0 \
--num_fewshot ${shot} \
--output_path ./lm_eval_output/${hf_model//\//_}_${task//,/_}-${shot}shot \
--batch_size ${batch_size} 2>&1 | tee ./lm_eval_output/eval-${hf_model//\//_}_${task//,/_}-${shot}shot.logConclusión: Consideraciones para el uso de los modelos OpenELM
La introducción de modelos OpenELM por Apple marca un avance significativo, ofreciendo a la comunidad de investigación modelos de lenguaje de última generación. Estas herramientas están entrenadas en conjuntos de datos públicamente disponibles y se proporcionan sin garantías de seguridad. Esto puede conducir a salidas que podrían ser inexactas, perjudiciales o sesgadas. Por lo tanto, es crucial que tanto los usuarios como los desarrolladores realicen extensas pruebas de seguridad y establezcan mecanismos de filtrado robustos para satisfacer sus necesidades únicas y garantizar un uso responsable.
Stay up to date
on the latest AI news by ChatLabs
Regístrese en solo un minuto.
© 2023 Writingmate.ai
© 2023 Writingmate.ai
© 2023 Writingmate.ai
© 2023 Writingmate.ai