Los modelos Snowflake Arctic ya están disponibles en Amazon SageMaker JumpStart

Esta publicación está coescrita con Matt Marzillo de Snowflake.

Hoy, nos complace anunciar que el modelo Snowflake Arctic Instruct está disponible a través de Inicio rápido de Amazon SageMaker para implementar y ejecutar la inferencia. Copo de nieve del Ártico es una familia de modelos de lenguaje grandes (LLM) de nivel empresarial creados por Copo de nieve para satisfacer las necesidades de los usuarios empresariales, exhibiendo capacidades excepcionales (como se muestra en la siguiente imagen). puntos de referencia) en consultas SQL, codificación y seguimiento preciso de instrucciones. SageMaker JumpStart es un centro de aprendizaje automático (ML) que brinda acceso a algoritmos, modelos y soluciones de ML para que pueda comenzar rápidamente con ML.

En esta publicación, explicamos cómo descubrir e implementar el modelo Snowflake Arctic Instruct usando SageMaker JumpStart y brindamos casos de uso de ejemplo con indicaciones específicas.

¿Qué es Snowflake Arctic?

Copo de nieve del Ártico es un LLM enfocado en la empresa que ofrece inteligencia empresarial de primer nivel entre los LLM abiertos con una relación costo-beneficio altamente competitiva. Snowflake puede lograr una alta inteligencia empresarial a través de una densa combinación de expertos (MoE). arquitectura de transformador híbrido y técnicas de entrenamiento eficientes. Con la arquitectura de transformador híbrido, Artic está diseñado con un modelo de transformador denso de 10 mil millones combinado con un MLP residual de 128 × 3,66 B MoE que da como resultado un total de 480 mil millones de parámetros distribuidos entre 128 expertos de grano fino y utiliza una selección de top-2 para elegir 17 mil millones de parámetros activos. Esto permite que Snowflake Arctic tenga una mayor capacidad para la inteligencia empresarial debido a la gran cantidad de parámetros totales y, al mismo tiempo, sea más eficiente en términos de recursos para el entrenamiento y la inferencia al utilizar la cantidad moderada de parámetros activos.

Snowflake Arctic se capacita con un plan de estudios de datos de tres etapas con diferente composición de datos que se centra en habilidades genéricas en la primera fase (1 billón de tokens, la mayoría de datos web) y habilidades centradas en la empresa en las dos fases siguientes (1,5 billones y 1 billón de tokens, respectivamente, con más datos de código, SQL y STEM). Esto ayuda al modelo Snowflake Arctic a establecer una nueva base de inteligencia empresarial y, al mismo tiempo, a ser rentable.

Además de la capacitación rentable, Snowflake Arctic también viene con una serie de innovaciones y optimizaciones para ejecutar la inferencia de manera eficiente. En tamaños de lotes pequeños, la inferencia está limitada por el ancho de banda de la memoria, y Snowflake Arctic puede tener hasta cuatro veces menos lecturas de memoria en comparación con otros modelos disponibles abiertamente, lo que genera un rendimiento de inferencia más rápido. En tamaños de lotes muy grandes, la inferencia pasa a estar limitada por el cálculo y Snowflake Arctic incurre en hasta cuatro veces menos cálculo en comparación con otros modelos disponibles abiertamente. Los modelos de Snowflake Arctic están disponibles bajo una licencia Apache 2.0, que proporciona acceso sin restricciones a los pesos y al código. Todas las recetas de datos y los conocimientos de investigación también estarán disponibles para los clientes.

¿Qué es SageMaker JumpStart?

Con SageMaker JumpStart, puede elegir entre una amplia selección de modelos de base (FM) disponibles públicamente. Los profesionales de ML pueden implementar FM en Amazon SageMaker instancias de un entorno aislado de red y personalice modelos con SageMaker para el entrenamiento y la implementación de modelos. Ahora puede descubrir e implementar el modelo Arctic Instruct con unos pocos clics en Estudio Amazon SageMaker o programáticamente a través del SDK de Python de SageMaker, lo que le permite derivar controles de operaciones de aprendizaje automático (MLOps) y rendimiento del modelo con funciones de SageMaker como Canalizaciones de Amazon SageMaker, Depurador de Amazon SageMakero registros de contenedores. El modelo se implementa en un entorno seguro de AWS y bajo los controles de su nube privada virtual (VPC), lo que ayuda a brindar seguridad a los datos. El modelo Snowflake Arctic Instruct está disponible hoy para implementación e inferencia en SageMaker Studio en us-east-2 Región de AWS, con disponibilidad futura planificada en regiones adicionales.

