Granit 3.0

Granite 3.0 est une famille légère et open source de modèles de langage génératifs conçus pour une gamme de tâches au niveau de l'entreprise. Il prend en charge de manière native les fonctionnalités, le codage, le raisonnement et l'utilisation d'outils multilingues, ce qui le rend adapté aux environnements d'entreprise.

J'ai testé l'exécution de ce modèle pour voir quelles tâches il peut gérer.

Configuration de l'environnement

J'ai configuré l'environnement Granite 3.0 dans Google Colab et installé les bibliothèques nécessaires à l'aide des commandes suivantes :

!pip install torch torchvision torchaudio
!pip install accelerate
!pip install -U transformers

Exécution

J'ai testé les performances des modèles 2B et 8B de Granite 3.0.

Modèle 2B

J'ai exécuté le modèle 2B. Voici l'exemple de code pour le modèle 2B :

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

device = "auto"
model_path = "ibm-granite/granite-3.0-2b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path, device_map=device)
model.eval()

chat = [
    { "role": "user", "content": "Please list one IBM Research laboratory located in the United States. You should only output its name and location." },
]
chat = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
input_tokens = tokenizer(chat, return_tensors="pt").to("cuda")
output = model.generate(**input_tokens, max_new_tokens=100)
output = tokenizer.batch_decode(output)
print(output[0])

Sortir

userPlease list one IBM Research laboratory located in the United States. You should only output its name and location.
assistant1. IBM Research - Austin, Texas

Modèle 8B

Le modèle 8B peut être utilisé en remplaçant 2b par 8b. Voici un exemple de code sans champs de rôle et de saisie utilisateur pour le modèle 8B :

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

device = "auto"
model_path = "ibm-granite/granite-3.0-8b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path, device_map=device)
model.eval()

chat = [
    { "content": "Please list one IBM Research laboratory located in the United States. You should only output its name and location." },
]
chat = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)

input_tokens = tokenizer(chat, add_special_tokens=False, return_tensors="pt").to("cuda")
output = model.generate(**input_tokens, max_new_tokens=100)
generated_text = tokenizer.decode(output[0][input_tokens["input_ids"].shape[1]:], skip_special_tokens=True)
print(generated_text)

Sortir

1. IBM Almaden Research Center - San Jose, California

Appel de fonction

J'ai exploré la fonctionnalité d'appel de fonction, en la testant avec une fonction factice. Ici, get_current_weather est défini pour renvoyer des données météorologiques simulées.

Fonction factice

import json

def get_current_weather(location: str) -> dict:
    """
    Retrieves current weather information for the specified location (default: San Francisco).
    Args:
        location (str): Name of the city to retrieve weather data for.
    Returns:
        dict: Dictionary containing weather information (temperature, description, humidity).
    """
    print(f"Getting current weather for {location}")

    try:
        weather_description = "sample"
        temperature = "20.0"
        humidity = "80.0"

        return {
            "description": weather_description,
            "temperature": temperature,
            "humidity": humidity
        }
    except Exception as e:
        print(f"Error fetching weather data: {e}")
        return {"weather": "NA"}

Création d'invite

J'ai créé une invite pour appeler la fonction :

functions = [
    {
        "name": "get_current_weather",
        "description": "Get the current weather",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city and country code, e.g. San Francisco, US",
                }
            },
            "required": ["location"],
        },
    },
]
query = "What's the weather like in Boston?"
payload = {
    "functions_str": [json.dumps(x) for x in functions]
}
chat = [
    {"role":"system","content": f"You are a helpful assistant with access to the following function calls. Your task is to produce a sequence of function calls necessary to generate response to the user utterance. Use the following function calls as required.{payload}"},
    {"role": "user", "content": query }
]

Génération de réponses

À l'aide du code suivant, j'ai généré une réponse :

instruction_1 = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
input_tokens = tokenizer(instruction_1, return_tensors="pt").to("cuda")
output = model.generate(**input_tokens, max_new_tokens=1024)
generated_text = tokenizer.decode(output[0][input_tokens["input_ids"].shape[1]:], skip_special_tokens=True)
print(generated_text)

Sortir

{'name': 'get_current_weather', 'arguments': {'location': 'Boston'}}

Cela a confirmé la capacité du modèle à générer l'appel de fonction correct en fonction de la ville spécifiée.

Spécification de format pour un flux d'interaction amélioré

Granite 3.0 permet la spécification de format pour faciliter les réponses dans des formats structurés. Cette section explique l'utilisation de [UTTERANCE] pour les réponses et de [THINK] pour les pensées intérieures.

