Gradio और EasyOCR के साथ DeepSeek R1 डेमो प्रोजेक्ट

इस हैंड्स-ऑन गाइड में, मैं DeepSeek-R1 मॉडल का उपयोग करके EasyOCR और Gradio के साथ एकीकृत गणित पहेली सॉल्वर असिस्टेंट बनाऊंगा।

मैं चरण-दर-चरण समझाऊंगा कि DeepSeek R1 मॉडल की उत्कृष्ट तर्क-क्षमता का उपयोग करते हुए कैसे एक ऐसा फंक्शनल वेब ऐप बनाएँ जो तरह-तरह की गणितीय पहेलियाँ हल कर सके और उपयोगी समाधान जेनरेट कर सके।

यदि आप केवल DeepSeek-R1 का एक ओवरव्यू देखना चाहते हैं, तो यह DeepSeek-R1 ओवरव्यू देखें। मॉडल को फाइन-ट्यून करने के लिए, इस ट्यूटोरियल की सिफारिश करता/करती हूँ: DeepSeek-R1 को फाइन-ट्यून करना।

DeepSeek-R1 डेमो प्रोजेक्ट: ओवरव्यू

हमारा पहेली सॉल्वर असिस्टेंट बनाने के लिए, हम निम्नलिखित चरणों से गुजरेंगे:

• आवश्यक प्री-रिक्विज़िट्स सेटअप करना।
• ऑप्टिमाइज़्ड कॉन्फ़िगरेशन के साथ मॉडल इनिशियलाइज़ करना।
• मॉडल की instruct क्षमताओं का उपयोग करते हुए कोर फ़ंक्शनैलिटी परिभाषित करना।
• आसान इंटरैक्शन के लिए घटकों को उपयोगकर्ता-अनुकूल Gradio इंटरफ़ेस में इंटीग्रेट करना।

चरण 1: प्री-रिक्विज़िट्स

इम्प्लीमेंटेशन शुरू करने से पहले, सुनिश्चित करें कि निम्नलिखित टूल्स और लाइब्रेरीज़ इंस्टॉल हैं:

• Python 3.8+
• PyTorch: डीप लर्निंग मॉडल को कुशलतापूर्वक हैंडल करने के लिए।
• EasyOCR: इमेज से टेक्स्ट निकालने के लिए एक Python मॉड्यूल।
• Gradio: उपयोगकर्ता-अनुकूल वेब इंटरफ़ेस बनाने के लिए।

आवश्यक डिपेंडेंसीज़ इंस्टॉल करने के लिए निम्नलिखित कमांड चलाएँ:

!pip install torch gradio pillow easyocr -qसंचालित द्वारा

उपरोक्त डिपेंडेंसीज़ इंस्टॉल हो जाने के बाद, ये इम्पोर्ट कमांड चलाएँ:

Import torch
from PIL import Image
import easyocr
import requests
import json
import gradio as grसंचालित द्वारा

चरण 2: DeepSeek-R1 API सेट करना

निम्नलिखित स्क्रिप्ट यह दर्शाती है कि उपयोगकर्ता प्रॉम्प्ट्स के आधार पर रिस्पॉन्स प्राप्त करने के लिए DeepSeek API से कैसे इंटरेक्ट किया जाए। ध्यान दें कि DeepSeek का API OpenAI के फ़ॉर्मेट के अनुकूल है और API रिक्वेस्ट्स के लिए एक बेस URL का उपयोग करता है।

आप या तो सीधे API कुंजी पास कर सकते हैं (गोपनीयता कारणों से अनुशंसित नहीं), या यदि आप मेरी तरह Google Colab का उपयोग कर रहे हैं, तो Secrets फीचर का उपयोग करके API कुंजी सेव कर सकते हैं। वैकल्पिक रूप से, आप environment variables का उपयोग कर सकते हैं।

# DeepSeek API configuration
DEEPSEEK_API_URL = "https://api.deepseek.com/v1/chat/completions"

# If you're using Colab and storing your key in the Secrets tab:
from google.colab import userdata
API_KEY = userdata.get('SECRET_KEY')

# If you are running this code elsewhere then, replace 'YOUR_API_KEY' with your actual DeepSeek API key. Uncomment the following line of code.
#API_KEY = 'YOUR_API_KEY' संचालित द्वारा