Descubre modelos

Puede acceder a los modelos de modelo a través de SageMaker JumpStart en la interfaz de usuario de SageMaker Studio y el SDK de Python de SageMaker. En esta sección, repasaremos cómo descubrir los modelos en SageMaker Studio.

SageMaker Studio es un entorno de desarrollo integrado (IDE) que proporciona una única interfaz visual basada en la web donde puede acceder a herramientas diseñadas específicamente para realizar todos los pasos de desarrollo de ML, desde la preparación de datos hasta la creación, el entrenamiento y la implementación de sus modelos de ML. Para obtener más detalles sobre cómo comenzar y configurar SageMaker Studio, consulte Estudio Amazon SageMaker.

En SageMaker Studio, puede acceder a SageMaker JumpStart, que contiene modelos entrenados previamente, cuadernos y soluciones prediseñadas, en Soluciones preconstruidas y automatizadas.

Desde la página de inicio de SageMaker JumpStart, puede descubrir varios modelos explorando diferentes centros, que reciben el nombre de proveedores de modelos. Puede encontrar el modelo Snowflake Arctic Instruct en el centro Hugging Face. Si no ve el modelo Arctic Instruct, actualice su versión de SageMaker Studio apagándolo y reiniciándolo. Para obtener más información, consulte Apagar y actualizar las aplicaciones de Studio Classic.

También puedes encontrar el modelo Snowflake Arctic Instruct buscando “Snowflake” en el campo de búsqueda.

Puede elegir la tarjeta del modelo para ver detalles sobre el modelo, como la licencia, los datos utilizados para entrenar y cómo utilizar el modelo. También encontrará dos opciones para implementar el modelo: los cuadernos Implementar y Vista previa, que implementarán el modelo y crearán un punto final.

Implementar el modelo en SageMaker Studio

Cuando elija Implementar en SageMaker Studio, comenzará la implementación.

Puede supervisar el progreso de la implementación en la página de detalles del punto final a la que será redirigido.

Implementar el modelo a través de un notebook

Como alternativa, puede elegir Abrir cuaderno para implementar el modelo a través del cuaderno de ejemplo. El cuaderno de ejemplo proporciona una guía completa sobre cómo implementar el modelo para la inferencia y la limpieza de recursos.

Para implementar mediante el cuaderno, comience seleccionando un modelo adecuado, especificado por model_id. Puede implementar cualquiera de los modelos seleccionados en SageMaker con el siguiente código:

from sagemaker.jumpstart.model import JumpStartModel
model = JumpStartModel(model_id = "huggingface-llm-snowflake-arctic-instruct-vllm")

predictor = model.deploy()

Esto implementa el modelo en SageMaker con configuraciones predeterminadas, incluido el tipo de instancia predeterminado y las configuraciones de VPC predeterminadas. Puede cambiar estas configuraciones especificando valores no predeterminados en JumpStartModel. Para obtener más información, consulte Documentación de la API.

Ejecutar inferencia

Después de implementar el modelo, puede ejecutar inferencias contra el punto final implementado a través de API de predicción de SageMakerSnowflake Arctic Instruct acepta el historial de chats entre el usuario y el asistente y genera chats posteriores.

predictor.predict(payload)

Los parámetros de inferencia controlan el proceso de generación de texto en el punto final. El parámetro de máximo de tokens nuevos controla el tamaño de la salida generada por el modelo. Puede que no sea el mismo que la cantidad de palabras porque el vocabulario del modelo no es el mismo que el vocabulario del idioma inglés. El parámetro de temperatura controla la aleatoriedad de la salida. Una temperatura más alta da como resultado salidas más creativas y alucinógenas. Todos los parámetros de inferencia son opcionales.

El modelo acepta instrucciones formateadas en las que los roles de conversación deben comenzar con una indicación del usuario y alternar entre las instrucciones del usuario y el asistente. El formato de la instrucción debe respetarse estrictamente, de lo contrario, el modelo generará resultados subóptimos. La plantilla para crear una indicación para el modelo se define de la siguiente manera:

<|im_start|>system
{system_message} <|im_end|>
<|im_start|>user
{human_message} <|im_end|>
<|im_start|>assistant\n

