Amazon Nova मॉडल्स: उदाहरणों सहित एक मार्गदर्शिका

Amazon Nova मॉडल्स क्या हैं?

Amazon के Nova मॉडल्स बहुप्रतीक्षित आधारभूत मॉडल्स हैं जिन्हें Amazon Bedrock सर्विस के माध्यम से एक्सेस किया जा सकता है। ये तेज़ और कम लागत वाले इनफ़रेंस, मल्टीमीडिया अंडरस्टैंडिंग, और क्रिएटिव कंटेंट जनरेशन सहित कई तरह के उपयोगों के लिए बनाए गए हैं। आइए प्रत्येक मॉडल को देखें।

Amazon Nova Micro

परिवार का सबसे तेज़ मॉडल, जिसमें सर्वोच्च स्पीड और कम कंप्यूटेशनल लागत है। Micro उन एप्लिकेशन्स के लिए सर्वोत्तम है जिन्हें केवल टेक्स्ट जनरेशन में तेज़ी चाहिए, और यह 200 टोकन/सेकंड की इनफ़रेंस स्पीड देता है।

Micro के कुछ बेहतरीन उपयोग हैं रियल-टाइम विश्लेषण, इंटरैक्टिव चैटबॉट्स, और हाई-ट्रैफ़िक टेक्स्ट जनरेशन सेवाएँ।

Nova Micro बेंचमार्क्स। (स्रोत: Amazon)

Amazon Nova Lite

Nova परिवार का किफायती मल्टीमोडल सदस्य, Lite, स्पीड और उच्च शुद्धता के बीच अच्छा संतुलन देता है—खासकर तर्क-वितर्क और अनुवाद जैसे कार्यों में—जबकि इसके समकक्ष GPT-4o या Llama से तुलना की जाए।

यह बड़े पैमाने के अनुरोधों को दक्षता से संभाल सकता है और साथ ही मजबूत शुद्धता बनाए रखता है। Lite उन एप्लिकेशन्स के लिए एक उपयुक्त विकल्प हो सकता है जहाँ स्पीड अत्यंत महत्वपूर्ण है और एक ऐसा मॉडल चाहिए जो कई मॉडैलिटीज़ संभाल सके।

Nova Lite बेंचमार्क्स। (स्रोत: Amazon)

Amazon Nova Pro

Nova परिवार में टेक्स्ट प्रोसेसिंग के लिए सबसे उन्नत मॉडल Nova Pro है, जो समान क्षमताओं वाले मॉडल्स की तुलना में अपेक्षाकृत कम कंप्यूटेशनल लागत पर प्रभावशाली शुद्धता प्रदान करता है।

Amazon के अनुसार, Nova Pro वीडियो सारांश, प्रश्नोत्तर, गणितीय तर्क, सॉफ्टवेयर विकास, और बहु-चरणीय वर्कफ़्लो निष्पादित करने में सक्षम AI एजेंट्स जैसे अनुप्रयोगों के लिए उपयुक्त है। Micro और Lite मॉडल्स की तरह, Nova Pro फिलहाल फाइन-ट्यूनिंग को सपोर्ट करता है।

Nova Pro बेंचमार्क्स। (स्रोत: Amazon)

Amazon Nova Premier

परिवार का सबसे सक्षम मल्टीमोडल मॉडल, जो अभी 2025 की शुरुआत में आने वाला है, उम्मीद है कि Pro मॉडल से एक कदम आगे होगा।

Amazon Nova Canvas

Canvas, Nova का इमेज जनरेशन समाधान है। यह उच्च-गुणवत्ता वाली छवियाँ बना सकता है, रंग-संयोजन और शैली पर नियंत्रण देता है, और इनपेंटिंग, आउटपेंटिंग, इमेज बढ़ाना, स्टाइल ट्रांसफ़र, तथा बैकग्राउंड रिमूवल जैसी सुविधाएँ प्रदान करता है। यह मॉडल मार्केटिंग इमेजेज़, प्रोडक्ट मॉकअप्स आदि बनाने के लिए उपयोगी लगता है।

Amazon Nova Reel

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

Amazon Bedrock Playground के जरिए Amazon Nova मॉडल्स तक कैसे पहुँचें

आप Amazon Bedrock Playground का उपयोग तैयार-उपयोग इंटरफ़ेस के जरिए कई मॉडल्स का परीक्षण और तुलना करने के लिए कर सकते हैं।

मैं मान कर चल रहा हूँ कि आपके पास Amazon CLI और Bedrock कॉन्फ़िगर होकर उपयोग के लिए तैयार हैं। यदि नहीं, तो आप मेरे AWS Multi-Agent Orchestrator ट्यूटोरियल को देख सकते हैं, जहाँ मैंने Bedrock सेवाओं द्वारा प्रदान किए गए मॉडल्स का उपयोग करने के लिए वातावरण सेट करने के चरण विस्तार से बताए हैं। इसके अतिरिक्त, Nils Durner का ब्लॉग पोस्ट Bedrock सेवाएँ सेट करने के लिए चरण-दर-चरण स्क्रीनशॉट्स प्रदान करता है।

