വെബ് പ്ലേഗ്രൗണ്ടുകൾ ഡെമോകൾക്ക് മികച്ചതാണ്. നിങ്ങൾ ഒരു ടെക്സ്റ്റ് ബ്ലോക്ക് പേസ്റ്റ് ചെയ്യുന്നു, മോഡൽ ഒരു വൃത്തിയുള്ള സമ്മറി തയ്യാറാക്കുന്നത് നോക്കുന്നു, തുടർന്ന് ടാബ് അടയ്ക്കുന്നു. എന്നാൽ ഇത് എൻജിനീയറിംഗ് അല്ല. പ്രൊഡക്ഷൻ വർക്കുകൾ എന്നാൽ APIs, error handling, നിങ്ങൾ ഉറങ്ങിക്കിടക്കുമ്പോഴും പ്രവർത്തിച്ചുകൊണ്ടിരിക്കുന്ന കോഡ് എന്നിവയാണ്. മീറ്റിംഗ് ട്രാൻസ്ക്രിപ്റ്റുകൾ, സപ്പോർട്ട് ടിക്കറ്റുകൾ അല്ലെങ്കിൽ റിസർച്ച് പേപ്പറുകൾ എന്നിവ ഒരു നിശ്ചിത സമയക്രമത്തിൽ കൈകാര്യം ചെയ്യണമെന്നുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഒരു പൈപ്പ്‌ലൈൻ ആവശ്യമാണ്.

ഈ ഗൈഡ് കൃത്യമായി അത് എങ്ങനെ നിർമ്മിക്കാം എന്ന് വിവരിക്കുന്നു: Python, AWS SDK for Python (boto3), Amazon Bedrock എന്നിവ ഉപയോഗിച്ച് നിർമ്മിച്ച ലഘുവായതും ഓട്ടോമേറ്റഡ് ആയതുമായ ഒരു ഡോക്യുമെന്റ് സമ്മറൈസേഷൻ സ്ക്രിപ്റ്റ്. ടെക്സ്റ്റ് സമ്മറൈസേഷൻ ജോലികൾക്കായി വേഗതയും ചിലവും തമ്മിലുള്ള മികച്ച സന്തുലിതാവസ്ഥ നൽകുന്ന Anthropic-ന്റെ Claude 3 Haiku മോഡലാണ് നമ്മൾ ഉപയോഗിക്കുന്നത്.

എന്തുകൊണ്ട് Bedrock ഉം Claude 3 Haiku ഉം?

ഒരു കൂട്ടം AWS APIs വഴി ഫൗണ്ടേഷൻ മോഡലുകൾ ലഭ്യമാക്കുന്ന ഒരു മാനേജ്ഡ് സർവീസാണ് Amazon Bedrock. പുറത്തുള്ള എൻഡ്‌പോയിന്റുകൾ കൂട്ടിച്ചേർക്കുന്നതിനും വ്യത്യസ്തമായ ബില്ലിംഗ്, സെക്യൂരിറ്റി മോഡലുകൾ കൈകാര്യം ചെയ്യുന്നതിനും പകരം, സ്റ്റാൻഡേർഡ് IAM കൺട്രോളുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു AWS എൻഡ്‌പോയിന്റ് വിളിക്കാം. നിങ്ങളുടെ ഡാറ്റ നിങ്ങളുടെ AWS എൻവയോൺമെന്റിനുള്ളിൽ തന്നെ സുരക്ഷിതമായിരിക്കും.

Claude 3 Haiku എന്നത് Anthropic-ന്റെ Claude 3 ഫാമിലിയിലെ ഏറ്റവും ലളിതമായ മോഡലാണ്. ഇത് വേഗതയ്ക്കും കുറഞ്ഞ ചിലവിനും വേണ്ടി നിർമ്മിച്ചതാണ്, അതിനാൽ ലളിതമായ വായന ആവശ്യങ്ങൾക്കായി വലിയ മോഡലുകളുടെ ഉയർന്ന ചിലവ് വഹിക്കാതെ തന്നെ, കൃത്യമായ ഔട്ട്‌പുട്ട് ആവശ്യമുള്ള ഉയർന്ന അളവിലുള്ള സമ്മറൈസേഷൻ ജോലികൾക്ക് ഇത് അനുയോജ്യമാണ്.

