Gemini API: Python এর সাথে ফাংশন কলিং

ai.google.dev-এ দেখুন

Google Colab-এ চালান

GitHub-এ উৎস দেখুন

আপনি ফাংশন বর্ণনা সহ মিথুন মডেল প্রদান করতে পারেন. মডেলটি আপনাকে একটি ফাংশন কল করতে এবং মডেলটিকে আপনার প্রশ্ন পরিচালনা করতে সহায়তা করার জন্য ফলাফলটি ফেরত পাঠাতে বলতে পারে।

সেটআপ

পাইথন SDK ইনস্টল করুন

Gemini API-এর জন্য Python SDK google-generativeai প্যাকেজে রয়েছে। পিপ ব্যবহার করে নির্ভরতা ইনস্টল করুন:

pip install -U -q google-generativeai

প্যাকেজ আমদানি করুন

প্রয়োজনীয় প্যাকেজ আমদানি করুন।

import pathlib
import textwrap
import time

import google.generativeai as genai


from IPython import display
from IPython.display import Markdown

def to_markdown(text):
  text = text.replace('•', '  *')
  return Markdown(textwrap.indent(text, '> ', predicate=lambda _: True))

আপনার API কী সেট আপ করুন

আপনি Gemini API ব্যবহার করার আগে, আপনাকে প্রথমে একটি API কী পেতে হবে। যদি আপনার কাছে ইতিমধ্যে একটি না থাকে তবে Google AI স্টুডিওতে এক ক্লিকে একটি কী তৈরি করুন৷

একটি API কী পান

Colab-এ, বাঁদিকের প্যানেলে "🔑"-এর নিচে সিক্রেট ম্যানেজারের কী যোগ করুন। এটিকে API_KEY নাম দিন।

একবার আপনার কাছে API কী হয়ে গেলে, এটি SDK-এ পাস করুন। আপনি এটি দুটি উপায়ে করতে পারেন:

• কীটি GOOGLE_API_KEY এনভায়রনমেন্ট ভেরিয়েবলে রাখুন (SDK স্বয়ংক্রিয়ভাবে সেখান থেকে তুলে নেবে)।
• genai.configure(api_key=...) এ কী পাস করুন

try:
    # Used to securely store your API key
    from google.colab import userdata

    # Or use `os.getenv('API_KEY')` to fetch an environment variable.
    GOOGLE_API_KEY=userdata.get('GOOGLE_API_KEY')
except ImportError:
    import os
    GOOGLE_API_KEY = os.environ['GOOGLE_API_KEY']

genai.configure(api_key=GOOGLE_API_KEY)

ফাংশন বেসিক

একটি genai.GenerativeModel তৈরি করার সময় আপনি tools আর্গুমেন্টে ফাংশনের একটি তালিকা পাস করতে পারেন।

def multiply(a:float, b:float):
    """returns a * b."""
    return a*b

model = genai.GenerativeModel(model_name='gemini-1.0-pro',
                              tools=[multiply])

model

genai.GenerativeModel(
    model_name='models/gemini-1.0-pro',
    generation_config={},
    safety_settings={},
    tools=<google.generativeai.types.content_types.FunctionLibrary object at 0x10e73fe90>,
)

ফাংশন কলিং ব্যবহার করার প্রস্তাবিত উপায় হল চ্যাট ইন্টারফেসের মাধ্যমে। প্রধান কারণ হল যে FunctionCalls চ্যাটের মাল্টি-টার্ন স্ট্রাকচারে সুন্দরভাবে ফিট করে।

chat = model.start_chat(enable_automatic_function_calling=True)

স্বয়ংক্রিয় ফাংশন কলিং সক্ষম সহ chat.send_message স্বয়ংক্রিয়ভাবে আপনার ফাংশনকে কল করে যদি মডেল এটি করতে বলে।

এটি সঠিক উত্তর সহ একটি পাঠ্য প্রতিক্রিয়া প্রদান করে বলে মনে হচ্ছে:

response = chat.send_message('I have 57 cats, each owns 44 mittens, how many mittens is that in total?')
response.text

'The total number of mittens is 2508.'

57*44

2508