D'un autre côté, étant donné que l'appel de fonction est généré sous forme de texte brut, il peut être nécessaire d'implémenter un mécanisme distinct pour faire la distinction entre les appels de fonction et les réponses en texte normal.

Spécification du format de sortie

Voici un exemple d'invite pour guider la sortie de l'IA :

prompt = """You are a conversational AI assistant that deepens interactions by alternating between responses and inner thoughts.

* Record spoken responses after the [UTTERANCE] tag and inner thoughts after the [THINK] tag.
* Use [UTTERANCE] as a start marker to begin outputting an utterance.
* After [THINK], describe your internal reasoning or strategy for the next response. This may include insights on the user's reaction, adjustments to improve interaction, or further goals to deepen the conversation.
* Important: **Use [UTTERANCE] and [THINK] as a start signal without needing a closing tag.**


Follow these instructions, alternating between [UTTERANCE] and [THINK] formats for responses.

example1:
  [UTTERANCE]Hello! How can I assist you today?[THINK]I’ll start with a neutral tone to understand their needs. Preparing to offer specific suggestions based on their response.[UTTERANCE]Thank you! In that case, I have a few methods I can suggest![THINK]Since I now know what they’re looking for, I'll move on to specific suggestions, maintaining a friendly and approachable tone.
...
example>

Please respond to the following user_input.

Hello! What can you do?

"""

Exemple de code d'exécution

le code pour générer une réponse :

chat = [
    { "role": "user", "content": prompt },
]
chat = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)

input_tokens = tokenizer(chat, return_tensors="pt").to("cuda")
output = model.generate(**input_tokens, max_new_tokens=1024)
generated_text = tokenizer.decode(output[0][input_tokens["input_ids"].shape[1]:], skip_special_tokens=True)
print(generated_text)

Exemple de sortie

Le résultat est le suivant :

[UTTERANCE]Hello! I'm here to provide information, answer questions, and assist with various tasks. I can help with a wide range of topics, from general knowledge to specific queries. How can I assist you today?
[THINK]I've introduced my capabilities and offered assistance, setting the stage for the user to share their needs or ask questions.

Les balises [UTTERANCE] et [THINK] ont été utilisées avec succès, permettant un formatage efficace des réponses.

En fonction de l'invite, des balises de fermeture (telles que [/UTTERANCE] ou [/THINK]) peuvent parfois apparaître dans la sortie, mais dans l'ensemble, le format de sortie peut généralement être spécifié avec succès.

Exemple de code de diffusion en continu

Voyons également comment générer des réponses en streaming.

Le code suivant utilise les bibliothèques asyncio et threading pour diffuser de manière asynchrone les réponses de Granite 3.0.

import asyncio
from threading import Thread
from typing import AsyncIterator
from transformers import (
    AutoTokenizer,
    AutoModelForCausalLM,
    TextIteratorStreamer,
)

device = "auto"
model_path = "ibm-granite/granite-3.0-8b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path, device_map=device)
model.eval()

async def generate(chat) -> AsyncIterator[str]:
    # Apply chat template and tokenize input
    chat = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
    input_tokens = tokenizer(chat, add_special_tokens=False, return_tensors="pt").to("cuda")

    # Set up the streamer
    streamer = TextIteratorStreamer(
        tokenizer,
        skip_prompt=True,
        skip_special_tokens=True,
    )
    generation_kwargs = dict(
        **input_tokens,
        streamer=streamer,
        max_new_tokens=1024,
    )
    # Generate response in a separate thread
    thread = Thread(target=model.generate, kwargs=generation_kwargs)
    thread.start()

    for output in streamer:
        if not output:
            continue
        await asyncio.sleep(0)
        yield output

# Execute asynchronous generation in the main function
async def main():
    chat = [
        { "role": "user", "content": "Please list one IBM Research laboratory located in the United States. You should only output its name and location." },
    ]
    generator = generate(chat)
    async for output in generator:  # Use async for to retrieve responses sequentially
        print(output, end="|")

await main()

Exemple de sortie

L'exécution du code ci-dessus générera des réponses asynchrones au format suivant :

1. |IBM |Almaden |Research |Center |- |San |Jose, |California|

Cet exemple illustre une diffusion en continu réussie. Chaque jeton est généré de manière asynchrone et affiché de manière séquentielle, permettant aux utilisateurs de visualiser le processus de génération en temps réel.

Résumé

Granite 3.0 fournit des réponses raisonnablement fortes, même avec le modèle 8B. Les fonctionnalités d'appel de fonction et de spécification de format fonctionnent également très bien, indiquant son potentiel pour un large éventail d'applications.