നിങ്ങൾക്ക് ആവശ്യമായവ

ഏതെങ്കിലും കോഡ് എഴുതുന്നതിന് മുമ്പ്, താഴെ പറയുന്നവ തയ്യാറാണെന്ന് ഉറപ്പുവരുത്തുക:

  • ഒരു ആക്റ്റീവ് AWS അക്കൗണ്ട്.
  • ലോക്കലായി ഇൻസ്റ്റാൾ ചെയ്ത Python 3.9 അല്ലെങ്കിൽ അതിനു മുകളിലുള്ള പതിപ്പ്.
  • Bedrock മോഡലുകൾ ഉപയോഗിക്കാൻ അനുമതിയുള്ള ക്രെഡൻഷ്യലുകൾ ഉപയോഗിച്ച് കോൺഫിഗർ ചെയ്ത AWS CLI. നിങ്ങൾ ഇതുവരെ aws configure ചെയ്തിട്ടില്ലെങ്കിൽ, ഇപ്പോൾ തന്നെ അത് ചെയ്യുക. പിന്നീട് പെർമിഷൻ എററുകൾ വന്നാൽ, നിങ്ങളുടെ IAM യൂസർക്കോ റോളിനോ അനുയോജ്യമായ Bedrock invocation പെർമിഷനുകൾ നൽകേണ്ടി വന്നേക്കാം.
  • AWS Bedrock കൺസോളിൽ Anthropic Claude 3 Haiku-ന് വേണ്ടി പ്രത്യേകം മോഡൽ ആക്സസ് എനേബിൾ ചെയ്തിരിക്കണം. ഓരോ മോഡൽ പ്രൊവൈഡറെയും ഉപയോഗിക്കുന്നതിന് മുമ്പ് AWS-ൽ പ്രത്യേകം അനുമതി വാങ്ങേണ്ടതുണ്ട്.

സ്റ്റെപ്പ് 1: മോഡൽ ആക്സസ് എനേബിൾ ചെയ്യുക

Bedrock നേരിട്ട് മോഡലുകൾ ഉപയോഗിക്കാൻ അനുവദിക്കില്ല. ആദ്യം നിങ്ങൾ കൺസോളിൽ അത് എനേബിൾ ചെയ്യണം.

  1. AWS Management Console-ലേക്ക് ലോഗിൻ ചെയ്യുക.
  2. സെർച്ച് ബാർ ഉപയോഗിച്ച് Amazon Bedrock കണ്ടെത്തുക.
  3. ഇടത് വശത്തുള്ള നാവിഗേഷൻ പാനലിൽ, Model access തിരഞ്ഞെടുക്കുക.
  4. Modify model access ക്ലിക്ക് ചെയ്യുക.
  5. Anthropic (Claude 3 Haiku) എന്ന ബോക്സിൽ ടിക്ക് ചെയ്യുക, തുടർന്ന് നിങ്ങളുടെ റിക്വസ്റ്റ് സബ്മിറ്റ് ചെയ്യുക.

സ്റ്റാറ്റസ് "Access granted" എന്നാവിയാൽ, നിങ്ങൾക്ക് കോഡ് വഴി മോഡൽ ഉപയോഗിക്കാം.

സ്റ്റെപ്പ് 2: നിങ്ങളുടെ എൻവയോൺമെന്റ് സജ്ജമാക്കുക

