Docker का उपयोग करके LLM एप्लिकेशन कैसे डिप्लॉय करें: चरण-दर-चरण मार्गदर्शिका

प्रोजेक्ट विवरण

AI एप्लिकेशन विकसित और डिप्लॉय करने के दो मुख्य तरीके हैं:

• पूरी तरह ओपन सोर्स: यह तरीका गोपनीयता और डेटा सुरक्षा पर ज़ोर देता है।
• पूरी तरह क्लोज़्ड सोर्स: इस तरीके में कई API और क्लाउड सेवाओं का एकीकरण शामिल है।

दोनों तरीकों के अपने फायदे और नुकसान हैं। हमारे मामले में, हमने दूसरा तरीका चुना है—कई AI सेवाओं का एकीकरण। इससे हम तेज़ AI एप्लिकेशन बना सकते हैं, जिसे बनाना और डिप्लॉय करना कुछ ही सेकंड में हो जाता है। हमारा मुख्य ध्यान Docker इमेज का आकार कम करना है, जिसे कई AI सेवाओं को इंटीग्रेट करके प्रभावी ढंग से हासिल किया जा सकता है।

बेहतर गोपनीयता के लिए ओपन-सोर्स टूल्स और फ़्रेमवर्क का उपयोग करके LLM एप्लिकेशन बनाने हेतु Local AI with Docker, n8n, Qdrant, and Ollama ट्यूटोरियल देखें!

हम एक सामान्य-उद्देश्य Q&A चैटबॉट बनाएंगे, जो उपयोगकर्ताओं को डॉक्यूमेंट अपलोड करने और रियल-टाइम में उनसे चैट करने की अनुमति देगा। यह Google के NotebookLM के काफी समान है।

प्रोजेक्ट डायग्राम। चित्र: लेखक द्वारा

इस प्रोजेक्ट में हम जिन टूल्स का उपयोग करेंगे, वे हैं:

1. Gradio Blocks: ऐसा यूज़र इंटरफ़ेस बनाने के लिए जो उपयोगकर्ताओं को कोई भी टेक्स्ट डॉक्यूमेंट अपलोड करने और आसानी से उससे चैट करने देता है।
2. LlamaCloud: फाइलों को पार्स करने और मार्कडाउन शैली में टेक्स्ट डेटा निकालने के लिए।
3. MixedBread AI: लोड किए गए डॉक्यूमेंट्स और चैट संदेशों को संदर्भ पुनर्प्राप्ति के लिए एम्बेडिंग्स में बदलने हेतु।
4. Groq Cloud: तेज़ LLM प्रतिक्रियाएँ पाने के लिए। इस प्रोजेक्ट में हम llama-3.1-70b मॉडल का उपयोग करेंगे।
5. LlamaIndex: RAG (Retrieval Augmented Generation) पाइपलाइन बनाने के लिए, जो सभी AI सेवाओं का समन्वय करेगी। पाइपलाइन अपलोड की गई फ़ाइल और यूज़र संदेशों का उपयोग करके संदर्भ-सचेत उत्तर उत्पन्न करेगी।
6. Docker: ऐप, निर्भरताएँ, वातावरण और कॉन्फ़िगरेशन को समेटने के लिए।
7. Hugging Face Cloud: हम सभी फ़ाइलों को Spaces रिपॉज़िटरी में पुश करेंगे, और Hugging Face Dockerfile का उपयोग करके इमेज को स्वतः बनाएगा और सर्वर पर डिप्लॉय करेगा।

यदि आप LLMs में नए हैं, तो बुनियादी शब्दावली, कार्यप्रणालियाँ, नैतिक विचार और नवीनतम शोध सीखने के लिए Master Large Language Models (LLMs) Concepts कोर्स करें।

1. वातावरण की सेटिंग

LLM ऐप बनाने से पहले, हमें आधिकारिक वेबसाइट से Docker डाउनलोड और इंस्टॉल करना होगा। 

• अपने लोकल सिस्टम पर डिफ़ॉल्ट विकल्पों का उपयोग करके Docker इंस्टॉल करें।
• इसके बाद, अपने पसंदीदा IDE में एक प्रोजेक्ट डायरेक्टरी बनाएँ और एक .env फ़ाइल जोड़ें। हम इसमें LlamaCloud, MixedBread AI, और Groq Cloud के API कुंजी स्टोर करेंगे।
• इसके बाद, LlamaCloud पर साइन अप करें और अपनी API कुंजी जनरेट करें। हम Excel, txt, Word और PDF सहित विभिन्न टेक्स्ट फ़ॉर्मेट्स को पार्स करने के लिए LlamaCloud का उपयोग करेंगे।