इस लेख के प्रकाशन के समय, DeepSeek की सेवाएँ भारी लोड में हैं और उनका प्रदर्शन घटा हुआ है—मुझे भी इस प्रोजेक्ट के लिए कोड चलाने में काफी कठिनाइयाँ आईं। कृपया इस प्रोजेक्ट का कोड चलाने का प्रयास करने से पहले DeepSeek की स्टेटस पेज अवश्य जाँचें।

चरण 3: कोर फीचर डिज़ाइन करना

अब API सेट हो गया है, हम कोड फीचर्स पर काम कर सकते हैं। इस खंड में, हम एक लॉजिक पज़ल वाली इमेज प्रोसेस करेंगे, OCR का उपयोग करके पज़ल टेक्स्ट निकालेंगे, टेक्स्ट को परिष्कृत करेंगे, और हल करने के लिए उसे DeepSeek API को भेजेंगे। पहले कोड देखते हैं, फिर मैं इसे समझाऊंगा/समझाऊंगी।

reader = easyocr.Reader(['en'])

def solve_puzzle(image):
    """Extracts the puzzle from the image and sends it to DeepSeek for solving."""
    try:
        # 1. Save the uploaded image temporarily; EasyOCR uses file paths
        image_path = "uploaded_image.png"
        image.save(image_path)

        # 2. Extract text from the image using EasyOCR
        results = reader.readtext(image_path)
        extracted_text = " ".join([res[1] for res in results])

        # Standardize the text to avoid misinterpretation of "??" as "2?"
        extracted_text = extracted_text.replace('??', '?')
      
        if "?" not in extracted_text:
            extracted_text += "?"

        print("Extracted Text:", extracted_text)  # Debugging output

        # 3. Refine the extracted text to standardize expressions
        refined_text = extracted_text.replace('x', '*').replace('X', '*').replace('=', ' = ').strip()
        print("Refined Text:", refined_text)  # Debugging output

        # 4. Compose the user message with concise instructions
        puzzle_prompt = (
            f"You are an AI specialized in solving puzzles. Analyze the following, identify hidden patterns or rules, and provide the missing value with step-by-step reasoning in text format. Do not return an answer in Latex."
            f"\nPuzzle:\n{refined_text}\n"
            "Format your response strictly as follows:\n"
            "1. **Given Equation**:\n   - (original equations)\n"
            "2. **Pattern Identified**:\n   (explain the hidden logic)\n"
            "3. **Step-by-step Calculation**:\n   - For (input values):\n     (calculation and result)\n"
            "4. **Final Answer**:\n     (Answer = X)"
        )

        messages = [
            {"role": "user", "content": puzzle_prompt}
        ]

        # 5. Optimized API request for faster response
        data = {
            "model": "deepseek-reasoner",
            "messages": messages,
            "temperature": 0,  
            "max_tokens": 100  
        }

        headers = {
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        }

        # 6. Send the request to DeepSeek with a timeout
        response = requests.post(DEEPSEEK_API_URL, headers=headers, json=data, timeout=15)

        # 7. Check the result
        if response.status_code == 200:
            try:
                json_resp = response.json()
                return json_resp.get("choices", [{}])[0].get("message", {}).get("content", "Error: No response content.").strip()
            except json.JSONDecodeError:
                return "Error: Invalid JSON response from DeepSeek API."
        else:
            return f"Error: DeepSeek API failed with status code {response.status_code}, Response: {response.text}"
    except requests.exceptions.Timeout:
        return "Error: DeepSeek API request timed out. Please try again."
    except Exception as e:
        return f"Error: {str(e)}"संचालित द्वारा

फ़ंक्शन solve_puzzle() एक लॉजिक पज़ल वाली इमेज को प्रोसेस करता है और OCR तथा R1 मॉडल की मदद से उसे हल करता है। यह इन चरणों का पालन करता है:

1. EasyOCR इनिशियलाइज़ करना: हम EasyOCR रीडर को अंग्रेज़ी में इनिशियलाइज़ करते हैं।
2. इमेज प्रोसेसिंग: अपलोड की गई इमेज को अस्थायी रूप से सेव किया जाता है और टेक्स्ट निकालने के लिए EasyOCR से प्रोसेस किया जाता है।
3. टेक्स्ट परिष्करण: निकाले गए टेक्स्ट को मानकीकृत किया जाता है ताकि एकरूपता और सटीकता बनी रहे।
4. क्वेरी कंपोज़िशन: परिष्कृत पज़ल टेक्स्ट और समाधान के लिए विशिष्ट निर्देशों सहित एक संरचित क्वेरी बनाई जाती है।
5. API इंटरेक्शन: क्वेरी DeepSeek API को भेजी जाती है, जो पज़ल का विश्लेषण करके उसे हल करता है। DeepSeek-R1 उपयोग करने के लिए deepseek-reasoner मॉडल का उपयोग करें। यदि आप DeepSeek-V3 का उपयोग करना चाहते हैं, तो deepseek-chat का उपयोग करें। और हमेशा प्राइसिंग के प्रति सजग रहें, सबसे ताज़ा जानकारी के लिए प्राइसिंग पेज देखें।
6. रिस्पॉन्स हैंडलिंग: API रिस्पॉन्स को प्रोसेस करके समाधान या उपयुक्त त्रुटि संदेश लौटाए जाते हैं।
7. एरर हैंडलिंग: यह फ़ंक्शन टाइमआउट या अप्रत्याशित अपवाद जैसी समस्याओं को भी संभालता है, जिससे मज़बूत संचालन सुनिश्चित होता है।

यह पाइपलाइन टेक्स्ट एक्सट्रैक्शन के लिए OCR और बुद्धिमत्तापूर्ण पज़ल-सॉल्विंग के लिए DeepSeek API को संयोजित करती है।

चरण 4: Gradio इंटरफ़ेस बनाना

Gradio हमें अपने एप्लिकेशन के लिए एक इंटरएक्टिव वेब इंटरफ़ेस बनाने की अनुमति देता है। निम्नलिखित कोड स्निपेट solve_puzzle() फ़ंक्शन के लिए एक उपयोगकर्ता-अनुकूल Gradio वेब इंटरफ़ेस बनाता है। Gradio इंटरफ़ेस उपयोगकर्ता के इनपुट लेता है और उन्हें वैलिडेशन के लिए मॉडल को पास करता है।

interface = gr.Interface(
    fn=solve_puzzle,
    inputs=gr.Image(type="pil"),
    outputs="text",
    title="Logic Puzzle Solver with EasyOCR & DeepSeek",
    description="Upload an image of a logic puzzle, and the model will solve it for you."
)
interface.launch(debug=True)संचालित द्वारा

उपरोक्त सेटअप में तीन कॉम्पोनेन्ट शामिल हैं:

• इनपुट: एक gr.Image कॉम्पोनेन्ट जहाँ उपयोगकर्ता अपनी इमेज अपलोड कर सकते हैं।
• आउटपुट: DeepSeek-R1 से प्राप्त उत्तर दिखाने के लिए एक text कॉम्पोनेन्ट।
• इंटरफ़ेस: gr.Interface() फ़ंक्शन इनपुट और आउटपुट को जोड़ता है और उपयोगकर्ता इंटरैक्शन के लिए एक वेब ऐप लॉन्च करता है।

चरण 5: ऐप का परीक्षण करें

आइए एक ऐसी पहेली के साथ अपने ऐप का परीक्षण करें जिसमें गणित और तर्क दोनों शामिल हों।

यदि आप पहली पंक्ति देखें, तो 1 + 4 = 5 है, और आप कह सकते हैं कि यह सरल जोड़ है। लेकिन दूसरी पंक्ति में 2 + 5 = 12 है, और फिर 3 + 6 = 21। क्या आप पैटर्न समझकर 8 + 11 = ? हल कर सकते हैं?

यदि आप Gradio इंटरफ़ेस के दाएँ भाग को देखें, तो आपको दिखेगा कि Puzzle Solver ऐप ने पैटर्न पहचान लिया है:

निष्कर्ष

इस ट्यूटोरियल में, हमने DeepSeek R1, OCR और Gradio को मिलाकर एक गणित पहेली सॉल्वर असिस्टेंट बनाया। AI में नवीनतम जानकारी से अपडेट रहने के लिए, मैं ये ब्लॉग्स सुझाता/सुझाती हूँ:

• Qwen 2.5-Max
• DeepSeek का Janus-Pro
• DeepSeek Janus-Pro को लोकली कैसे उपयोग करें