ഒരു ക്ലീൻ Python എൻവയോൺമെന്റ് ഉപയോഗിക്കുന്നത് ഡിപെൻഡൻസികൾ വേർതിരിച്ചു നിർത്താനും എളുപ്പത്തിൽ പുനരാവിഷ്കരിക്കാനും സഹായിക്കും. നിങ്ങളുടെ ടെർമിനൽ തുറന്ന് ഈ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുക:

mkdir bedrock-summarizer && cd bedrock-summarizer
python3 -m venv venv
source venv/bin/activate
pip install boto3

വിൻഡോസ് ഉപയോക്താക്കൾ ആക്ടിവേഷൻ കമാൻഡിന് പകരം venv\Scripts\activate ഉപയോഗിക്കണം. pip install boto3 പൂർത്തിയായ ശേഷം, AWS APIs ഉപയോഗിക്കാൻ ആവശ്യമായതെല്ലാം നിങ്ങളുടെ പക്കലുണ്ട്.

സ്റ്റെപ്പ് 3: സ്ക്രിപ്റ്റ് എഴുതുക

summarize.py എന്ന പേരിൽ ഒരു ഫയൽ നിർമ്മിക്കുക. ഒരു ഡോക്യുമെന്റ് ഡിസ്കിൽ നിന്ന് വായിച്ച്, അത് Bedrock Converse API-ലേക്ക് നൽകി, ഒരു സംക്ഷിപ്ത സമ്മറി പ്രിന്റ് ചെയ്യുക എന്നതാണ് ഇതിന്റെ ലക്ഷ്യം.

താഴെ നൽകിയിരിക്കുന്നത് പൂർണ്ണമായ ഒരു ഇംപ്ലിമെന്റേഷൻ ആണ്. വിവിധ മോഡൽ പ്രൊവൈഡർമാർ പ്രതീക്ഷിക്കുന്ന റോ JSON ഫോർമാറ്റിംഗ് ഒഴിവാക്കാൻ വേണ്ടിയാണ് നമ്മൾ Converse API ഉപയോഗിക്കുന്നത്. നിങ്ങൾ മെസ്സേജുകളുടെ ഒരു ലിസ്റ്റും ഇൻഫറൻസ് സെറ്റിംഗുകളും നൽകിയാൽ മാത്രം മതി.

import boto3

def summarize_document(text: str) -> str:
    client = boto3.client("bedrock-runtime")
    
    model_id = "anthropic.claude-3-haiku-20240307-v1:0"
    
    messages = [
        {
            "role": "user",
            "content": [
                {
                    "text": (
                        "Provide a concise summary of the following document. "
                        "Focus on the main points and avoid unnecessary detail:\n\n"
                        f"{text}"
                    )
                }
            ]
        }
    ]
    
    response = client.converse(
        modelId=model_id,
        messages=messages,
        inferenceConfig={
            "temperature": 0.3,
            "maxTokens": 512
        }
    )
    
    summary = response["output"]["message"]["content"][0]["text"]
    return summary.strip()


if __name__ == "__main__":
    with open("document.txt", "r", encoding="utf-8") as f:
        document_text = f.read()
    
    result = summarize_document(document_text)
    print("\n--- Summary ---\n")
    print(result)