LlamaCloud में नई कुंजी बनाना। चित्र स्रोत: LlamaCloud

• अगला, MixedBread AI पर साइन अप करें और अपनी API कुंजी जनरेट करें। हम उनके उच्च-स्तरीय एम्बेडिंग मॉडल तक मुफ़्त पहुँच के लिए इस कुंजी का उपयोग करेंगे।

MixedBread में API कुंजी बनाना। चित्र स्रोत: MixedBread

• GroqCloud पर जाएँ और बिना किसी लागत के अपनी API कुंजी जनरेट करने के लिए साइन अप करें। हम उच्च-गति वाले LLMs तक पहुँच के लिए GroqCloud का उपयोग करेंगे।

GroqCloud में API कुंजी बनाना।  चित्र स्रोत: GroqCloud

GroqCloud के बारे में सब कुछ Groq LPU Inference Engine पर लेख पढ़कर जानें। आप कोड उदाहरणों के साथ Groq API और उसकी विशेषताओं के बारे में सीखेंगे। साथ ही, Groq API और LlamaIndex का उपयोग करके संदर्भ-सचेत AI एप्लिकेशन बनाना भी सीखेंगे।

आपकी .env फ़ाइल इस तरह दिखनी चाहिए:

LLAMA_CLOUD_API_KEY=llx-XXXXXX
GROQ_API_KEY=gsk_XXXXXXX
MXBAI_API_KEY=emb_XXXXXXसंचालित द्वारा

ध्यान रखें कि अपनी API कुंजियों के सार्वजनिक रूप से उजागर होने से बचने के लिए .env फ़ाइल को .gitignore में जोड़ें।

2. LLM एप्लिकेशन बनाना

अब हम app.py नाम का एक Python स्क्रिप्ट बनाएँगे और LlamaIndex के साथ LlamaParser का उपयोग करते हुए सभी AI सेवाओं को इंटीग्रेट करते हुए Retrieval-Augmented Generation (RAG) पाइपलाइन विकसित करते समय यूज़र इंटरफ़ेस कंपोनेंट्स जोड़ेंगे।

app.py स्क्रिप्ट ये काम करेगी:

1. सभी आवश्यक Python पैकेज लोड करना।
2. सुरक्षित रूप से .env फ़ाइल से सभी API कुंजियाँ लोड करना।
3. LlamaCloud API कुंजी का उपयोग करके LlamaParser को इनिशियलाइज़ करना।
4. आम फ़ाइल एक्सटेंशनों को संभालने वाला फाइल एक्स्ट्रैक्टर परिभाषित करना।
5. MixedBread AI API कुंजी का उपयोग करके, विशेष रूप से mixedbread-ai/mxbai-embed-large-v1 नाम वाले मॉडल के साथ एम्बेडिंग मॉडल को इनिशियलाइज़ करना।
6. Groq Cloud API कुंजी और llama-3.1-70b-versatile नाम वाले मॉडल का उपयोग करके बड़े भाषा मॉडल को इनिशियलाइज़ करना।

इसके बाद, यह निम्नलिखित Python फ़ंक्शंस लागू करेगी:

• load_files(): यह फ़ंक्शन फाइलें लोड करेगा, उन्हें LlamaParser से पार्स करेगा, एम्बेडिंग्स में बदलेगा, और उन्हें वेक्टर स्टोर में संग्रहीत करेगा। यदि गैर-फ़ाइलें या असमर्थित फ़ाइल फ़ॉर्मैट्स अपलोड किए जाते हैं, तो एक्सेप्शन हैंडलिंग शामिल होगी।
• respond(): यह फ़ंक्शन यूज़र इनपुट लेगा, वेक्टर स्टोर से सामग्री पुनर्प्राप्त करेगा, और Groq मॉडल का उपयोग करके प्रतिक्रिया जनरेट करेगा। प्रतिक्रिया स्ट्रीमिंग फ़ॉर्मैट में होगी, और यदि कोई फ़ाइल अपलोड नहीं की गई है तो एक्सेप्शन हैंडलिंग शामिल होगी।

