ग्रेनाइट 3.0

ग्रेनाइट 3.0 एक ओपन-सोर्स, जेनेरिक भाषा मॉडल का हल्का परिवार है जिसे एंटरप्राइज़-स्तरीय कार्यों की एक श्रृंखला के लिए डिज़ाइन किया गया है। यह मूल रूप से बहु-भाषा कार्यक्षमता, कोडिंग, तर्क और उपकरण उपयोग का समर्थन करता है, जो इसे उद्यम वातावरण के लिए उपयुक्त बनाता है।

मैंने यह देखने के लिए इस मॉडल का परीक्षण किया कि यह कौन से कार्य संभाल सकता है।

पर्यावरण सेटअप

मैंने Google Colab में ग्रेनाइट 3.0 वातावरण स्थापित किया और निम्नलिखित कमांड का उपयोग करके आवश्यक लाइब्रेरी स्थापित की:

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

कार्यान्वयन

मैंने ग्रेनाइट 3.0 के 2बी और 8बी दोनों मॉडलों के प्रदर्शन का परीक्षण किया।

2बी मॉडल

मैंने 2बी मॉडल चलाया। यहां 2बी मॉडल के लिए कोड नमूना है:

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])

उत्पादन

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

8बी मॉडल

8बी मॉडल का उपयोग 2बी को 8बी से बदलकर किया जा सकता है। यहां 8बी मॉडल के लिए भूमिका और उपयोगकर्ता इनपुट फ़ील्ड के बिना एक कोड नमूना है:

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)

उत्पादन

1. IBM Almaden Research Center - San Jose, California

फ़ंक्शन कॉलिंग

मैंने फ़ंक्शन कॉलिंग सुविधा की खोज की, इसे एक डमी फ़ंक्शन के साथ परीक्षण किया। यहां, get_current_weather को नकली मौसम डेटा लौटाने के लिए परिभाषित किया गया है।

डमी फ़ंक्शन

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"}

शीघ्र निर्माण

मैंने फ़ंक्शन को कॉल करने के लिए एक संकेत बनाया:

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 }
]

प्रतिक्रिया सृजन

निम्नलिखित कोड का उपयोग करके, मैंने एक प्रतिक्रिया उत्पन्न की:

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)

उत्पादन

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

इसने निर्दिष्ट शहर के आधार पर सही फ़ंक्शन कॉल उत्पन्न करने की मॉडल की क्षमता की पुष्टि की।

उन्नत इंटरेक्शन फ़्लो के लिए प्रारूप विशिष्टता

ग्रेनाइट 3.0 संरचित प्रारूपों में प्रतिक्रियाओं को सुविधाजनक बनाने के लिए प्रारूप विनिर्देश की अनुमति देता है। यह खंड प्रतिक्रियाओं के लिए [उचित] और आंतरिक विचारों के लिए [सोचें] का उपयोग करने की व्याख्या करता है।

दूसरी ओर, चूंकि फ़ंक्शन कॉलिंग सादे पाठ के रूप में आउटपुट होती है, इसलिए फ़ंक्शन कॉल और नियमित टेक्स्ट प्रतिक्रियाओं के बीच अंतर करने के लिए एक अलग तंत्र लागू करना आवश्यक हो सकता है।

आउटपुट स्वरूप निर्दिष्ट करना

एआई के आउटपुट को निर्देशित करने के लिए यहां एक नमूना संकेत दिया गया है:

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?

"""

निष्पादन कोड उदाहरण

प्रतिक्रिया उत्पन्न करने के लिए कोड:

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)

उदाहरण आउटपुट

आउटपुट इस प्रकार है:

[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.

[UTTERANCE] और [THINK] टैग का सफलतापूर्वक उपयोग किया गया, जिससे प्रभावी प्रतिक्रिया स्वरूपण की अनुमति मिली।

संकेत के आधार पर, समापन टैग (जैसे कि [/UTTERANCE] या [/THINK]) कभी-कभी आउटपुट में दिखाई दे सकते हैं, लेकिन कुल मिलाकर, आउटपुट प्रारूप आम तौर पर सफलतापूर्वक निर्दिष्ट किया जा सकता है।

स्ट्रीमिंग कोड उदाहरण

आइए यह भी देखें कि स्ट्रीमिंग प्रतिक्रियाओं को कैसे आउटपुट किया जाए।

निम्नलिखित कोड ग्रेनाइट 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()

उदाहरण आउटपुट

उपरोक्त कोड को चलाने से निम्नलिखित प्रारूप में अतुल्यकालिक प्रतिक्रियाएं उत्पन्न होंगी:

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

यह उदाहरण सफल स्ट्रीमिंग को दर्शाता है। प्रत्येक टोकन अतुल्यकालिक रूप से उत्पन्न होता है और क्रमिक रूप से प्रदर्शित होता है, जिससे उपयोगकर्ता वास्तविक समय में उत्पादन प्रक्रिया को देख सकते हैं।

सारांश

ग्रेनाइट 3.0 8बी मॉडल के साथ भी काफी मजबूत प्रतिक्रिया प्रदान करता है। फ़ंक्शन कॉलिंग और फ़ॉर्मेट विशिष्टता सुविधाएं भी काफी अच्छी तरह से काम करती हैं, जो अनुप्रयोगों की एक विस्तृत श्रृंखला के लिए इसकी क्षमता को दर्शाती है।