Amazon Bedrock Playground

Nova Micro और Pro की तुलना करते समय मैंने देखा कि दोनों मॉडलों के बीच शुद्धता का अंतर खास महसूस नहीं होता। टेक्स्ट जनरेशन में Micro, Pro से दोगुने से भी अधिक तेज़ है, फिर भी यह अधिकांश सामान्य उपयोग मामलों के लिए पर्याप्त उत्तर देता है। दूसरी ओर, Pro आमतौर पर थोड़ा अधिक विस्तृत और लंबी प्रतिक्रियाएँ देता है।

Amazon Bedrock API के जरिए Amazon Nova मॉडल्स तक कैसे पहुँचें

API के माध्यम से Nova मॉडल्स का उपयोग करने और उन्हें अपने कोड में इंटीग्रेट करने के लिए, पहले सुनिश्चित करें कि आपका AWS खाता, AWS CLI, और मॉडलों तक पहुँच सही तरह से सेटअप है (इसके लिए डॉक्यूमेंटेशन मार्गदर्शन देता है)।

इसके बाद, boto3 लाइब्रेरी इंस्टॉल करें, जो AWS का Python SDK है और आपको उनके मॉडल्स के साथ काम करने में सक्षम बनाता है।

pip install boto3संचालित द्वारा

आप नीचे दिए गए जैसे स्क्रिप्ट का उपयोग करके प्रोग्रामेटिक तरीके से मॉडल्स के साथ इंटरैक्ट कर सकते हैं:

import boto3
import json 

client = boto3.client(service_name="bedrock-runtime")

messages = [
    {"role": "user", "content": [{"text": "Write a short poem"}]},
]

model_response = client.converse(
    modelId="us.amazon.nova-lite-v1:0", 
    messages=messages
)

print("\\n[Full Response]")
print(json.dumps(model_response, indent=2))

print("\\n[Response Content Text]")
print(model_response["output"]["message"]["content"][0]["text"])संचालित द्वारा

Nova Micro और AWS Multi-Agent Orchestrator के साथ डेमो प्रोजेक्ट

अब हम Nova Micro की एजेंटिक क्षमताओं का परीक्षण करने के लिए एक डेमो प्रोजेक्ट लागू करते हैं। हम AWS Multi-Agent Orchestrator फ़्रेमवर्क का उपयोग करके दो एजेंट्स वाली एक सरल Python एप्लिकेशन सेटअप करेंगे: Python Developer Agent और ML Expert Agent। यदि आप ऑर्केस्ट्रेटर सेट करना चाहते हैं, तो इस AWS Multi-Agent Orchestrator गाइड का उपयोग कर सकते हैं।

हम Chainlit, एक ओपन-सोर्स Python पैकेज, का उपयोग एप्लिकेशन के लिए एक साधारण UI लागू करने में भी करेंगे। शुरुआत करने के लिए आवश्यक लाइब्रेरीज़ इंस्टॉल करें:

chainlit==1.2.0
multi_agent_orchestrator==0.0.18संचालित द्वारा

हम आवश्यक लाइब्रेरीज़ इम्पोर्ट करने से शुरू करते हैं:

import uuid
import chainlit as cl
from multi_agent_orchestrator.orchestrator import MultiAgentOrchestrator, OrchestratorConfig
from multi_agent_orchestrator.classifiers import BedrockClassifier, BedrockClassifierOptions
from multi_agent_orchestrator.agents import AgentResponse
from multi_agent_orchestrator.agents import BedrockLLMAgent, BedrockLLMAgentOptions, AgentCallbacks
from multi_agent_orchestrator.orchestrator import MultiAgentOrchestrator
from multi_agent_orchestrator.types import ConversationMessage
import asyncio
import chainlit as clसंचालित द्वारा

यह फ़्रेमवर्क किसी आने वाले यूज़र रिक्वेस्ट के लिए सर्वोत्तम एजेंट चुनने हेतु एक Classifier का उपयोग करता है। हम अपने Classifier के लिए “anthropic.claude-3-haiku-20240307-v1:0” मॉडल का उपयोग करते हैं।

class ChainlitAgentCallbacks(AgentCallbacks):
    def on_llm_new_token(self, token: str) -> None:
        asyncio.run(cl.user_session.get("current_msg").stream_token(token))

# Initialize the orchestrator
custom_bedrock_classifier = BedrockClassifier(BedrockClassifierOptions(
    model_id='anthropic.claude-3-haiku-20240307-v1:0',
    inference_config={
        'maxTokens': 500,
        'temperature': 0.7,
        'topP': 0.9
    }
))