अंत में, यह UI कंपोनेंट्स बनाएगी, जिनमें फाइल अपलोडर, बटन, चैट बॉक्स और समग्र चैट इंटरफ़ेस शामिल हैं।

LlamaIndex फ़्रेमवर्क के बारे में और जानने के लिए अधिक सरल LlamaIndex ट्यूटोरियल देखें।

यह रहा app.py स्क्रिप्ट:

import os

import gradio as gr
from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
from llama_index.embeddings.mixedbreadai import MixedbreadAIEmbedding
from llama_index.llms.groq import Groq
from llama_parse import LlamaParse

# API keys
llama_cloud_key = os.environ.get("LLAMA_CLOUD_API_KEY")
groq_key = os.environ.get("GROQ_API_KEY")
mxbai_key = os.environ.get("MXBAI_API_KEY")
if not (llama_cloud_key and groq_key and mxbai_key):
    raise ValueError(
        "API Keys not found! Ensure they are passed to the Docker container."
    )

# models name
llm_model_name = "llama-3.1-70b-versatile"
embed_model_name = "mixedbread-ai/mxbai-embed-large-v1"

# Initialize the parser
parser = LlamaParse(api_key=llama_cloud_key, result_type="markdown")

# Define file extractor with various common extensions
file_extractor = {
    ".pdf": parser,
    ".docx": parser,
    ".doc": parser,
    ".txt": parser,
    ".csv": parser,
    ".xlsx": parser,
    ".pptx": parser,
    ".html": parser,
    ".jpg": parser,
    ".jpeg": parser,
    ".png": parser,
    ".webp": parser,
    ".svg": parser,
}

# Initialize the embedding model
embed_model = MixedbreadAIEmbedding(api_key=mxbai_key, model_name=embed_model_name)

# Initialize the LLM
llm = Groq(model="llama-3.1-70b-versatile", api_key=groq_key)


# File processing function
def load_files(file_path: str):
    global vector_index
    if not file_path:
        return "No file path provided. Please upload a file."
   
    valid_extensions = ', '.join(file_extractor.keys())
    if not any(file_path.endswith(ext) for ext in file_extractor):
        return f"The parser can only parse the following file types: {valid_extensions}"

    document = SimpleDirectoryReader(input_files=[file_path], file_extractor=file_extractor).load_data()
    vector_index = VectorStoreIndex.from_documents(document, embed_model=embed_model)
    print(f"Parsing completed for: {file_path}")
    filename = os.path.basename(file_path)
    return f"Ready to provide responses based on: {filename}"


# Respond function
def respond(message, history):
    try:
        # Use the preloaded LLM
        query_engine = vector_index.as_query_engine(streaming=True, llm=llm)
        streaming_response = query_engine.query(message)
        partial_text = ""
        for new_text in streaming_response.response_gen:
            partial_text += new_text
            # Yield an empty string to cleanup the message textbox and the updated conversation history
            yield partial_text
    except (AttributeError, NameError):
        print("An error occurred while processing your request.")
        yield "Please upload the file to begin chat."


# Clear function
def clear_state():
    global vector_index
    vector_index = None
    return [None, None, None]


# UI Setup
with gr.Blocks(
    theme=gr.themes.Default(
        primary_hue="green",
        secondary_hue="blue",
        font=[gr.themes.GoogleFont("Poppins")],
    ),
    css="footer {visibility: hidden}",
) as demo:
    gr.Markdown("# DataCamp Doc Q&A 🤖📃")
    with gr.Row():
        with gr.Column(scale=1):
            file_input = gr.File(
                file_count="single", type="filepath", label="Upload Document"
            )
            with gr.Row():
                btn = gr.Button("Submit", variant="primary")
                clear = gr.Button("Clear")
            output = gr.Textbox(label="Status")
        with gr.Column(scale=3):
            chatbot = gr.ChatInterface(
                fn=respond,
                chatbot=gr.Chatbot(height=300),
                theme="soft",
                show_progress="full",
                textbox=gr.Textbox(
                    placeholder="Ask questions about the uploaded document!",
                    container=False,
                ),
            )

    # Set up Gradio interactions
    btn.click(fn=load_files, inputs=file_input, outputs=output)
    clear.click(
        fn=clear_state,  # Use the clear_state function
        outputs=[file_input, output],
    )