ഇവിടെ ശ്രദ്ധിക്കേണ്ട ചില പ്രായോഗിക കാര്യങ്ങൾ:

  • boto3.client("bedrock-runtime") ഇൻഫറൻസ് കൈകാര്യം ചെയ്യുന്ന റൺടൈം എൻഡ്‌പോയിന്റിലേക്കാണ് ലക്ഷ്യമിടുന്നത്. ~/.aws/config-ലെ നിങ്ങളുടെ AWS റീജിയൻ Bedrock സപ്പോർട്ട് ചെയ്യുന്നുണ്ടെന്നും അതേ റീജിയനിൽ നിങ്ങൾ Haiku എനേബിൾ ചെയ്തിട്ടുണ്ടെന്നും ഉറപ്പുവരുത്തുക.
  • Model ID anthropic.claude-3-haiku-20240307-v1:0 എന്നത് Bedrock പ്രതീക്ഷിക്കുന്ന കൃത്യമായ ഐഡന്റിഫയർ ആണ്. ഇത് കൃത്യമായി കോപ്പി ചെയ്യുക.
  • Temperature 0.3 ആയി സെറ്റ് ചെയ്യുന്നത് ഔട്ട്‌പുട്ടിനെ കൃത്യതയുള്ളതാക്കി നിലനിർത്തുന്നു. സമ്മറൈസേഷന് നിങ്ങൾക്ക് വേണ്ടത് ഉറവിട ടെക്സ്റ്റിനോടുള്ള കൃത്യതയും സ്ഥിരതയുമാണ്, അല്ലാതെ സർഗ്ഗാത്മകമായ മാറ്റങ്ങളല്ല. നിങ്ങൾ ടെമ്പറേച്ചർ 1.0-ലേക്ക് ഉയർത്തുകയാണെങ്കിൽ, മോഡൽ വാചകങ്ങളിൽ മാറ്റം വരുത്താനും ചിലപ്പോൾ പുതിയ വിവരങ്ങൾ കൂട്ടിച്ചേർക്കാനും തുടങ്ങും.
  • പ്രോംപ്റ്റ് വളരെ വ്യക്തമാണ്. വെറുതെ "summarize this" എന്ന് പറഞ്ഞ് ടെക്സ്റ്റ് നൽകുന്നതിന് പകരം, പ്രധാന പോയിന്റുകൾ ചോദിക്കുകയും അനാവശ്യ കാര്യങ്ങൾ ഒഴിവാക്കാൻ നിർദ്ദേശിക്കുകയും ചെയ്യുന്നു. ഇത്തരത്തിലുള്ള വ്യക്തതയാണ് ഉപയോഗശൂന്യമായ ഔട്ട്‌പുട്ടിനെ പ്രായോഗികമായ ഒന്നിൽ നിന്ന് വേർതിരിക്കുന്നത്.

നിങ്ങൾക്ക് സമ്മറൈസ് ചെയ്യേണ്ട ടെക്സ്റ്റ് ഫയൽ അതേ ഡയറക്ടറിയിൽ document.txt എന്ന പേരിൽ സേവ് ചെയ്യുക.

സ്റ്റെപ്പ് 4: ഇത് പ്രവർത്തിപ്പിക്കുക

നിങ്ങളുടെ വിർച്വൽ എൻവയോൺമെന്റ് ആക്റ്റീവ് ആണെന്ന് ഉറപ്പുവരുത്തി താഴെ പറയുന്നവ പ്രവർത്തിപ്പിക്കുക:

python summarize.py

നിങ്ങളുടെ ക്രെഡൻഷ്യലുകളും മോഡൽ ആക്സസും ശരിയാണെങ്കിൽ, ഏതാനും സെക്കൻഡുകൾക്കുള്ളിൽ ടെർമിനലിൽ ഒരു വൃത്തിയുള്ള സമ്മറി കാണാൻ സാധിക്കും. ആക്സസ് എറർ വരികയാണെങ്കിൽ, നിങ്ങളുടെ IAM പെർമിഷനുകൾ പരിശോധിക്കുകയും കൺസോളിൽ Claude 3 Haiku എനേബിൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പുവരുത്തുകയും ചെയ്യുക.

സ്ക്രിപ്റ്റിന് അപ്പുറത്തേക്ക്

ഈ പൈപ്പ്‌ലൈൻ ബോധപൂർവ്വം ലളിതമായാണ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്, എന്നാൽ യഥാർത്ഥ ഓട്ടോമേഷന്റെ അടിസ്ഥാനം ഇതാണ്. അനാവശ്യമായ സങ്കീർണ്ണതകൾ കൂട്ടാതെ ഇത് എങ്ങനെ വികസിപ്പിക്കാം എന്ന് താഴെ നൽകുന്നു.

