Web playgrounds டெமோக்களுக்குச் சிறந்தவை. நீங்கள் ஒரு உரைத் தொகுப்பை (block of text) ஒட்டலாம், மாடல் ஒரு நேர்த்தியான சுருக்கத்தை உருவாக்குவதைப் பார்க்கலாம், பிறகு அந்தத் தாவலை (tab) மூடிவிடலாம். ஆனால் அது பொறியியல் (engineering) அல்ல. தயாரிப்புப் பணி (Production work) என்பது APIs, பிழை கையாளுதல் (error handling) மற்றும் நீங்கள் தூங்கிக் கொண்டிருக்கும் போதும் இயங்கக்கூடிய குறியீடுகளைக் (code) குறிக்கும். கூட்டங்களின் டிரான்ஸ்கிரிப்ட்கள் (meeting transcripts), ஆதரவு டிக்கெட்டுகள் (support tickets) அல்லது ஆராய்ச்சித் தாள்களை ஒரு குறிப்பிட்ட கால அட்டவணையின்படி கையாள நீங்கள் விரும்பினால், உங்களுக்கு ஒரு பைப்லைன் (pipeline) தேவை.

இந்த வழிகாட்டி சரியாக அதையே உருவாக்குவது பற்றி விளக்குகிறது: Python, AWS SDK for Python (boto3) மற்றும் Amazon Bedrock ஆகியவற்றைப் பயன்படுத்தி ஒரு இலகுவான, தானியங்கி ஆவணச் சுருக்க ஸ்கிரிப்டை (automated document summarization script) உருவாக்குதல். உரைச் சுருக்கப் பணிகளுக்கு வேகம் மற்றும் செலவு ஆகியவற்றின் சரியான சமநிலையைக் கொண்ட Anthropic-ன் Claude 3 Haiku மாடலை நாம் பயன்படுத்துவோம்.

ஏன் Bedrock மற்றும் Claude 3 Haiku?

Amazon Bedrock என்பது ஒரு மேலாண்மை செய்யப்பட்ட சேவையாகும் (managed service), இது ஒரு ஒற்றை AWS API தொகுப்பின் மூலம் பவுண்டேஷன் மாடல்களை (foundation models) வழங்குகிறது. வெளிப்புற எண்ட்பாயிண்டுகளை (external endpoints) ஒன்றிணைப்பதற்கும், தனித்தனி பில்லிங் மற்றும் பாதுகாப்பு மாதிரிகளுடன் போராடுவதற்கும் பதிலாக, நீங்கள் நிலையான IAM கட்டுப்பாடுகளுடன் ஒரு AWS எண்ட்பாயிண்டை அழைக்கலாம். உங்கள் தரவு உங்கள் AWS சூழலுக்குள்ளேயே இருக்கும்.

Claude 3 Haiku என்பது Anthropic-ன் Claude 3 குடும்பத்தில் மிகவும் இலகுவான மாடல் ஆகும். இது விரைவான பதிலளிப்பு மற்றும் குறைந்த செலவிற்காக உருவாக்கப்பட்டுள்ளது, இது அதிக அளவிலான சுருக்கப் பணிகளுக்கு (high-volume summarization) மிகவும் ஏற்றது. எளிய வாசிப்புப் பணிகளுக்காக பெரிய மாடல்களின் அதிகப்படியான திறனுக்காக (horsepower) பணம் செலுத்தாமல், கணிக்கக்கூடிய வெளியீட்டைப் பெற இது உதவும்.

உங்களுக்குத் தேவையானவை

எந்தவொரு குறியீட்டை எழுதுவதற்கு முன்பும், பின்வருவனவற்றைத் தயாராக வைத்திருப்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்:

  • ஒரு செயல்பாட்டில் உள்ள AWS கணக்கு.
  • உள்ளூரில் (locally) நிறுவப்பட்ட Python 3.9 அல்லது அதற்கு மேற்பட்ட பதிப்பு.
  • Bedrock மாடல்களை அழைக்க அனுமதி கொண்ட தகுதியுடன் (credentials) கட்டமைக்கப்பட்ட AWS CLI. நீங்கள் இன்னும் aws configure செய்யவில்லை என்றால், இப்போதே அதைச் செய்யுங்கள். பின்னர் நீங்கள் அனுமதி பிழைகளை (permission errors) எதிர்கொண்டால், உங்கள் IAM பயனர் அல்லது ரோலுக்கு (role) பொருத்தமான Bedrock invocation அனுமதிகளை இணைக்க வேண்டியிருக்கும்.
  • AWS Bedrock கன்சோலில் Anthropic Claude 3 Haiku-க்காக பிரத்யேகமாக மாடல் அணுகல் (Model access) செயல்படுத்தப்பட்டிருக்க வேண்டும். நீங்கள் ஒரு மாடலை அழைப்பதற்கு முன், ஒவ்வொரு மாடல் வழங்குநருக்கும் (model provider) நீங்கள் வெளிப்படையாக ஒப்புதல் அளிக்க வேண்டும் என்று AWS கோருகிறது.