# Launch the demo
if __name__ == "__main__":
    demo.launch()संचालित द्वारा

• Gradio सर्वर शुरू करने के लिए ऊपर दी गई Python फ़ाइल को अपने टर्मिनल में निम्न कमांड से चलाएँ:

$ python app.py  संचालित द्वारा

आउटपुट:

• जनरेट हुआ URL कॉपी-पेस्ट करके आप ब्राउज़र में Gradio UI एक्सेस कर सकते हैं। फिर आप कोई फ़ाइल अपलोड कर सकते हैं और उससे जुड़े प्रश्न पूछना शुरू कर सकते हैं।

ब्राउज़र पर Gradio ऐप एक्सेस करना। चित्र: लेखक द्वारा

हम इस ट्यूटोरियल के लिए अपने LLM एप्लिकेशन को डिप्लॉय और बनाने में LlamaIndex का उपयोग करते हैं। आप Developing LLM Applications with LangChain शॉर्ट कोर्स करके LangChain के साथ एक समान एप्लिकेशन बना सकते हैं।

3. Dockerfile बनाना

• अपने प्रोजेक्ट में एक Dockerfile बनाएँ, जिससे एप्लिकेशन स्क्रिप्ट, Python निर्भरताएँ और सर्वर कॉन्फ़िगरेशन पैकेज हों, साथ ही Gradio सर्वर इनिशियलाइज़ हो सके। 

Dockerfile ये कार्य करेगा:

1. Python 3.9 वातावरण सेट करना।
2. वर्किंग डायरेक्टरी परिभाषित करना।
3. requirements.txt फ़ाइल को /app डायरेक्टरी में कॉपी करना। इसमें सभी आवश्यक Python पैकेजों के नाम होते हैं।
4. requirements.txt में बताई गई सभी निर्भरताएँ इंस्टॉल करना।
5. app.py फ़ाइल को /app डायरेक्टरी में कॉपी करना।
6. पोर्ट एक्सपोज़ करना और Gradio सर्वर URL सेट करना।
7. सर्वर शुरू करने के लिए एप्लिकेशन फ़ाइल चलाना।

आपका Dockerfile इस तरह दिखना चाहिए:

# Dockerfile

# Use the official Python image with the desired version
FROM python:3.9-slim

# Set the working directory inside the container
WORKDIR /app

# Copy the requirements file to the working directory
COPY requirements.txt /app

# Install the dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the application code to the working directory
COPY app.py /app

# Expose the port that Gradio will run on (default is 7860)
EXPOSE 7860

ENV GRADIO_SERVER_NAME="0.0.0.0"

# Command to run your application
CMD ["python", "app.py"]संचालित द्वारा

• और requirements.txt फ़ाइल इस प्रकार दिखती है। इसे भी अपने प्रोजेक्ट में जोड़ें:

gradio
llama-index-embeddings-mixedbreadai
llama-index-llms-groq
llama-indexसंचालित द्वारा

4. Docker इमेज बनाना और कंटेनर चलाना

• docqa docker इमेज बनाने के लिए टर्मिनल में निम्न कमांड टाइप करें। यह Docker इमेज बनाने के लिए Dockerfile का उपयोग करेगी।

$ docker build -t docqa . संचालित द्वारा

Docker इमेज बनाते समय होने वाली प्रक्रियाओं के लॉग्स हम देख सकते हैं:

LLM Docker इमेज बनाना। चित्र: लेखक द्वारा

• इमेज सफलतापूर्वक बन जाने पर Docker Desktop में जाएँ, Images टैब पर क्लिक करें, और लॉग्स तथा इमेज रन करने के विभिन्न निर्देश देखने के लिए Docker इमेज पर क्लिक करें। 

Docker Desktop पर Docker इमेज देखना। चित्र: लेखक द्वारा

अब हम इमेज का उपयोग करके लोकल रूप से Docker कंटेनर चलाएँगे। हम पोर्ट नंबर, वातावरण चर सेट करने के लिए .env फ़ाइल, Docker कंटेनर का नाम, और Docker इमेज टैग प्रदान करेंगे।

• टर्मिनल में निम्न कमांड चलाएँ: 