<|im_start|> y <|im_end|> son tokens especiales para el comienzo de la cadena (BOS) y el final de la cadena (EOS). El modelo puede contener múltiples turnos de conversación entre el sistema, el usuario y el asistente, lo que permite la incorporación de ejemplos de pocos intentos para mejorar las respuestas del modelo.

El siguiente código muestra cómo puedes formatear el mensaje en formato de instrucción:

<|im_start|>user\n5x + 35 = 7x -60 + 10. Solve for x<|im_end|>\n<|im_start|>assistant\n

from typing import Dict, List

def format_instructions(instructions: List[Dict[str, str]]) -> List[str]:
    """Format instructions where conversation roles must alternate system/user/assistant/user/assistant/..."""
    prompt: List[str] = []
    for instruction in instructions:
        if instruction["role"] == "system":
            prompt.extend(["<|im_start|>system\n", (instruction["content"]).strip(), "<|im_end|>\n"])
        elif instruction["role"] == "user":
            prompt.extend(["<|im_start|>user\n", (instruction["content"]).strip(), "<|im_end|>\n"])
        else:
            raise ValueError(f"Invalid role: {instruction['role']}. Role must be either 'user' or 'system'.")
    prompt.extend(["<|im_start|>assistant\n"])
    return "".join(prompt)

def print_instructions(prompt: str, response: str) -> None:
    bold, unbold = '\033[1m', '\033[0m'
    print(f"{bold}> Input{unbold}\n{prompt}\n\n{bold}> Output{unbold}\n{response[0]['generated_text'].strip()}\n")

En las siguientes secciones proporcionamos ejemplos de indicaciones para diferentes casos de uso centrados en la empresa.

Resumen de texto largo

Puede utilizar Snowflake Arctic Instruct para tareas personalizadas, como resumir texto extenso en una salida con formato JSON. A través de la generación de texto, puede realizar una variedad de tareas, como resumen de texto, traducción de idiomas, generación de código, análisis de sentimientos y más. La carga útil de entrada al punto final se parece al siguiente código:

payload = {
“inputs”: str,
(optional)"parameters":{"max_new_tokens":int, "top_p":float, "temperature":float}
}

A continuación se muestra un ejemplo de un mensaje y el texto generado por el modelo. Todos los resultados se generan con parámetros de inferencia. {"max_new_tokens":512, "top_p":0.95, "temperature":0.7, "top_k":50}.

La entrada es la siguiente:

instructions = [
{
"role": "user",
"content": """Summarize this transcript in less than 200 words.
Put the product name, defect and summary in JSON format.

Transcript:

Customer: Hello

Agent: Hi there, I hope you're having a great day! To better assist you, could you please provide your first and last name and the company you are calling from?

Customer: Sure, my name is Jessica Turner and I'm calling from Mountain Ski Adventures.

Agent: Thanks, Jessica. What can I help you with today?

Customer: Well, we recently ordered a batch of XtremeX helmets, and upon inspection, we noticed that the buckles on several helmets are broken and won't secure the helmet properly.

Agent: I apologize for the inconvenience this has caused you. To confirm, is your order number 68910?

Customer: Yes, that's correct.

Agent: Thank you for confirming. I'm going to look into this issue and see what we can do to correct it. Would you prefer a refund or a replacement for the damaged helmets?

Customer: A replacement would be ideal, as we still need the helmets for our customers.

Agent: I understand. I will start the process to send out replacements for the damaged helmets as soon as possible. Can you please specify the quantity of helmets with broken buckles?

Customer: There are ten helmets with broken buckles in total.

Agent: Thank you for providing me with the quantity. We will expedite a new shipment of ten XtremeX helmets with functioning buckles to your location. You should expect them to arrive within 3-5 business days.

Customer: Thank you for your assistance, I appreciate it.

Agent: You're welcome, Jessica! If you have any other questions or concerns, please don't hesitate to contact us. Have a great day!
"""
}
]

prompt = format_instructions(instructions)
inputs = {
"inputs": prompt,
"parameters": {
"temperature": 0.1,
"top_p": 0.95,
"max_new_tokens": 512,
"do_sample": False
}
}
response = predictor.predict(inputs)
print_instructions(prompt, response)

Obtenemos el siguiente resultado:

> Output
{
"product_name": "XtremeX helmets",
"defect": "broken buckles",
"summary": "Customer reports that several XtremeX helmets have broken buckles that won't secure the helmet properly. They prefer a replacement as they still need the helmets for their customers. Agent confirms the order number and will send out replacements for the damaged helmets within 3-5 business days."
}

Generación de código

Usando el ejemplo anterior, podemos utilizar indicaciones de generación de código de la siguiente manera:

instructions = [
{
"role": "user",
"content": "Write a function in Python to write a json file:"
}
]
prompt = format_instructions(instructions)
inputs = {
"inputs": prompt,
"parameters": {
"temperature": 0.1,
"top_p": 0.95,
"max_new_tokens": 400,
"do_sample": False
}
}
response = predictor.predict(inputs)
print_instructions(prompt, response)

El código anterior utiliza Snowflake Arctic Instruct para generar una función Python que escribe un archivo JSON. Define un diccionario de carga útil con el mensaje de entrada “Escribir una función en Python para escribir un archivo JSON:” y algunos parámetros para controlar el proceso de generación, como la cantidad máxima de tokens para generar y si se habilita el muestreo. Envía esta carga útil a un predictor (probablemente una API), recibe la respuesta de texto generada y la imprime en la consola. La salida impresa debe ser la función Python para escribir un archivo JSON, como se solicita en el mensaje.

El siguiente es el resultado:

> Input
<|im_start|>user
Write a function in Python to write a json file:<|im_end|>
<|im_start|>assistant

> Output
Here is a simple function in Python that writes a Python dictionary to a JSON file:

```python
import json

def write_json(data, filename):
with open(filename, 'w') as f:
json.dump(data, f)
```

You can use this function to write a Python dictionary to a file like this:

```python
data = {
"name": "John",
"age": 30,
"city": "New York"
}

write_json(data, 'output.json')
```

Esto creará un archivo llamado `output.json` en el mismo directorio que su script de Python y escribirá el diccionario `data` en ese archivo en formato JSON.

El resultado de la generación de código define el write_json que toma el nombre del archivo y un objeto Python y escribe el objeto como datos JSON. El resultado muestra el contenido del archivo JSON esperado, lo que ilustra las capacidades de generación de código y procesamiento de lenguaje natural del modelo.

Matemáticas y razonamiento

Snowflake Arctic Instruct también informa sobre la solidez del razonamiento matemático. Utilicemos el siguiente mensaje para probarlo:

instructions = [
{
"role": "user",
"content": "I bought an ice cream for 6 kids. Each cone was $1.25 and I paid with a $10 bill. How many dollars did I get back? Explain first before answering."
}
]
prompt = format_instructions(instructions)
inputs = {
"inputs": prompt,
"parameters": {
"temperature": 0.6,
"top_p": 0.9,
"max_new_tokens": 200,
"do_sample": False
}
}
response = predictor.predict(inputs)
print_instructions(prompt, response)

El siguiente es el resultado:

> Input
<|im_start|>user
I bought an ice cream for 6 kids. Each cone was $1.25 and I paid with a $10 bill. How many dollars did I get back? Explain first before answering.<|im_end|>
<|im_start|>assistant

> Output
To solve this problem, we first need to calculate the total cost of the ice cream cones and then subtract that amount from the $10 bill to find out how much change was received.

Step 1: Calculate the total cost of the ice cream cones
There are 6 kids, and each cone costs $1.25. So, the total cost is:
6 kids * $1.25/cone = $7.50

Step 2: Calculate the change received
You paid with a $10 bill, so to find out how much change you got back, subtract the total cost from the $10 bill:
$10 - $7.50 = $2.50

So, you received $2.50 in change.

El código anterior muestra la capacidad de Snowflake Arctic para comprender indicaciones en lenguaje natural que involucran razonamiento matemático, dividirlas en pasos lógicos y generar explicaciones y soluciones similares a las humanas.

Generación de SQL

El modelo Arctic Instruct de Snowflake también es capaz de generar consultas SQL basadas en indicaciones de lenguaje natural y en su entrenamiento inteligente empresarial. Ponemos a prueba esa capacidad con la siguiente indicación:

question = "Show the average price by cut and sort the results by average price in descending order"
context = """
Here is the table name <tableName> ML_HOL_DB.ML_HOL_SCHEMA.DIAMONDS </tableName>

<tableDescription> This table has data on diamond sales from our favorite diamond dealer. </tableDescription>

Here are the columns of the ML_HOL_DB.ML_HOL_SCHEMA.DIAMONDS

<columns>\n\n CARAT, CUT, COLOR, CLARITY, DEPTH, TABLE_PCT, PRICE, X, Y, Z \n\n</columns>
"""
instructions = [
{
"role": "user",
"content": """You will be acting as an AI Snowflake SQL Expert named Snowflake Cortex Assistant.
Your goal is to give correct, executable sql query to users.
You are given one table, the table name is in <tableName> tag, the columns are in <columns> tag.
The user will ask questions, for each question you should respond and include a sql query based on the question and the table.

{context}

Here are 7 critical rules for the interaction you must abide:
<rules>
1. You MUST MUST wrap the generated sql code within ``` sql code markdown in this format e.g
```sql
(select 1) union (select 2)
```
2. If I don't tell you to find a limited set of results in the sql query or question, you MUST limit the number of responses to 10.
3. Text / string where clauses must be fuzzy match e.g ilike %keyword%
4. Make sure to generate a single snowflake sql code, not multiple.
5. YOU SHOULD USE ONLY THE COLUMN NAMES IN <COLUMNS>, AND THE TABLE GIVEN IN <TABLENAME>.
6. DO NOT put numerical at the very front of sql variable.
7. BE CONCISE. DO NOT SHOW ANY TEXT AFTER THE SQL QUERY! ONLY SHOW THE SQL QUERY AND NOTHING ELSE!
</rules>

Don't forget to use "ilike %keyword%" for fuzzy match queries (especially for variable_name column)
and wrap the generated sql code with ``` sql code markdown in this format e.g:
```sql
(select 1) union (select 2)
```

For each question from the user, make sure to include a SQL QUERY in your response.

Question: {question}

Answer: the most important piece of information is the SQL QUERY. BE CONCISE AND JUST SHOW THE SQL QUERY. DO NOT SHOW ANY TEXT AFTER THE SQL QUERY!')) as response
""".format(context=context, question=question)
}
]

prompt = format_instructions(instructions)
inputs = {
"inputs": prompt,
"parameters": {
"temperature": 0.1,
"top_p": 0.95,
"max_new_tokens": 512,
"do_sample": False
}
}
response = predictor.predict(inputs)
print_instructions(prompt, response)

El siguiente es el resultado:

> Output
SELECT CUT, AVG(PRICE) as AVG_PRICE FROM ML_HOL_DB.ML_HOL_SCHEMA.DIAMONDS 
GROUP BY CUT ORDER BY AVG_PRICE DESC LIMIT 10;

El resultado muestra que Snowflake Arctic Instruct infirió los campos específicos de interés en las tablas y proporcionó una consulta ligeramente más compleja que implica unir dos tablas para obtener el resultado deseado.

Limpiar

Una vez que hayas terminado de ejecutar el cuaderno, elimina todos los recursos que hayas creado en el proceso para detener la facturación. Usa el siguiente código:

predictor.delete_model()
predictor.delete_endpoint()

Al implementar el punto final desde la consola de SageMaker Studio, puede eliminarlo eligiendo Eliminar en la página de detalles del punto final.

Conclusión

En esta publicación, le mostramos cómo comenzar a usar el modelo Snowflake Arctic Instruct en SageMaker Studio y le proporcionamos ejemplos de indicaciones para múltiples casos de uso empresariales. Debido a que los FM están entrenados previamente, también pueden ayudar a reducir los costos de capacitación e infraestructura y permitir la personalización para su caso de uso. Consulte Puesta en marcha de SageMaker en SageMaker Studio ahora para comenzar. Para obtener más información, consulte los siguientes recursos:

Acerca de los autores

Natarajan Chennimalai Kumar – Arquitecto de soluciones principal, proveedores de modelos 3P, AWS
Pavan Kumar Rao Navule – Arquitecto de soluciones, AWS
Nidhi Gupta – Arquitecta de soluciones para socios sénior, AWS
Bosco Albuquerque – Arquitecto de soluciones para socios sénior, AWS
Matt Marzillo – Ingeniero asociado sénior, Snowflake
Nithin Vijeaswaran – Arquitecto de soluciones, AWS
Armando Diaz – Arquitecto de Soluciones, AWS
Supriya Puragundla – Arquitecta de soluciones sénior, AWS
Jin Tan Ruan – Desarrollador de prototipos, AWS