orchestrator = MultiAgentOrchestrator(options=OrchestratorConfig(
        LOG_AGENT_CHAT=True,
        LOG_CLASSIFIER_CHAT=True,
        LOG_CLASSIFIER_RAW_OUTPUT=True,
        LOG_CLASSIFIER_OUTPUT=True,
        LOG_EXECUTION_TIMES=True,
        MAX_RETRIES=3,
        USE_DEFAULT_AGENT_IF_NONE_IDENTIFIED=False,
        MAX_MESSAGE_PAIRS_PER_AGENT=10,
    ),
    classifier=custom_bedrock_classifier
)संचालित द्वारा

अगला, हम Nova Micro द्वारा संचालित दो एजेंट परिभाषित करते हैं—एक Python डेवलपर विशेषज्ञ के रूप में और दूसरा मशीन लर्निंग विशेषज्ञ के रूप में।

def create_python_dev():
    return BedrockLLMAgent(BedrockLLMAgentOptions(
        name="Python Developer Agent",
        streaming=True,
        description="Experienced Python developer specialized in writing, debugging, and evaluating only Python code.",
        model_id="amazon.nova-micro-v1:0",
        callbacks=ChainlitAgentCallbacks()
    ))

def create_ml_expert():
    return BedrockLLMAgent(BedrockLLMAgentOptions(
        name="Machine Learning Expert",
        streaming=True,
        description="Expert in areas related to machine learning including deep learning, pytorch, tensorflow, scikit-learn, and large language models.",
        model_id="amazon.nova-micro-v1:0",
        callbacks=ChainlitAgentCallbacks()
    ))
    

# Add agents to the orchestrator
orchestrator.add_agent(create_python_dev())
orchestrator.add_agent(create_ml_expert())संचालित द्वारा

अंत में, हम Chainlit UI के लिए स्क्रिप्ट का मुख्य भाग सेट करते हैं ताकि यूज़र रिक्वेस्ट और एजेंट प्रतिक्रियाओं को संभाला जा सके।

@cl.on_chat_start
async def start():
    cl.user_session.set("user_id", str(uuid.uuid4()))
    cl.user_session.set("session_id", str(uuid.uuid4()))
    cl.user_session.set("chat_history", [])

@cl.on_message
async def main(message: cl.Message):
    user_id = cl.user_session.get("user_id")
    session_id = cl.user_session.get("session_id")
    msg = cl.Message(content="")
    await msg.send()  # Send the message immediately to start streaming
    cl.user_session.set("current_msg", msg)
    response:AgentResponse = await orchestrator.route_request(message.content, user_id, session_id, {})
    # Handle non-streaming responses
    if isinstance(response, AgentResponse) and response.streaming is False:
        # Handle regular response
        if isinstance(response.output, str):
            await msg.stream_token(response.output)
        elif isinstance(response.output, ConversationMessage):
                await msg.stream_token(response.output.content[0].get('text'))
    await msg.update()

if __name__ == "__main__":
    cl.run()संचालित द्वारा

परिणामस्वरूप Chainlit UI मिलता है, जो आपको व्यवहार में और अपनी पसंद के अनुसार Nova मॉडल्स के साथ चैट करने देता है।

Chainlit पर हमारा ऐप चल रहा है

इमेज और वीडियो जनरेशन मॉडल्स भी API के माध्यम से उपलब्ध हैं। उनका उपयोग कैसे करें, यह दिखाने वाली स्क्रिप्ट्स के लिए आप डॉक्यूमेंटेशन देख सकते हैं।

निष्कर्ष

Amazon Nova मॉडल्स, आधारभूत मॉडल इकोसिस्टम में एक उन्नति का प्रतिनिधित्व करते हैं, जो अत्याधुनिक शुद्धता, स्पीड, लागत-प्रभावशीलता, और मल्टीमोडल क्षमताओं का संयोजन करते हैं। जैसे-जैसे Amazon का LLM सूट नए प्रोडक्ट्स के साथ बढ़ रहा है, यह AWS पर किफायती और स्केलेबल एप्लिकेशन्स बनाने के लिए एक सशक्त विकल्प बनता जा रहा है।

चाहे आप एजेंटिक AI एप्लिकेशन्स विकसित कर रहे हों, कस्टमर सर्विस के लिए चैटबॉट्स बना रहे हों, या एक डेवलपर के रूप में अन्वेषण कर रहे हों—Nova मॉडल्स के साथ प्रयोग करना सार्थक अनुभव है। AWS, Bedrock, और Amazon के LLM टूल्स की समझ को गहरा करना भी लाभदायक है।

इस लेख में, हमने इन मॉडल्स के प्रमुख पहलुओं, उनके साथ प्रयोग करने के तरीकों, और Nova मॉडल्स का उपयोग करके एक बुनियादी एजेंटिक AI एप्लिकेशन कैसे बनाया जाए, इस पर चर्चा की।