$ docker run -p 7860:7860 --env-file .env --name docqa-container docqaसंचालित द्वारा

कंटेनर शुरू होते ही, आप ब्राउज़र में इस URL, जैसे http://0.0.0.1:7860/ पेस्ट करके Gradio ऐप एक्सेस कर सकते हैं। 

Docker कंटेनर LLM एप्लिकेशन का परीक्षण। चित्र: लेखक द्वारा

• लोकल रूप से चल रहे सभी कंटेनरों की जानकारी देखने के लिए यह कमांड टाइप करें:

$ docker psसंचालित द्वारा

आउटपुट:

CONTAINER ID   IMAGE     COMMAND           CREATED          STATUS          PORTS                    NAMES
ff2a11da13d7   docqa     "python app.py"   17 seconds ago   Up 16 seconds   0.0.0.0:7860->7860/tcp   docqa-containerसंचालित द्वारा

• आप stop कमांड का उपयोग करके Docker कंटेनर को रोक सकते हैं:

$ docker stop docqa-container संचालित द्वारा

• आप rm कमांड से इसे हटा भी सकते हैं:

$ docker rm docqa-container संचालित द्वारा

एक बार हमारे पास Docker इमेज हो, तो हम अपने LLM एप्लिकेशन को कहीं भी डिप्लॉय कर सकते हैं: GCP, AWS, Azure, या कोई भी क्लाउड सर्वर जो Docker डिप्लॉयमेंट को सपोर्ट करता हो।

5. Docker का उपयोग करके Hugging Face पर LLM एप्लिकेशन डिप्लॉय करना

शुरुआती लोगों के लिए चीज़ों को सरल बनाने हेतु, हम Hugging Face Cloud (Spaces) पर Docker का प्रयोग करके ऐप डिप्लॉय करेंगे। 

• Hugging Face डैशबोर्ड पर जाएँ, प्रोफ़ाइल इमेज पर क्लिक करें, और + New Space चुनें।
• अपने Space को नाम दें, छोटा विवरण जोड़ें, लाइसेंस और SDK चुनें, और Space रिपॉज़िटरी बनाएं।

Docker का उपयोग करके नया Hugging Face Space बनाना। चित्र स्रोत: Hugging Face

Space रिपॉज़िटरी बन जाने के बाद, आपको इसे क्लोन करने और आवश्यक फ़ाइलें जोड़ने के निर्देश मिलेंगे।

• रिपॉज़िटरी क्लोन करने के लिए, निम्न कमांड का उपयोग करें (URL को अपने Space के अनुसार अपडेट करें):

$ git clone https://huggingface.co/spaces/kingabzpro/doc-qa-dockerसंचालित द्वारा

• प्रोजेक्ट डायरेक्टरी से सभी फ़ाइलें कॉपी-पेस्ट करके नई रिपॉज़िटरी में डालें:

सभी फ़ाइलों के साथ आपका प्रोजेक्ट डायरेक्टरी इस प्रकार दिखना चाहिए। सुनिश्चित करें कि आप .env फ़ाइल को पुश न करें, इसलिए उसे .gitignore में जोड़ें। 

प्रोजेक्ट फ़ाइल संरचना। चित्र: लेखक द्वारा

• फ़ाइलों को स्टेज करें, संदेश के साथ कमिट करें, और फिर उसे Hugging Face Space पर पुश करें:

$ git add .                                                                                            
$ git commit -m "Deploying the App" 
$ git pushसंचालित द्वारा

आउटपुट:

Enumerating objects: 8, done.
Counting objects: 100% (8/8), done.
Delta compression using up to 16 threads
Compressing objects: 100% (7/7), done.
Writing objects: 100% (7/7), 7.60 KiB | 7.60 MiB/s, done.
Total 7 (delta 0), reused 0 (delta 0), pack-reused 0 (from 0)
To https://huggingface.co/spaces/kingabzpro/doc-qa-docker
   afb20ad..5ca6388  main -> mainसंचालित द्वारा

• अपना Hugging Face Space खोलें और एप्लिकेशन एक्सेस करें। यह Docker इमेज बनाएगा और फिर एप्लिकेशन सर्व करेगा:

Hugging Face Cloud में Docker इमेज बन रही है। चित्र स्रोत: Doc Qa Docker