Batch processing. ഒറ്റ ഫയൽ വായിക്കുന്നതിന് പകരം ഒരു ഡയറക്ടറിയിലുള്ള ഫയലുകൾക്കായി ഒരു ലൂപ്പ് (loop) ഉപയോഗിക്കുക. അമ്പത് PDF-കളോ ടെക്സ്റ്റ് ഫയലുകളോ ഒരു ഇൻപുട്ട് ഫോൾഡറിലേക്ക് നൽകുക, അവ ഓരോന്നായി പരിശോധിക്കുക (iterate), കൂടാതെ സംഗ്രഹങ്ങൾ (summaries) ഒരു ഔട്ട്‌പുട്ട് ഫോൾഡറിലേക്ക് എഴുതുക. നിങ്ങൾക്ക് നേരിട്ട് PDF-കൾ ഉപയോഗിക്കണമെന്നുണ്ടെങ്കിൽ, Bedrock-ലേക്ക് എത്തുന്നതിന് മുമ്പ് പച്ച ടെക്സ്റ്റ് (raw text) വേർതിരിച്ചെടുക്കാൻ PyPDF2 അല്ലെങ്കിൽ pdfplumber പോലുള്ള ഒരു ലൈബ്രറി ഉപയോഗിച്ച് ഒരു പ്രീപ്രോസസ്സിംഗ് ഘട്ടം ആവശ്യമായി വരും.

Chunking strategy. വളരെ നീളമുള്ള ഡോക്യുമെന്റുകൾ മോഡലിന്റെ കോൺടെക്സ്റ്റ് ലിമിറ്റ് (context limit) മറികടക്കാൻ സാധ്യതയുണ്ട്. അങ്ങനെ സംഭവിക്കുമ്പോൾ, ടെക്സ്റ്റിനെ ഖണ്ഡികകളായോ സെക്ഷനുകളായോ യുക്തിസഹമായ ഭാഗങ്ങളായി (logical chunks) തിരിക്കുക, ഓരോ ഭാഗവും പ്രത്യേകം സംഗ്രഹിക്കുക, തുടർന്ന് ആ ഇടക്കാല സംഗ്രഹങ്ങൾ (intermediate summaries) ഒരു അന്തിമ സംഗ്രഹത്തിനായി വീണ്ടും മോഡലിലേക്ക് നൽകുക. ഈ രണ്ട് ഘട്ടങ്ങളുള്ള രീതി ഡോക്യുമെന്റിലെ വിവരങ്ങൾ വിട്ടുപോകാതെ തന്നെ ടോക്കൺ പരിധിക്കുള്ളിൽ (token limits) നിലനിർത്താൻ സഹായിക്കുന്നു.

Error handling. പ്രൊഡക്ഷൻ കോഡുകൾ boto3.exceptions.ClientError പ്രത്യേകം കൈകാര്യം ചെയ്യണം. നിങ്ങൾ API വളരെ വേഗത്തിൽ വിളിച്ചാൽ (call) AWS നിങ്ങളുടെ റിക്വസ്റ്റുകൾ നിയന്ത്രിച്ചേക്കാം (throttle). നിങ്ങളുടെ converse കോളിനെ exponential backoff ഉള്ള ഒരു റീട്രൈ ലൂപ്പിൽ (retry loop) ഉൾപ്പെടുത്തുക, അല്ലെങ്കിൽ റേറ്റ് ലിമിറ്റുകൾ (rate limits) സുഗമമായി കൈകാര്യം ചെയ്യാൻ tenacity പോലുള്ള ഒരു ലൈബ്രറി ഉപയോഗിക്കുക.