படி 1: Model Access-ஐ அனுமதித்தல்

Bedrock நேரடியாக மாடல்களை அழைக்க அனுமதிப்பதில்லை. நீங்கள் முதலில் கன்சோலில் (console) அதைச் செயல்படுத்த வேண்டும்.

  1. AWS Management Console-இல் லாக்-இன் செய்யவும்.
  2. தேடல் பட்டியில் (search bar) Amazon Bedrock என்பதைக் கண்டறியவும்.
  3. இடது பக்க வழிசெலுத்தல் பேனலில் (navigation panel), Model access என்பதைத் தேர்ந்தெடுக்கவும்.
  4. Modify model access என்பதைக் கிளிக் செய்யவும்.
  5. Anthropic (Claude 3 Haiku) பெட்டியைத் டிக் செய்து உங்கள் கோரிக்கையைச் சமர்ப்பிக்கவும்.

நிலை (status) "Access granted" என மாறியவுடன், நீங்கள் குறியீட்டின் மூலம் மாடலை அழைக்கத் தயாராகிவிட்டீர்கள் என்று அர்த்தம்.

படி 2: உங்கள் சூழலை (Environment) அமைத்தல்

ஒரு சுத்தமான Python சூழல் (environment), சார்புகளை (dependencies) தனிமைப்படுத்தவும் மீண்டும் உருவாக்கக்கூடியதாகவும் (reproducible) வைத்திருக்கும். உங்கள் டெர்மினலைத் திறந்து இந்த கட்டளைகளை இயக்கவும்:

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

Windows பயனர்கள் activation கட்டளைக்கு பதிலாக venv\Scripts\activate என்பதைப் பயன்படுத்த வேண்டும். pip install boto3 முடிந்ததும், AWS APIs உடன் தொடர்பு கொள்ளத் தேவையான அனைத்தும் உங்களிடம் இருக்கும்.

படி 3: ஸ்கிரிப்டை எழுதுதல்

summarize.py என்ற பெயரில் ஒரு கோப்பை உருவாக்கவும். வட்டில் (disk) இருந்து ஒரு ஆவணத்தைப் படித்து, அதை Bedrock Converse API-யிடம் ஒப்படைத்து, ஒரு சுருக்கமான சுருக்கத்தை அச்சிடுவதுதான் இதன் நோக்கம்.

கீழே முழுமையான, இயங்கக்கூடிய செயலாக்கம் (implementation) கொடுக்கப்பட்டுள்ளது. வெவ்வேறு மாடல் வழங்குநர்கள் எதிர்பார்க்கும் மூல JSON வடிவமைப்பை (raw JSON formatting) இது எளிமையாக்குவதால், நாம் Converse API-யைப் பயன்படுத்துகிறோம். நீங்கள் செய்ததெல்லாம் செய்திகளின் பட்டியல் (list of messages) மற்றும் அனுமான அமைப்புகளை (inference settings) வழங்குவது மட்டுமே.

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") என்பது அனுமானத்தைக் (inference) கையாளும் runtime எண்ட்பாயிண்டைக் குறிக்கிறது. ~/.aws/config-இல் உள்ள உங்கள் AWS region Bedrock-ஐ ஆதரிக்கிறதா என்பதையும், அதே region-இல் நீங்கள் Haiku-வைச் செயல்படுத்தியிருக்கிறீர்களையும் உறுதிப்படுத்திக் கொள்ளுங்கள்.
  • Model ID anthropic.claude-3-haiku-20240307-v1:0 என்பது Bedrock எதிர்பார்க்கும் துல்லியமான அடையாளங்காட்டி (identifier) ஆகும். அதை அப்படியே நகலெடுக்கவும்.
  • Temperature 0.3 என அமைக்கப்படுவது வெளியீட்டைத் துல்லியமாக வைத்திருக்க உதவுகிறது. சுருக்கப் பணிகளுக்கு, உங்களுக்கு மூல உரையின் (source text) நிலைத்தன்மையும் நம்பகத்தன்மையுமே தேவை தவிர, கற்பனைத் திறனைத் தேவையில்லை. நீங்கள் வெப்பநிலையை (temperature) 1.0 நோக்கி உயர்த்தினால், மாடல் சொற்றொடர்களைத் தன்னிச்சையாக மாற்றத் தொடங்கும் மற்றும் அவ்வப்போது விவரங்களைத் தானாகவே உருவாக்கும்.
  • ப்ராம்ப்ட் (prompt) மிகவும் குறிப்பிட்டது. மாடலுக்கு "இதைச் சுருக்கு" (summarize this) என்று ஒரு தெளிவற்ற உரையைத் தராமல், முக்கியக் கருத்துக்களைக் கேட்கிறோம் மற்றும் தேவையற்ற விஷயங்களைத் தவிர்க்குமாறு அறிவுறுத்துகிறோம். இத்தகைய தெளிவுதான் பயன்படுத்த முடியாத வெளியீட்டிற்கும், நீங்கள் உண்மையில் பயன்படுத்தக்கூடிய வெளியீட்டிற்கும் இடையிலான வேறுபாட்டை உருவாக்குகிறது.