यदि आपको नीचे जैसी त्रुटि दिखाई दे, तो चिंता न करें। यह गायब वातावरण चर के कारण है। हमें बस Hugging Face Space में वे वैरिएबल्स सेट करने हैं।

डिप्लॉय किए गए ऐप पर रनटाइम त्रुटि। चित्र स्रोत: Doc Qa Docker

• अपने Space में नया वातावरण चर जोड़ने के लिए Settings पर जाएँ, नीचे स्क्रॉल करें, और New secret बटन क्लिक करें। फिर नीचे दिखाए अनुसार वातावरण चर के लिए नाम और मान दें। इस मामले में, हम आवश्यक API कुंजियाँ जोड़ रहे हैं:

डिप्लॉय किए गए ऐप में सीक्रेट्स जोड़ना। चित्र स्रोत: Doc Qa Docker settings.

सभी आवश्यक API कुंजियों को वातावरण चर के रूप में जोड़ने के बाद आपके सीक्रेट्स इस तरह दिखने चाहिए:

डिप्लॉय किए गए ऐप के सीक्रेट्स। चित्र स्रोत: Doc Qa Docker settings.

सीक्रेट्स सेट करने के बाद, ऐप स्वतः रीस्टार्ट होगा और आपको ऐप चलता हुआ दिखना चाहिए। क्लाउड पर अपने डॉक्यूमेंट Q&A एप्लिकेशन का उपयोग करें और आनंद लें!

Hugging Face Spaces पर LLM ऐप। चित्र स्रोत: Doc Qa Docker

परिणाम पुनरुत्पादित करने के लिए, सभी फ़ाइलें और कॉन्फ़िगरेशन GitHub रिपॉज़िटरी में उपलब्ध हैं: kingabzpro/Deploy-Doc-QA.

6. डिप्लॉय किए गए एप्लिकेशन की मॉनिटरिंग

AI सेवाओं का उपयोग करने के फायदे हैं: आपको कोई सेवा डिप्लॉय या प्रबंधित नहीं करनी पड़ती, उच्च थ्रूपुट मिलता है, और लॉग्स वाला डैशबोर्ड मिलता है। 

आपका LlamaCloud डैशबोर्ड पार्स किए गए सभी डॉक्यूमेंट्स को लॉग करता है। आप हिस्ट्री या अनुरोध और उपयोग की तुलना देख सकते हैं। 

Llama Cloud डैशबोर्ड। चित्र स्रोत: LlamaCloud 

इसी तरह, आप एम्बेडिंग मॉडल के लिए उपयोग किए गए टोकनों की संख्या और जनरेट किए गए अनुरोधों की संख्या भी देख सकते हैं। 

Mixedbread डैशबोर्ड। चित्र स्रोत: Mixedbread

प्रत्येक API के सबसे विस्तृत लॉग GroqCloud पर मिलते हैं, जिनमें विलंबता, टोकनों की संख्या, AI कुंजी, और सिस्टम डिबगिंग के लिए अनुरोध ID की जानकारी होती है।

GroqCloud लॉग्स। चित्र स्रोत: GroqCloud

अंतिम विचार

इस गाइड ने हमें सिखाया कि कम संसाधन उपयोग और कम्प्यूटेशनल ओवरहेड के साथ एक कुशल डॉक्यूमेंट Q&A एप्लिकेशन बनाने के लिए कई सेवाओं को कैसे संयोजित किया जाए। जिन सभी सेवाओं और टूल्स का हमने उपयोग किया है, वे मुफ़्त में उपलब्ध हैं ताकि आप अपना स्वयं का एप्लिकेशन टेस्ट और बना सकें।

हमने तैयार-शुदा कई AI सेवाओं का उपयोग करके अपनी Docker इमेज का आकार 600MB तक घटा दिया है। यदि हम सब कुछ स्वयं डिप्लॉय करते, तो इमेज का आकार लगभग 20GB या उससे अधिक होता। 

मैं आपकी सीखने की अगली चरण के रूप में LLMOps Concepts: From Ideation to Deployment कोर्स करने की सिफारिश करता/करती हूँ। यह कोर्स आपको LLM विकास जीवनचक्र और एप्लिकेशन डिप्लॉयमेंट की चुनौतियों के बारे में समझ देगा। यह आपको इन अवधारणाओं को प्रभावी ढंग से लागू करना भी सिखाएगा।