વેબ પ્લેગ્રાઉન્ડ્સ ડેમો માટે ઉત્તમ છે. તમે ટેક્સ્ટનો એક બ્લોક પેસ્ટ કરો છો, મોડેલ એક સુંદર સારાંશ (summary) બનાવે છે તે જુઓ છો, અને ટેબ બંધ કરી દો છો. પરંતુ તે એન્જિનિયરિંગ નથી. પ્રોડક્શન વર્ક એટલે APIs, એરર હેન્ડલિંગ અને એવો કોડ જે તમે સૂતા હોવ ત્યારે પણ ચાલતો રહે. જો તમારે મીટિંગ ટ્રાન્સક્રિપ્ટ્સ, સપોર્ટ ટિકિટ્સ અથવા રિસર્ચ પેપર્સને શેડ્યૂલ મુજબ પ્રોસેસ કરવા હોય, તો તમારે એક પાઇપલાઇનની જરૂર છે.
આ ગાઈડ બરાબર તે જ બનાવવાની પ્રક્રિયા સમજાવે છે: Python, AWS SDK for Python (boto3), અને Amazon Bedrock નો ઉપયોગ કરીને એક લાઇટવેઇટ, ઓટોમેટેડ ડોક્યુમેન્ટ સમરાઇઝેશન સ્ક્રિપ્ટ. અમે Anthropic ના Claude 3 Haiku નો ઉપયોગ કરીશું, જે ટેક્સ્ટ સમરાઇઝેશન કાર્યો માટે ઝડપ અને ખર્ચના સંતુલનનું શ્રેષ્ઠ મોડેલ છે.
Bedrock અને Claude 3 Haiku શા માટે?
Amazon Bedrock એ એક મેનેજ્ડ સર્વિસ છે જે સિંગલ AWS APIs દ્વારા ફાઉન્ડેશન મોડેલ્સ પ્રદાન કરે છે. એક્સટર્નલ એન્ડપોઇન્ટ્સને ભેગા કરવા અને અલગ-અલગ બિલિંગ અને સિક્યુરિટી મોડેલ્સ સાથે ઝઘડવાને બદલે, તમે સ્ટાન્ડર્ડ IAM કંટ્રોલ્સ સાથે AWS એન્ડપોઇન્ટને કોલ કરી શકો છો. તમારો ડેટા તમારા AWS એન્વાયરમેન્ટની અંદર જ રહે છે.
Claude 3 Haiku એ Anthropic ના Claude 3 ફેમિલીનું સૌથી લિન (lean) મોડેલ છે. તે રિસ્પોન્સિવનેસ અને ઓછા ખર્ચ માટે બનાવવામાં આવ્યું છે, જે તેને હાઇ-વોલ્યુમ સમરાઇઝેશન માટે આદર્શ બનાવે છે જ્યાં તમે સાદા વાંચવાના કાર્યો માટે મોટા મોડેલ્સની ક્ષમતા માટે વધુ ચૂકવણી કર્યા વિના અનુમાનિત આઉટપુટ મેળવવા માંગો છો.
તમારે શું જોઈએ છે
કોઈપણ કોડ લખતા પહેલા, ખાતરી કરો કે તમારી પાસે નીચેની વસ્તુઓ તૈયાર છે:
- એક એક્ટિવ AWS એકાઉન્ટ.
- લોકલી ઇન્સ્ટોલ કરેલ Python 3.9 અથવા તેનાથી ઉપરનું વર્ઝન.
- Bedrock મોડેલ્સને ઇવોક (invoke) કરવાની પરવાનગી ધરાવતા ક્રેડેન્શિયલ્સ સાથે કોન્ફિગર કરેલ AWS CLI. જો તમે હજુ સુધી
aws configureરન નથી કર્યું, તો અત્યારે જ કરી લો. જો તમને પછીથી પરમિશન એરર આવે, તો તમારે તમારા IAM યુઝર અથવા રોલ સાથે યોગ્ય Bedrock invocation પરમિશન જોડવાની જરૂર પડી શકે છે. - AWS Bedrock કન્સોલની અંદર ખાસ કરીને Anthropic Claude 3 Haiku માટે મોડેલ એક્સેસ સક્ષમ હોવું જોઈએ. AWS માં તમે કોઈપણ મોડેલ પ્રોવાઇડરને કોલ કરતા પહેલા તેના માટે સ્પષ્ટપણે ઓપ્ટ-ઇન (opt in) કરવું જરૂરી છે.
સ્ટેપ 1: મોડેલ એક્સેસ સક્ષમ કરો
Bedrock તમને સીધું જ મોડેલ્સ કોલ કરવા દેતું નથી. તમારે પહેલા કન્સોલમાં સ્વિચ ચાલુ કરવી પડશે.
- AWS Management Console માં લોગ ઇન કરો.
- Amazon Bedrock શોધવા માટે સર્ચ બારનો ઉપયોગ કરો.
- ડાબી નેવિગેશન પેનલમાં, Model access પસંદ કરો.
- Modify model access પર ક્લિક કરો.
- 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
Windows યુઝર્સે એક્ટિવેશન કમાન્ડને venv\Scripts\activate સાથે બદલવો જોઈએ. pip install boto3 પૂર્ણ થયા પછી, તમારી પાસે AWS APIs સાથે વાત કરવા માટે જરૂરી બધું જ હશે.
સ્ટેપ 3: સ્ક્રિપ્ટ લખો
summarize.py નામની ફાઇલ બનાવો. ધ્યેય ડિસ્કમાંથી ડોક્યુમેન્ટ વાંચવાનો, તેને Bedrock Converse API ને આપવાનો અને સંક્ષિપ્ત સારાંશ (summary) પ્રિન્ટ કરવાનો છે.
નીચે સંપૂર્ણ, કાર્યરત અમલીકરણ (implementation) છે. અમે Converse API નો ઉપયોગ કરીએ છીએ કારણ કે તે અલગ-અલગ મોડેલ પ્રોવાઇડર્સ અપેક્ષા રાખતા કાચા JSON ફોર્મેટિંગને સરળ બનાવે છે. તમે ફક્ત મેસેજની યાદી અને ઇન્ફરન્સ સેટિંગ્સ પાસ કરો છો.
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 પર સેટ કરવાથી આઉટપુટ સચોટ રહે છે. સમરાઇઝેશન માટે, તમારે સ્ત્રોત ટેક્સ્ટ પ્રત્યે સુસંગતતા અને વફાદારી જોઈએ છે, સર્જનાત્મક વધારા નહીં. જો તમે તાપમાન (temperature) 1.0 તરફ વધારશો, તો મોડેલ શબ્દો સાથે રમત કરવાનું શરૂ કરશે અને ક્યારેક વિગતોની ઉપજાવી કાઢશે.
- પ્રોમ્પ્ટ પોતે જ ચોક્કસ છે. મોડેલ પર અસ્પષ્ટ "summarize this" સાથે કાચું ટેક્સ્ટ ફેંકવાને બદલે, અમે સ્પષ્ટપણે મુખ્ય મુદ્દાઓ માટે પૂછીએ છીએ અને તેને બિનજરૂરી વિગતો છોડવા માટે સૂચના આપીએ છીએ. આ પ્રકારની સ્પષ્ટતા બિનઉપયોગી આઉટપુટ અને તમે ખરેખર ઉપયોગમાં લઈ શકો તેવા આઉટપુટ વચ્ચે તફાવત લાવે છે.
તમે જે ટેક્સ્ટ ફાઇલનો સારાંશ મેળવવા માંગતા હોવ તેને તે જ ડિરેક્ટરીમાં મૂકો અને તેનું નામ document.txt રાખો.
સ્ટેપ 4: તેને રન કરો
તમારું વર્ચ્યુઅલ એન્વાયરમેન્ટ એક્ટિવ હોય ત્યારે, આ રન કરો:
python summarize.py
જો તમારા ક્રેડેન્શિયલ્સ અને મોડેલ એક્સેસ સાચા હશે, તો તમે થોડી સેકન્ડોમાં તમારા ટર્મિનલમાં એક વ્યવસ્થિત સારાંશ પ્રિન્ટ થયેલો જોશો. જો તમને એક્સેસ એરર આવે, તો તમારા IAM પરમિશન ફરીથી તપાસો અને ખાતરી કરો કે તમે કન્સોલમાં Claude 3 Haiku સક્ષમ કર્યું છે.
સ્ક્રિપ્ટથી આગળ વધવું
આ પાઇપલાઇન જાણીજોઈને સરળ રાખવામાં આવી છે, પરંતુ તે વાસ્તવિક ઓટોમેશન માટેનો પાયો છે. તમે વધારાનો બિનજરૂરી ભાર ઉમેર્યા વિના તેને કેવી રીતે વિસ્તૃત કરી શકો છો તે અહીં છે.
Batch processing. સિંગલ ફાઇલ રીડને બદલે ડિરેક્ટરી પર લૂપ (loop) નો ઉપયોગ કરો. ઇનપુટ ફોલ્ડરમાં પચાસ PDFs અથવા ટેક્સ્ટ ફાઇલો નાખો, તેના પર ઇટરેટ (iterate) કરો, અને સારાંશને આઉટપુટ ફોલ્ડરમાં લખો. જો તમે સીધી રીતે PDFs ઇન્જેસ્ટ કરવા માંગતા હોવ, તો Bedrock સુધી પહોંચતા પહેલા કાચો ટેક્સ્ટ (raw text) કાઢવા માટે તમારે PyPDF2 અથવા pdfplumber જેવી લાઇબ્રેરી સાથે પ્રી-પ્રોસેસિંગ સ્ટેપની જરૂર પડશે.
Chunking strategy. ખૂબ લાંબા દસ્તાવેજો મોડેલની કોન્ટેક્સ્ટ લિમિટ (context limit) કરતાં વધી શકે છે. જ્યારે આવું થાય, ત્યારે ટેક્સ્ટને પેરેગ્રાફ અથવા સેક્શન દ્વારા તાર્કિક ચંક્સ (chunks) માં વિભાજિત કરો, દરેક ચંકનો વ્યક્તિગત રીતે સારાંશ બનાવો, અને પછી અંતિમ સંશ્લેષણ (synthesis) માટે મધ્યવર્તી સારાંશને ફરીથી મોડેલ દ્વારા પસાર કરો. આ બે-તબક્કાની અભિગમ તમને આખા દસ્તાવેજનું કવરેજ જાળવી રાખીને ટોકન લિમિટની અંદર રાખે છે.
Error handling. પ્રોડક્શન કોડમાં ખાસ કરીને boto3.exceptions.ClientError ને કેચ (catch) કરવો જોઈએ. જો તમે API ને ખૂબ જ આક્રમક રીતે કોલ કરો છો, તો AWS તમારી વિનંતીઓને થ્રોટલ (throttle) કરી શકે છે. તમારા converse કોલને એક્સપોનેન્શિયલ બેકઓફ (exponential backoff) સાથે રીટ્રાય લૂપમાં રેપ કરો, અથવા રેટ લિમિટને યોગ્ય રીતે હેન્ડલ કરવા માટે tenacity જેવી લાઇબ્રેરીનો ઉપયોગ કરો.
Prompt engineering. એક સામાન્ય સારાંશ અને ઉપયોગી સારાંશ વચ્ચેનો તફાવત ઘણીવાર પ્રોમ્પ્ટ (prompt) પર આધારિત હોય છે. જો તમારે ઝડપથી વાંચી શકાય તેવું (scanability) જોઈતું હોય, તો બુલેટ પોઈન્ટ્સ માટે પૂછો. જો પ્રેક્ષકો વરિષ્ઠ નેતૃત્વ (senior leadership) હોય, તો એક પેરેગ્રાફના એક્ઝિક્યુટિવ સારાંશ માટે પૂછો. તમે ફોર્મેટિંગના નિયંત્રણો પણ આપી શકો છો, જેમ કે "સારાંશને ત્રણ વાક્યો સુધી મર્યાદિત કરો" અથવા "આઉટપુટને topic, key_points, અને action_items કી સાથે JSON તરીકે રિટર્ન કરો."
મુખ્ય તારણ
ચેટ પ્લેગ્રાઉન્ડમાંથી કાર્યરત સ્ક્રિપ્ટ તરફ આગળ વધવું એ એવો વળાંક છે જ્યાં AI ઇન્ફ્રાસ્ટ્રક્ચરમાં પરિવર્તિત થાય છે. એકવાર આ પાઇપલાઇન લોકલી ચાલે, પછી તમે તેને S3 અપલોડ દ્વારા ટ્રિગર થતા AWS Lambda ફંક્શનમાં લઈ જઈ શકો છો, ECS Fargate પર શેડ્યૂલ કરી શકો છો, અથવા તેને હાલના ડેટા વર્કફ્લો સાથે જોડી શકો છો. API કોલ એ સરળ ભાગ છે. એન્જિનિયરિંગ મૂલ્ય તે કોલને એવી લોજિકમાં રેપ કરવાથી આવે છે જે ફાઇલો, ભૂલો અને ફોર્મેટિંગને હેન્ડલ કરે છે જેથી તમારે ફરી ક્યારેય બ્રાઉઝરમાં ટેક્સ્ટ કોપી અને પેસ્ટ કરવાની જરૂર ન પડે.
આ સેટઅપ પર વધુ સંદર્ભ અને વિવિધતાઓ માટે, Dev.to પર મૂળ વોકથ્રુ (walkthrough) જુઓ. જો તમે બિલ્ડર્સના સમુદાય સાથે AWS આર્કિટેક્ચર્સ, LLM પાઇપલાઇન્સ અથવા પ્રોમ્પ્ટ એન્જિનિયરિંગ વિશે ચર્ચા કરવા માંગતા હોવ, તો GyaanSetu AI on Telegram પર વાતચીતમાં જોડાઓ.