நீங்கள் சுருக்க விரும்பும் எந்தவொரு உரை கோப்பையும் (text file) அதே கோப்பகத்தில் (directory) வைத்து அதற்கு document.txt என்று பெயரிடவும்.

படி 4: இயக்குதல்

உங்கள் விர்ச்சுவல் என்விரான்மென்ட் (virtual environment) செயல்பாட்டில் இருக்கும்போது, இதை இயக்கவும்:

python summarize.py

உங்கள் தகுதிகள் (credentials) மற்றும் மாடல் அணுகல் சரியாக இருந்தால், சில வினாடிகளுக்குள் உங்கள் டெர்மினலில் ஒரு நேர்த்தியான சுருக்கம் அச்சிடப்படுவதைக் காண்பீர்கள். உங்களுக்கு அணுகல் பிழை (access error) ஏற்பட்டால், உங்கள் IAM அனுமதிகளை மீண்டும் சரிபார்க்கவும் மற்றும் கன்சோலில் Claude 3 Haiku-வைச் செயல்படுத்தியிருப்பதை உறுதி செய்யவும்.

ஸ்கிரிப்டைத் தாண்டி அடுத்த கட்டத்திற்குச் செல்லுதல்

இந்தத் தொடர்முறை (pipeline) வேண்டுமென்றே எளிமையாக வடிவமைக்கப்பட்டுள்ளது, ஆனால் இது உண்மையான தானியங்கி செயல்பாட்டிற்கான (automation) அடித்தளமாகும். தேவையற்ற சிக்கல்களைச் சேர்க்காமல் இதை நீங்கள் எவ்வாறு விரிவுபடுத்தலாம் என்பது இதோ.

தொகுதி செயலாக்கம் (Batch processing). ஒற்றை கோப்பை வாசிப்பதற்குப் பதிலாக, ஒரு கோப்பகத்தில் (directory) உள்ள கோப்புகளை ஒரு லூப் (loop) மூலம் வாசிக்கும் முறையைப் பயன்படுத்தவும். ஐம்பது PDF அல்லது உரைத் கோப்புகளை (text files) ஒரு உள்ளீட்டுத் கோப்புறையில் (input folder) போட்டு, அவற்றை ஒவ்வொன்றாகச் செயலாக்கி, அதன் சுருக்கங்களை ஒரு வெளியீட்டுத் கோப்புறையில் (output folder) சேமிக்கவும். நீங்கள் PDF கோப்புகளை நேரடியாகப் பயன்படுத்த விரும்பினால், Bedrock-க்கு அனுப்பும் முன், PyPDF2 அல்லது pdfplumber போன்ற ஒரு நூலகத்தைப் (library) பயன்படுத்தி மூல உரையை (raw text) பிரித்தெடுக்கும் ஒரு முன்செயலாக்க (preprocessing) படிநிலை உங்களுக்குத் தேவைப்படும்.

