AI ഏജന്റുകൾ ജനറേറ്റീവ് AI യിലെ ഒരു രസകരമായ പുരോഗതിയെ പ്രതിനിധീകരിക്കുന്നു, വലിയ ഭാഷാ മോഡലുകൾ (LLMs) സഹായികളിൽ നിന്ന് പ്രവൃത്തികൾ എടുക്കാൻ കഴിയുന്ന ഏജന്റുകളായി വികസിക്കുന്നതിന്. AI ഏജന്റ് ഫ്രെയിംവർക്ക് ഡെവലപ്പർമാർക്ക് LLMകൾക്ക് ഉപകരണങ്ങൾക്കും സ്റ്റേറ്റ് മാനേജ്മെന്റിനും പ്രവേശനം നൽകുന്ന ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കാൻ സഹായിക്കുന്നു. ഈ ഫ്രെയിംവർക്ക് കാണുന്ന ദൃശ്യതയും മെച്ചപ്പെടുത്തുന്നു, ഉപയോഗിക്കുന്നവർക്കും ഡെവലപ്പർമാർക്കും LLMകൾ പ്ലാൻ ചെയ്ത പ്രവൃത്തികൾ നിരീക്ഷിക്കാൻ കഴിയുന്നു, അതിലൂടെ അനുഭവ മാനേജ്മെന്റ് മെച്ചപ്പെടുത്തുന്നു.
പാഠം താഴെപ്പറയുന്ന മേഖലകൾ ഉൾക്കൊണ്ടിരിക്കും:
- AI ഏജന്റ് എന്തെന്ന് മനസിലാക്കൽ - AI ഏജന്റ് എന്താണ്?
- അഞ്ച് വ്യത്യസ്ത AI ഏജന്റ് ഫ്രെയിംവർക്കുകൾ പരിശോധിക്കൽ - അവയെ പ്രത്യേകമാകുന്നത് എന്ത്?
- വ്യത്യസ്ത ഉപയോഗങ്ങൾക്കായി AI ഏജന്റുകളെ പ്രയോജനം ചെയ്യുക - എപ്പോൾ AI ഏജന്റുകൾ ഉപയോഗിക്കണം?
ഈ പാഠം കഴിഞ്ഞാൽ നിങ്ങൾക്ക് കഴിയും:
- AI ഏജന്റുകൾ എന്താണെന്ന് വിശദീകരിക്കൽ, അവ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് വ്യക്തമാക്കുക.
- ചില ജനപ്രിയ AI ഏജന്റ് ഫ്രെയിംവർക്കുകൾ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ മനസിലാക്കുക.
- AI ഏജന്റുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് മനസിലാക്കി അവ ഉപയോഗിച്ച് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുക.
ജനറേറ്റീവ് AI ലോകത്ത് AI ഏജന്റുകൾ വളരെ രസകരമായ ഒരു മേഖലയാണ്. ഈ ഉത്സാഹത്തോടൊപ്പം ചിലപ്പോൾ പദങ്ങൾക്കും അവരുടെ പ്രയോഗത്തിനും ആശയക്കുഴപ്പവും ഉണ്ടാകാറുണ്ട്. സകല AI ഏജന്റ് ചുറ്റുപാടുകളെയും ഉൾക്കൊള്ളുന്നതുമായി കാര്യങ്ങൾ എളുപ്പമാക്കാൻ, നാം ഈ നിർവചനത്തെ ഉപയോഗിക്കാനായി:
AI ഏജന്റുകൾ വലിയ ഭാഷാ മോഡലുകൾ (LLMs) എടുക്കാൻ കഴിയുന്ന ടാസ്കുകൾക്കും അവയ്ക്ക് ഒരു സ്റ്റേറ്റ് ഉം ഉപകരണങ്ങൾ ഉം പ്രദാനം ചെയ്യുന്നതാണ്.
ഈ പദങ്ങള് നിർവചിക്കാം:
വലിയ ഭാഷാ മോഡലുകൾ - ഈ കോഴ്സ് മുഴുവൻ പരാമർശിച്ച მოდലുകൾ ആണ്, ഉദാഹരണത്തിന് GPT-3.5, GPT-4, Llama-2 തുടങ്ങിയവ.
സ്റ്റേറ്റ് - ഇത് LLM പ്രവർത്തിക്കുന്ന സാന്ദർഭ്യത്തെ സൂചിപ്പിക്കുന്നു. LLM സമീപകാല പ്രവൃത്തികളും നിലവിലെ സാന്ദർഭ്യവും ഉപയോഗിച്ച് തുടര്ന്നുള്ള പ്രവൃത്തികൾക്കായുള്ള തീരുമാനങ്ങൾ കൈക്കള്ളുന്നു. AI ഏജന്റ് ഫ്രെയിംവർക്കുകൾ വികസിപ്പകർക്ക് ഈ സാന്ദർഭ്യം പരിപാലിക്കാൻ സഹായിക്കുന്നു.
ഉപകരണങ്ങൾ - ഉപയോക്താവ് അഭ്യർത്ഥിച്ചും LLM ആസൂത്രണം ചെയ്ത ടാസ്കുകൾ പൂർത്തിയാക്കാൻ LLM ഉദ്ദേശിക്കുന്ന ഉപകരണങ്ങൾ ലഭിക്കണം. ഉദാഹരണങ്ങൾക്ക് ഡാറ്റാബേസ്, API, ബാഹ്യ ആപ്ലിക്കേഷൻ അല്ലെങ്കിൽ മറ്റൊരു LLM!
ഈ നിർവചനങ്ങൾ നിങ്ങളുടെ അടിസ്ഥാന ബോധം മെച്ചപ്പെടുത്താനാകും, പിന്നീട് അവ എങ്ങനെ നടപ്പിലാക്കുന്നുവെന്ന് നോക്കാം. ചില വ്യത്യസ്ത AI ഏജന്റ് ഫ്രെയിംവർക്കുകൾ പരിശോധിക്കാം:
LangChain Agents മുൻപിൽ നൽകിയ നിർവചനങ്ങളുടെ ഒരു നടപ്പാക്കലാണ്.
സ്റ്റേറ്റ് മാനേജ് ചെയ്യാൻ, ഇത് AgentExecutor എന്ന പണിത ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. ഇത് നിർവചിച്ച agent ഉം ലഭ്യമായ tools ഉം സ്വീകരിക്കുന്നു.
Agent Executor കൂടാതെ ചാറ്റ് ചരിത്രം സൂക്ഷിക്കുകയും സംഭാഷണത്തിന്റെ സഹായ പിന്നണി നൽകുകയും ചെയ്യുന്നു.
LangChain നിങ്ങളുടെ ആപ്ലിക്കേഷനിലേക്ക് ഇറക്കിക്കടുക്കാവുന്ന ഉപകരണങ്ങളുടെ പട്ടിക ഉണ്ട്, LLM അവയ്ക്ക് പ്രവേശനം നേടും. ഇത് കമ്മ്യൂണിറ്റിയും LangChain സംഘവും രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു.
നിങ്ങൾക്ക് ഈ ഉപകരണങ്ങൾ നിർവചിച്ച് Agent Executorന് കൈമാറാം.
AI ഏജന്റുകൾ സംസാരിച്ചാൽ ദൃശ്യത മറ്റൊന്ന് വളരെ പ്രധാനമാണ്. അപ്ലിക്കേഷൻ ഡെവലപ്പർമാർക്ക് LLM ഏതു ഉപകരണം ഉപയോഗിക്കുന്നു എന്നും അത് എന്തിനാണ് എന്ന് സമവായം വേണം. അതിനായി LangChain സംഘത്തിൽ LangSmith വികസിപ്പിച്ചു.
ഏറ്റവും അടുത്ത AI ഏജന്റ് ഫ്രെയിംവർക്ക് AutoGen ആണ്. AutoGenയുടെ പ്രധാന ശ്രദ്ധ സംഭാഷണങ്ങളിലാണ്. ഏജന്റുകൾ സംഭാഷണ സമർത്ഥരും കസ്റ്റമൈസ് ചെയ്യാവുന്നതുമായവയും ആകുന്നു.
സംഭാഷണ സമർത്ഥം - LLMകൾ ഒരു ടാസ്ക് പൂർത്തിയാക്കാൻ മറ്റൊരു LLM-നോട് സംഭാഷണം തുടങ്ങി തുടരാൻ കഴിയും. ഇത് AssistantAgents സൃഷ്ടിച്ച്, അവയ്ക്ക് ഒരു പ്രത്യേക സിസ്റ്റം സന്ദേശം നൽകിയാണ് ചെയ്യുന്നത്.
autogen.AssistantAgent( name="Coder", llm_config=llm_config, ) pm = autogen.AssistantAgent( name="Product_manager", system_message="Creative in software product ideas.", llm_config=llm_config, )കസ്റ്റമൈസ് ചെയ്യാവുന്നത് - ഏജന്റുകൾ LLMകളായി മാത്രമല്ല, ഉപയോക്താവോ ഉപകരണമോ ആകാം. ഡെവലപ്പറായി, നിങ്ങൾ ഒരു UserProxyAgent നിർവചിക്കാം, ഇത് ഉപയോക്താവുമായി ആശയവിനിമയം നടത്തിയാണ് ടാസ്ക് പൂർത്തീകരണത്തിൽ പിന്തുണ നൽകുന്നത്. ഈ പ്രതികരണം ടാസ്ക് തുടർന്നും നടപ്പാക്കുകയോ അവസാനിപ്പിക്കുകയോ ചെയ്യാം.
user_proxy = UserProxyAgent(name="user_proxy")സ്റ്റേറ്റ് മാറാനും നിയന്ത്രിക്കാനായി, ഒരു അസിസ്റ്റന്റ് ഏജന്റ് പൈത്തൺ കോഡ്സ് സൃഷ്ടിക്കുന്നു ടാസ്ക് പൂർത്തിയാക്കാൻ.
ഇവിടെയാണ് പ്രക്രിയയുടെ ഒരു ഉദാഹരണം:
system_message="For weather related tasks, only use the functions you have been provided with. Reply TERMINATE when the task is done."ഈ സിസ്റ്റം സന്ദേശം ഈ പ്രത്യേക LLM-ന് ഏത് ഫംഗ്ഷനുകൾ ടാസ്ക്കിന് ബന്ധപ്പെട്ടവയെന്ന് നിർദ്ദേശിക്കുന്നു. ഓർക്കുക, AutoGen-ൽ നിങ്ങൾക്ക് പല വ്യത്യസ്ത സിസ്റ്റം സന്ദേശങ്ങളുമായ AssistantAgents ഉണ്ടാകാം.
user_proxy.initiate_chat( chatbot, message="I am planning a trip to NYC next week, can you help me pick out what to wear? ", )ഉപയോക്താവ്_proxy (മനുഷ്യൻ) അയക്കുന്ന ഈ സന്ദേശമാണ് ഏജന്റിന്റെ പണി ആരംഭിക്കാൻ പ്രേരിപ്പിക്കുന്നത്, ഏജന്റ് ഏത് ഫംഗ്ഷനുകൾ നിർവഹിക്കണമെന്നും അന്വേഷിക്കുന്നു.
chatbot (to user_proxy):
***** Suggested tool Call: get_weather ***** Arguments: {"location":"New York City, NY","time_periond:"7","temperature_unit":"Celsius"} ******************************************************** --------------------------------------------------------------------------------
>>>>>>>> EXECUTING FUNCTION get_weather... user_proxy (to chatbot): ***** Response from calling function "get_weather" ***** 112.22727272727272 EUR ****************************************************************
ആദ്യം ചാറ്റ് പ്രോസസ്സായതിനു ശേഷം, ഏജന്റ് നിർദ്ദേശിച്ച ഉപകരണം വിളിക്കും. ഇവിടെ get_weather എന്ന ഫംഗ്ഷനാണ് ഇത്. നിങ്ങളുടെ ക്രമീകരണമനുസരിച്ച്, ഈ ഫംഗ്ഷൻ സ്വയംനടത്തുകയും ഏജന്റുമായി വായിക്കുകയും ചെയ്യാം അല്ലെങ്കിൽ ഉപയോക്താവിന്റെ ഇൻപുട്ടിനെ അടിസ്ഥാനമാക്കി മുൻപോട്ടു നടക്കും.
ആരംഭിക്കാൻ കുറച്ച് കൂടി പഠിക്കാന് AutoGen കോഡ് സാമ്പിളുകൾ കാണുക.
Microsoft Agent Framework മൈക്രോസോഫ്റ്റിന്റെ എഐ ഏജന്റുകളും മൾട്ടി-ഏജന്റ് സിസ്റ്റങ്ങളുമുണ്ടാക്കുന്ന ഓപ്പൺ സോഴ്സ് SDK ആണ്, ഇരുഭാഷകളിലും Pythonനും .NETനും. വിദഗ്ധ സാങ്കേതികതകളും ഓർക്കെസ്ട്രേഷനും ഒരുമിച്ചിട്ടുള്ള, മുൻ മൈക്രോസോഫ്റ്റ് പ്രോജക്റ്റുകളുടെ ശക്തി ഈ ഫ്രെയിംവർക്കിൽ ഉണ്ട്. AutoGen-ന് പകരം പുതിയ ഏജന്റ് പ്രോജക്റ്റുകൾക്ക് ഇതാണ് ശുപാർശ.
ഫ്രെയിംവർക്കുകൾ ഒരു ഏകദേശം ചാറ്റ് ഏജന്റ് മുതൽ സങ്കീർണ്ണമായ മൾട്ടി-ഏജന്റ് വർക്ക്ഫ്ലോകൾ വരെ സ്കെയിൽ ചെയ്യാൻ കഴിയും, മൈക്രോസോഫ്റ്റ് ഫൗണ്ട്രി, അസ്യൂർ OpenAI, ഒപ്പൺAI എന്നിവയുമായി നേരിട്ട് ഇന്റഗ്രേറ്റ് ചെയ്യുന്നു. ഓപൺടെലിമെട്രി ഒരുക്കത്തോടെയും ഏജന്റുകളുടെ പ്രവർത്തനം കൃത്യമായി തിരിച്ചറിയാൻ കഴിയും.
സ്റ്റേറ്റ് - ഫ്രെയിംവർക്ക് ത്രെഡ്ളയിൽ സംഭാഷണ സമ്പ്രദായം മാനേജ് ചെയ്യുന്നു. ഏജന്റ് മെസ്സേജ് ചരിത്രം (ഉപയോക്തൃ അഭ്യർത്ഥനകൾ, ഉപകരണ വിളികൾ, അവരുടെ ഫലങ്ങൾ) നിരീക്ഷിച്ച് ഓരോ ചഭിനും മുമ്പത്തെത് തുടരും. ത്രെഡുകൾ നിലനിർത്താവുന്നതും ബ്രേക്ക് ചെയ്ത് പിന്നീട് തുടരുമെന്നുമാണ് കഴിവ്.
ഉപകരണങ്ങൾ - plain Python ഫംഗ്ഷനുകൾ ഏജന്റിന് നൽകുക. ടൈപ്പ് അനോടേറ്റഡ് പാരാമീറ്ററുകൾ സ്കീമയാക്കി മാറുന്നു, മോഡലിന് എപ്പൊഴും എങ്ങനെ വിളിക്കാമെന്നറിയാം (ഫംഗ്ഷൻ കോൾ). MCP സർവർകളും കോഡ് ഇന്റർപ്രിറ്ററുകളുടെ ഹോസ്റ്റുചെയ്യുന്നത് പിന്തുണയ്ക്കുന്നു.
ഒരു ഒറ്റ ഏജന്റുടെ കസ്റ്റം ടൂളിന്റെ ഉദാഹരണം ഇവിടെ:
import asyncio
from typing import Annotated
from pydantic import Field
from agent_framework import Agent
from agent_framework.openai import OpenAIChatClient
def get_weather(
location: Annotated[str, Field(description="The location to get the weather for.")],
) -> str:
"""Get the weather for a given location."""
return f"The weather in {location} is sunny with a high of 22°C."
async def main():
agent = Agent(
client=OpenAIChatClient(),
instructions="You are a helpful assistant that can answer weather questions.",
tools=[get_weather],
)
response = await agent.run("What's the weather in Amsterdam?")
print(response)
asyncio.run(main())Microsoft Foundry-ലിൽ അസ്യൂർ OpenAI-യുമായി കണക്റ്റ് ചെയ്യാൻ, ക്ലയന്റിന് നിങ്ങളുടെ എപ്പോന്റും ക്രെഡൻഷ്യലുകളും പാസ്സ് ചെയ്യുക:
from azure.identity.aio import AzureCliCredential
from agent_framework.openai import OpenAIChatClient
client = OpenAIChatClient(
model="my-gpt-4o-deployment",
azure_endpoint="https://my-resource.openai.azure.com",
credential=AzureCliCredential(),
)ഫ്രെയിംവർക്ക് പ്രത്യേകത പല ഏജന്റുകളെ ഒരുമിച്ച് ഓർകെസ്ട്രേറ്റ് ചെയ്യുന്നതാണു. ഉദാഹരണത്തിന്, ഏജൻറുകൾ പിറകിൽ പിറകിനെ തുടർന്നും രാഷ്ട്രീയാവാസ്ഥ അയയ്ക്കുകയും അല്ലെങ്കിൽ ഒരേ സമയം പല ഏജന്റുകളിലേക്ക് തിരിച്ചുവിട്ടും അവരുടെ ഫലങ്ങൾ കൂട്ടിച്ചേർക്കുകയും ചെയ്യാം:
from agent_framework.orchestrations import SequentialBuilder, ConcurrentBuilder
# ഏജൻറുകളെ ഒരു ക്രമത്തിൽ പ്രവർത്തിപ്പിക്കുക, സംഭാഷണപരമായ പശ്ചാത്തലം ശൃംഖലയിൽ പങ്കുവെച്ച്
sequential = SequentialBuilder(participants=[researcher, writer, editor]).build()
# ഏജൻറുകളെ സമാന്തരമായി പ്രവർത്തിപ്പിക്കുക, പിന്നിട്ട് അവരുടെ മറുപടികൾ ഒന്നിച്ച് ചേർക്കുക
concurrent = ConcurrentBuilder(participants=[analyst_a, analyst_b, analyst_c]).build()ഫ്രെയിംവർക്ക് ഇൻസ്റ്റാൾ ചെയ്ത് ആരംഭിക്കാൻ:
pip install agent-framework-core
# ഐച്ഛിക സംയോജനങ്ങൾ
pip install agent-framework-openai # OpenAI ഉം Azure OpenAI ഉം
pip install agent-framework-foundry # Microsoft FoundryMicrosoft Agent Framework റെപ്പോസിറ്ററിയും അധികൃത ഡോക്യുമെന്റേഷനും പരിശോധിക്കാം.
അടുത്ത ഏജന്റ് ഫ്രെയിംവർക്ക് Taskweaver ആണ്. ഇത് "കോഡ്-ഫസ്റ്റ്" ഏജന്റ് എന്നറിയപ്പെടുന്നു കാരണം ഇത് പൂർണ്ണമായും strings ഉപയോഗിക്കുന്നതിന് പകരം Python-ൽ ഡാറ്റാഫ്രെയിമുകളുമായി പ്രവർത്തിക്കാം. ഡാറ്റാ വിശകലനം, ജനറേഷൻ ടാസ്കുകൾക്ക് ഇത് വളരെ പ്രയോജകമാണ്. ഗ്രാഫുകൾ, ചാർട്ടുകൾ സൃഷ്ടിക്കുക, റാൻഡം നമ്പറുകൾ കാല്പനികമായി ഉണ്ടാക്കുക തുടങ്ങിയവയ്ക്ക് ഉപയോഗിക്കുന്നു.
സംഭാഷണത്തിന്റെ സ്റ്റേറ്റ് മാനേജ് ചെയ്യാൻ TaskWeaver Planner എന്ന ആശയം ഉപയോഗിക്കുന്നു. Planner ഉപയോക്താക്കളുടെ അഭ്യർത്ഥന സ്വീകരിച്ച്, പൂർത്തിയാക്കേണ്ട ടാസ്കുകൾ മാപ്പ് ചെയ്യുന്ന LLM ആണ്.
ടാസ്കുകൾ പൂർത്തിയാക്കാൻ Planner-ന് Plugins എന്ന ഉപകരണങ്ങളുടെ ശേഖരം ലഭ്യം. ഇവ Python ക്ലാസ്സുകളും പൊതുവായ കോഡ് ഇന്റർപ്രിറ്ററും ആകാം. ഈ പ്ലഗിനുകൾ LLM ഏറ്റവും അനുയോജ്യമായ പ്ലഗിൻ തിരയാൻ എമ്പഡിംഗുകളായി സൂക്ഷിക്കുന്നു.
അനോമലി ഡിറ്റക്ഷൻ കൈകാര്യം ചെയ്യാൻ പ്ലഗിന്റെ ഒരു ഉദാഹരണം:
class AnomalyDetectionPlugin(Plugin): def __call__(self, df: pd.DataFrame, time_col_name: str, value_col_name: str):കോഡ് നടപ്പിലാക്കുന്നതിന് മുമ്പ് സെർട്ടിഫൈ ചെയ്യപ്പെടുന്നു. Taskweaver-ൽ സാന്ദർഭ്യം മാനേജ് ചെയ്യാനുള്ള മറ്റൊരു സവിശേഷത experience ആണ്. ഇത് സംഭാഷണത്തിന്റെ സാന്ദർഭ്യത്തെ ദീർഘകാലം YAML ഫയലായി സൂക്ഷിക്കാൻ അനുവദിക്കുന്നു. എത്ര ആവശ്യങ്ങൾ മുൻകൂട്ടി കണ്ടതിന് LLM നേരെയുള്ള കഴിവുകൾ മെച്ചപ്പെടാനും ഇത് സഹായിക്കുന്നു.
അവസാന ഏജന്റ് ഫ്രെയിംവർക്ക് JARVIS ആണ്. JARVIS-നെ പ്രത്യേകമാക്കുന്നത് LLM സംവാദത്തിന്റെ സ്റ്റേറ്റ് മാനേജ് ചെയ്യുന്നു, tools എന്നത് മറ്റ് AI മോഡലുകളാണ്. ഓരോ AI മോഡലുകളും പ്രത്യേക ടാസ്കുകൾ പൂർത്തീകരിക്കുന്ന വിദഗ്ധ മോഡലുകളും ആകുന്നു, ഉദാഹരണത്തിന് ഒബ്ജക്ട് ഡിറ്റക്ഷൻ, ട്രാൻസ്ക്രിപ്ഷൻ, ചിത്ര വിവരണം എന്നിവ.
പൊതുവായ മോഡലായ LLM ഉപയോക്താവിൽ നിന്നും അഭ്യർത്ഥന സ്വീകരിച്ച് നിർദ്ദിഷ്ട ടാസ്കും പൂർത്തിയാക്കാനുള്ള ആവശ്യമുള്ള ഡാറ്റയും തിരിച്ചറിയുന്നു.
[{"task": "object-detection", "id": 0, "dep": [-1], "args": {"image": "e1.jpg" }}]LLM തുടർന്ന് ഈ അഭ്യർത്ഥന പ്രത്യേക AI മോഡൽ വ്യാഖ്യാനിക്കാൻ കഴിയുന്ന രൂപത്തിൽ, ഉദാഹരണത്തിന് JSON, രൂപപ്പെടുത്തുന്നു. AI മോഡൽ ടാസ്കിന്റെ അടിസ്ഥാനത്തിൽ പ്രവചനവുമായി തിരിച്ചുകിട്ടുമ്പോൾ LLM പ്രതികരണം സ്വീകരിക്കുന്നു.
പല മോഡലുകളും ടാസ്ക് പൂർത്തിയാക്കേണ്ടത് ആവശ്യമുണ്ടെങ്കിൽ, അവയുടെ പ്രതികരണവും LLM വ്യാഖ്യാനിച്ച് ഒത്തു ചേർത്ത് ഉപയോക്താവിന് മറുപടി സൃഷ്ടിക്കും.
താഴെ ഉദാഹരണം കാണിക്കുന്നു, ഒരുപയോക്താവ് ഒരു ചിത്രത്തിലെ വസ്തുക്കളുടെ വിവരണം, എണ്ണം അഭ്യർത്ഥിക്കുമ്പോൾ ഇത് എങ്ങനെ പ്രവർത്തിക്കും:
AI ഏജന്റുകളുടെ പഠനം തുടരാൻ Microsoft Agent Framework ഉപയോഗിച്ച് നിർമ്മിക്കുക:
- ഒരു വിദ്യാഭ്യാസ സ്റ്റാർട്ട്അപ്പിന്റെ विभिन्न വകുപ്പ് സംഘടനകളെ ഉൾക്കൊള്ളുന്ന ഒരു ബിസിനസ് മീറ്റിംഗ് സിമുലേറ്റ് ചെയ്യുന്ന ആപ്ലിക്കേഷൻ.
- LLMകൾ വ്യത്യസ്ത പേര്സണാസുകളും പ്രധാനം ചെയ്യുന്ന കാര്യങ്ങളും മനസ്സിലാക്കാൻ സഹായിക്കുന്ന സിസ്റ്റം സന്ദേശങ്ങൾ സൃഷ്ടിക്കുക, ഉപയോക്താവ് പുതിയ ഉൽപ്പന്ന ആശയം അവതരിപ്പിക്കുന്നു.
- ഓരോ വകുപ്പിനും അവരവരുടെ പിന്തുടർന്നുള്ള ചോദ്യങ്ങൾ നിർമിക്കുന്നതായി LLM നിർമിക്കണം, ഇതിലൂടെ പിച്ച് മെച്ചപ്പെടുത്തുകയും ഉൽപ്പന്ന ആശയം ഊർജ്ജസ്വലമാക്കുകയും ചെയ്യുന്നു.
ഈ പാഠം പൂർത്തിയാക്കിയ ശേഷം, നമ്മുടെ ജനറേറ്റീവ് AI പഠന ശേഖരം കാണാമെന്തെന്ന് ജെനറേറ്റീവ് AI ന്റെ അറിവ് മെച്ചപ്പെടുത്താൻ തുടരും!
അറിയിപ്പ്: ഈ രേഖ AI പരിഭാഷാ സേവനം Co-op Translator ഉപയോഗിച്ച് പരിഭാഷപ്പെടുത്തിയതാണ്. ഞങ്ങൾ കൃത്യതയ്ക്കായി ശ്രമിക്കുന്നുവെങ്കിലും, ഓട്ടോമേറ്റഡ് പരിഭാഷകളിൽ പിഴവുകൾ അല്ലെങ്കിൽ തെറ്റായ വിവരങ്ങൾ ഉണ്ടാകാൻ സാധ്യതയുണ്ട്. അതിന്റെ സ്വാഭാവിക ഭാഷയിലുള്ള അസൽ രേഖയാണ് പ്രാമാണികമായ ഉറവിടമായി പരിഗണിക്കേണ്ടത്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ പരിഭാഷ ശുപാർശ ചെയ്യുന്നു. ഈ പരിഭാഷ ഉപയോഗിച്ച് ഉണ്ടാകുന്ന തെറ്റിദ്ധാരണകൾ അല്ലെങ്കിൽ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കായി ഞങ്ങൾ ഉത്തരവാദികളല്ല.