আপনি যদি ChatSession.history দেখুন তাহলে আপনি ইভেন্টের ক্রম দেখতে পাবেন:

1. আপনি প্রশ্ন পাঠিয়েছেন।
2. মডেল একটি glm.FunctionCall সঙ্গে উত্তর.
3. genai.ChatSession স্থানীয়ভাবে ফাংশনটি সম্পাদন করেছে এবং মডেলটিকে একটি glm.FunctionResponse ফেরত পাঠিয়েছে।
4. মডেলটি তার উত্তরে ফাংশন আউটপুট ব্যবহার করেছে।

for content in chat.history:
    part = content.parts[0]
    print(content.role, "->", type(part).to_dict(part))
    print('-'*80)

user -> {'text': 'I have 57 cats, each owns 44 mittens, how many mittens is that in total?'}
--------------------------------------------------------------------------------
model -> {'function_call': {'name': 'multiply', 'args': {'a': 57.0, 'b': 44.0} } }
--------------------------------------------------------------------------------
user -> {'function_response': {'name': 'multiply', 'response': {'result': 2508.0} } }
--------------------------------------------------------------------------------
model -> {'text': 'The total number of mittens is 2508.'}
--------------------------------------------------------------------------------

সাধারণভাবে রাষ্ট্র চিত্র হল:

মডেলটি একটি পাঠ্য প্রতিক্রিয়া ফেরত দেওয়ার আগে একাধিক ফাংশন কলের সাথে প্রতিক্রিয়া জানাতে পারে এবং পাঠ্য প্রতিক্রিয়ার আগে ফাংশন কল আসে।

যদিও এটি সমস্ত স্বয়ংক্রিয়ভাবে পরিচালনা করা হয়েছিল, আপনার যদি আরও নিয়ন্ত্রণের প্রয়োজন হয়, আপনি করতে পারেন:

• ডিফল্ট enable_automatic_function_calling=False ত্যাগ করুন এবং glm.FunctionCall প্রতিক্রিয়াগুলি নিজেই প্রক্রিয়া করুন।
• অথবা GenerativeModel.generate_content ব্যবহার করুন, যেখানে আপনাকে চ্যাটের ইতিহাসও পরিচালনা করতে হবে।

[ঐচ্ছিক] নিম্ন স্তরের অ্যাক্সেস

পাইথন ফাংশন থেকে স্কিমার স্বয়ংক্রিয় নিষ্কাশন সব ক্ষেত্রে কাজ করে না। উদাহরণস্বরূপ: এটি এমন ক্ষেত্রে পরিচালনা করে না যেখানে আপনি একটি নেস্টেড অভিধান-অবজেক্টের ক্ষেত্রগুলি বর্ণনা করেন, তবে API এটি সমর্থন করে। এপিআই নিম্নলিখিত ধরনের যে কোনো বর্ণনা করতে সক্ষম:

AllowedType = (int | float | bool | str | list['AllowedType'] | dict[str, AllowedType]

google.ai.generativelanguage ক্লায়েন্ট লাইব্রেরি আপনাকে সম্পূর্ণ নিয়ন্ত্রণ প্রদান করে নিম্ন স্তরের প্রকারগুলিতে অ্যাক্সেস প্রদান করে৷

import google.ai.generativelanguage as glm

মডেলের _tools অ্যাট্রিবিউটের ভিতরে প্রথমে উঁকি দিয়ে দেখুন, আপনি দেখতে পাবেন যে এটি কীভাবে মডেলটিতে পাস করা ফাংশন(গুলি) বর্ণনা করে:

def multiply(a:float, b:float):
    """returns a * b."""
    return a*b

model = genai.GenerativeModel(model_name='gemini-1.0-pro',
                             tools=[multiply])

model._tools.to_proto()

[function_declarations {
   name: "multiply"
   description: "returns a * b."
   parameters {
     type_: OBJECT
     properties {
       key: "b"
       value {
         type_: NUMBER
       }
     }
     properties {
       key: "a"
       value {
         type_: NUMBER
       }
     }
     required: "a"
     required: "b"
   }
 }]

এটি glm.Tool অবজেক্টের তালিকা প্রদান করে যা API এ পাঠানো হবে। যদি মুদ্রিত বিন্যাসটি পরিচিত না হয় তবে এর কারণ হল এইগুলি হল গুগল প্রোটোবাফ ক্লাস। প্রতিটি glm.Tool (এই ক্ষেত্রে 1) এ glm.FunctionDeclarations এর একটি তালিকা রয়েছে, যা একটি ফাংশন এবং এর আর্গুমেন্ট বর্ণনা করে।

এখানে glm ক্লাস ব্যবহার করে লেখা একই গুন ফাংশনের জন্য একটি ঘোষণা রয়েছে।

মনে রাখবেন যে এই ক্লাসগুলি শুধুমাত্র API এর জন্য ফাংশন বর্ণনা করে, তারা এটির বাস্তবায়ন অন্তর্ভুক্ত করে না। সুতরাং এটি ব্যবহার করে স্বয়ংক্রিয় ফাংশন কলিংয়ের সাথে কাজ করে না, তবে ফাংশনগুলির সর্বদা একটি বাস্তবায়নের প্রয়োজন হয় না।

calculator = glm.Tool(
    function_declarations=[
      glm.FunctionDeclaration(
        name='multiply',
        description="Returns the product of two numbers.",
        parameters=glm.Schema(
            type=glm.Type.OBJECT,
            properties={
                'a':glm.Schema(type=glm.Type.NUMBER),
                'b':glm.Schema(type=glm.Type.NUMBER)
            },
            required=['a','b']
        )
      )
    ])

সমানভাবে, আপনি এটিকে একটি JSON- সামঞ্জস্যপূর্ণ বস্তু হিসাবে বর্ণনা করতে পারেন:

calculator = {'function_declarations': [
      {'name': 'multiply',
       'description': 'Returns the product of two numbers.',
       'parameters': {'type_': 'OBJECT',
       'properties': {
         'a': {'type_': 'NUMBER'},
         'b': {'type_': 'NUMBER'} },
       'required': ['a', 'b']} }]}

glm.Tool(calculator)

function_declarations {
  name: "multiply"
  description: "Returns the product of two numbers."
  parameters {
    type_: OBJECT
    properties {
      key: "b"
      value {
        type_: NUMBER
      }
    }
    properties {
      key: "a"
      value {
        type_: NUMBER
      }
    }
    required: "a"
    required: "b"
  }
}

যেভাবেই হোক, আপনি একটি glm.Tool বা টুলের তালিকার একটি উপস্থাপনা পাস করেন

model = genai.GenerativeModel('gemini-pro', tools=calculator)
chat = model.start_chat()

response = chat.send_message(
    f"What's 234551 X 325552 ?",
)

মডেলটি একটি glm.FunctionCall ফেরত দেওয়ার আগের মতো multiply

response.candidates

[index: 0
content {
  parts {
    function_call {
      name: "multiply"
      args {
        fields {
          key: "b"
          value {
            number_value: 325552
          }
        }
        fields {
          key: "a"
          value {
            number_value: 234551
          }
        }
      }
    }
  }
  role: "model"
}
finish_reason: STOP
]

ফাংশনটি নিজেই চালান:

fc = response.candidates[0].content.parts[0].function_call
assert fc.name == 'multiply'

result = fc.args['a'] * fc.args['b']
result

76358547152.0

কথোপকথন চালিয়ে যেতে মডেলে ফলাফল পাঠান:

response = chat.send_message(
    glm.Content(
    parts=[glm.Part(
        function_response = glm.FunctionResponse(
          name='multiply',
          response={'result': result}))]))

সারসংক্ষেপ

বেসিক ফাংশন কলিং SDK-তে সমর্থিত। মনে রাখবেন যে চ্যাট-মোড ব্যবহার করে পরিচালনা করা সহজ, কারণ সামনে এবং পিছনে প্রাকৃতিক কাঠামো। আপনি আসলে ফাংশনগুলিকে কল করার এবং মডেলটিতে ফলাফলগুলি পাঠানোর দায়িত্বে আছেন যাতে এটি একটি পাঠ্য-প্রতিক্রিয়া তৈরি করতে পারে।