துண்டுகளாகப் பிரிக்கும் உத்தி (Chunking strategy). மிக நீண்ட ஆவணங்கள் மாதிரியின் (model) சூழல் வரம்பைத் (context limit) தாண்டக்கூடும். அவ்வாறு நடக்கும்போது, உரையை பத்தி அல்லது பிரிவுகளாகத் தர்க்கரீதியான துண்டுகளாகப் பிரிக்கவும், ஒவ்வொரு துண்டையும் தனித்தனியாகச் சுருக்கவும், பின்னர் அந்த இடைநிலைச் சுருக்கங்களை இறுதிச் தொகுப்பிற்காக மீண்டும் மாதிரியிடம் அனுப்பவும். இந்த இருநிலை அணுகுமுறை, முழு ஆவணத்தின் உள்ளடக்கத்தையும் சிதைக்காமல், டோக்கன் வரம்பிற்குள் (token limits) உங்களை வைத்திருக்க உதவும்.

பிழை கையாளுதல் (Error handling). பயன்பாட்டு நிலையில் உள்ள குறியீடு (Production code) குறிப்பாக boto3.exceptions.ClientError-ஐக் கண்டறிய வேண்டும். நீங்கள் API-ஐ மிக வேகமாகத் தொடர்ந்து அழைத்தால், AWS உங்கள் கோரிக்கைகளைக் கட்டுப்படுத்தலாம் (throttle). உங்கள் converse அழைப்பை 'exponential backoff' வசதியுடன் கூடிய ஒரு 'retry loop'-க்குள் வைக்கவும், அல்லது 'rate limits'-ஐச் சிறப்பாகக் கையாள tenacity போன்ற ஒரு நூலகத்தைப் பயன்படுத்தவும்.

தூண்டுதல் பொறியியல் (Prompt engineering). ஒரு சாதாரணச் சுருக்கத்திற்கும் பயனுள்ள சுருக்கத்திற்கும் இடையிலான வேறுபாடு பெரும்பாலும் நீங்கள் கொடுக்கும் 'prompt'-ஐப் பொறுத்தே அமைகிறது. எளிதாகப் படிக்கத் தேவைப்பட்டால் புல்லட் புள்ளிகளைக் (bullet points) கேட்கவும். வாசகர்கள் உயர்நிலைத் தலைவர்கள் என்றால், ஒரு பத்தி கொண்ட நிர்வாகச் சுருக்கத்தைக் (executive summary) கேட்கவும். "சுருக்கத்தை மூன்று வாக்கியங்களாகக் கட்டுப்படுத்தவும்" அல்லது "topic, key_points, மற்றும் action_items ஆகிய சாவிகளுடன் (keys) JSON வடிவில் வெளியீட்டைத் தரவும்" போன்ற வடிவமைப்புத் தடைகளையும் (formatting constraints) நீங்கள் வழங்கலாம்.

உண்மையான பயன்

ஒரு சாட் பிளேக்ரவுண்டிலிருந்து (chat playground) ஒரு இயங்கக்கூடிய ஸ்கிரிப்டிற்கு மாறுவது என்பது AI ஒரு உள்கட்டமைப்பாக (infrastructure) மாறும் ஒரு முக்கியத் திருப்புமுனையாகும். இந்தத் தொடர்முறை உள்ளூர் கணினியில் (locally) இயங்கத் தொடங்கியதும், அதை S3 பதிவேற்றங்களால் தூண்டப்படும் (triggered) ஒரு AWS Lambda செயல்பாடாக மாற்றலாம், ECS Fargate-இல் திட்டமிடலாம் அல்லது ஏற்கனவே உள்ள தரவுப் பணிப்பாய்வோடு (data workflow) இணைக்கலாம். API அழைப்பு என்பது எளிதான பகுதி. கோப்புகள், பிழைகள் மற்றும் வடிவமைப்பைக் கையாளும் தர்க்கத்துடன் (logic) அந்த அழைப்பை இணைப்பதில் தான் பொறியியல் மதிப்பு உள்ளது; இதன் மூலம் நீங்கள் இனி ஒருபோதும் உரையை உலாவியில் (browser) நகலெடுத்து ஒட்ட வேண்டியிருக்காது.

இந்த அமைப்பைப் பற்றிய கூடுதல் விவரங்கள் மற்றும் மாற்றங்களுக்கு, Dev.to-வில் உள்ள அசல் வழிகாட்டியைப் பார்க்கவும். நீங்கள் AWS கட்டமைப்புகள் (architectures), LLM தொடர்முறைகள் அல்லது தூண்டுதல் பொறியியல் பற்றி உருவாக்குநர்களின் சமூகத்துடன் விவாதிக்க விரும்பினால், GyaanSetu AI on Telegram இல் இணைந்து உரையாடுங்கள்.