Prompt engineering. ഒരു സാധാരണ സംഗ്രഹവും ഉപയോഗപ്രദമായ സംഗ്രഹവും തമ്മിലുള്ള വ്യത്യാസം പലപ്പോഴും പ്രോംപ്റ്റിൽ (prompt) ആണ് ഇരിക്കുന്നത്. വേഗത്തിൽ വായിച്ചു മനസ്സിലാക്കാൻ (scanability) ബുള്ളറ്റ് പോയിന്റുകൾ ആവശ്യപ്പെടുക. ഉയർന്ന ഉദ്യോഗസ്ഥർക്ക് വേണ്ടിയാണെങ്കിൽ ഒരു ഖണ്ഡിക മാത്രമുള്ള എക്സിക്യൂട്ടീവ് സമ്മറി ആവശ്യപ്പെടുക. "സംഗ്രഹം മൂന്ന് വാചകങ്ങളിൽ പരിമിതപ്പെടുത്തുക" എന്നോ "topic, key_points, action_items എന്നീ കീകളോട് കൂടിയ JSON രൂപത്തിൽ ഔട്ട്‌പുട്ട് നൽകുക" എന്നോ ഉള്ള ഫോർമാറ്റിംഗ് നിർദ്ദേശങ്ങളും നിങ്ങൾക്ക് നൽകാവുന്നതാണ്.

പ്രധാന പാഠം

ഒരു ചാറ്റ് പ്ലേഗ്രൗണ്ടിൽ നിന്ന് പ്രവർത്തിക്കുന്ന ഒരു സ്ക്രിപ്റ്റിലേക്കുള്ള മാറ്റം AI ഒരു ഇൻഫ്രാസ്ട്രക്ചറായി മാറുന്ന നിർണ്ണായക ഘട്ടമാണ്. ഈ പൈപ്പ്‌ലൈൻ ലോക്കലായി പ്രവർത്തിക്കാൻ തുടങ്ങിയാൽ, നിങ്ങൾക്ക് ഇത് S3 അപ്‌ലോഡുകൾ വഴി പ്രവർത്തിക്കുന്ന ഒരു AWS Lambda ഫംഗ്ഷനിലേക്ക് മാറ്റാം, ECS Fargate-ൽ ഷെഡ്യൂൾ ചെയ്യാം, അല്ലെങ്കിൽ നിലവിലുള്ള ഒരു ഡാറ്റാ വർക്ക്ഫ്ലോയുമായി ബന്ധിപ്പിക്കാം. API കോൾ എന്നത് എളുപ്പമുള്ള കാര്യമാണ്. എന്നാൽ ഫയലുകൾ, എററുകൾ, ഫോർമാറ്റിംഗ് എന്നിവ കൈകാര്യം ചെയ്യുന്ന ലോജിക് ഉപയോഗിച്ച് ആ കോളിനെ ഒരു സംവിധാനമായി മാറ്റുന്നതിലാണ് യഥാർത്ഥ എഞ്ചിനീയറിംഗ് മൂല്യം അടങ്ങിയിരിക്കുന്നത്; അങ്ങനെ നിങ്ങൾക്ക് ഇനി ഒരിക്കലും ഒരു ബ്രൗസറിലേക്ക് ടെക്സ്റ്റ് കോപ്പി ചെയ്ത് പേസ്റ്റ് ചെയ്യേണ്ടി വരില്ല.

ഈ സെറ്റപ്പിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്കും മാറ്റങ്ങൾക്കുമായി Dev.to-യിലെ യഥാർത്ഥ വിവരണം കാണുക. AWS ആർക്കിടെക്ചറുകൾ, LLM പൈപ്പ്‌ലൈനുകൾ, അല്ലെങ്കിൽ പ്രോംപ്റ്റ് എഞ്ചിനീയറിംഗ് എന്നിവയെക്കുറിച്ച് നിർമ്മാതാക്കളുടെ ഒരു കമ്മ്യൂണിറ്റിയുമായി ചർച്ച ചെയ്യാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, GyaanSetu AI on Telegram എന്ന ലിങ്ക് വഴി സംഭാഷണത്തിൽ പങ്കുചേരുക.