एआई के साथ ब्लॉग लेखों के अनुवाद में क्रांति

Jls -

इस लेख में, मैं एक पीओसी (प्रूफ़ ऑफ़ कॉन्सेप्ट) के रूप में एक पाइथन स्क्रिप्ट साझा कर रहा हूँ, जो ओपनएआई के GPT-4 भाषा मॉडल का उपयोग करके मेरे ब्लॉग पोस्टों के अनुवाद को स्वचालित करने के लिए विकसित की गई है। यह स्क्रिप्ट विशेष रूप से मेरे ह्यूगो ब्लॉग की संरचना में मार्कडाउन फाइलों को प्रोसेस करने के लिए डिज़ाइन की गई है, जिससे मेरे लेखों की बहुभाषी प्रबंधन में सुविधा हो। वे अंग्रेजी, स्पेनिश और चीनी में उपलब्ध हैं।

परियोजना की शुरुआत: मेरे ब्लॉग के लिए एआई और ऑटोमेशन का समामेलन

मेरे ब्लॉग लेखों के अनुवाद को स्वचालित करने की इस परियोजना की शुरुआत मेरी बढ़ती हुई कृत्रिम बुद्धिमत्ता (एआई) के प्रति आकर्षण से हुई थी। OpenAI GPT-4 और Mistral AI APIs के साथ अपनी प्रारंभिक अनभवों से प्रेरित होकर, इन तकनीकों को एक व्यावहारिक परियोजना में साकार करने के विचार ने मुझे आकर्षित किया, जो मेरे ब्लॉग को एक ठोस मूल्य प्रदान करेगा। यह केवल एआई उपकरणों को समझने की खोज नहीं थी, बल्कि ऑटोमेशन और इनोवेशन को मिलाकर मेरे डिजिटल स्पेस को समृद्ध करने की इच्छा भी थी।

यह परियोजना एक यात्रा में बदल गई जहां एआई केवल लेखन का एक विषय नहीं था, बल्कि विकास में एक सक्रिय साझेदार था। एआई के साथ अपने लेखों का सरल और प्रभावी तरीके से अनुवाद करने के विचार ने, उसकी ऑटोमेशन क्षमता का अन्वेषण करते हुए, आकर्षक संभावनाएँ खोलीं। यह भाषाई बाधाओं को पार करने का एक अवसर था, जिससे मेरी सामग्री को अधिक व्यापक दर्शकों के लिए सुलभ बनाया जा सके, जबकि कृत्रिम बुद्धिमत्ता के लगातार विकसित हो रहे क्षेत्र में नेविगेट करते हुए।

चुनौती

मुख्य चुनौती एक ऐसी स्क्रिप्ट बनाने की थी जो सटीकता के साथ अनुवाद कर सके और लेखों की मूल फॉर्मेटिंग को बनाए रख सके, विशेषकर कोड ब्लॉकों, लिंक्स और छवियों को। एक और चुनौती यह सुनिश्चित करना था कि स्क्रिप्ट विभिन्न भाषाओं का समर्थन करने के लिए आसानी से अनुकूलित की जा सके। इसे इस संरचना को भी ध्यान में रखना था:

├── content
│   ├── about
│   │   └── a-propos-du-blog-jls42.md
│   ├── mentions
│   │   └── mentions-legales.md
│   ├── posts
│   │   ├── blog
│   │   │   └── nouveau-theme-logo.md
│   │   ├── ia
│   │   │   ├── poc-mistral-ai-mixtral.md
│   │   │   ├── poc-openai-api-gpt4.md
│   │   │   └── stable-difusion-aws-ec2.md
│   │   ├── infrastructure
│   │   │   └── infrastruture-as-code-serverless-ha-jls42-org.md
│   │   └── raspberry-pi
│   │       ├── glusterfs_distribue_replique_sur_raspberry_pi_via_ansible.md
│   │       ├── initialisation-auto-de-raspbian-sur-raspberry-pi.md
│   │       ├── installation-de-docker-sur-raspberry-pi-via-ansible.md
│   │       └── installation-de-kubernetes-sur-raspberry-pi-via-ansible.md

समाधान: एक अभिनव स्क्रिप्ट

मैंने एक पाइथन स्क्रिप्ट डिज़ाइन की, जो गैर-पाठ्यात्मक तत्वों को संरक्षित रखते हुए टेक्स्ट का अनुवाद करने के लिए OpenAI GPT-4 API पर निर्भर है। प्रोसेसिंग नियमों की एक श्रृंखला और प्लेसहोल्डर के उपयोग के माध्यम से, स्क्रिप्ट कोड ब्लॉकों और अन्य अनुवाद-गैर-अनुवादनीय तत्वों की पहचान कर सकते हैं और उन्हें बाहर निकाल सकते हैं, इस प्रकार मूल सामग्री के प्रति निष्ठा बनाए रखते हैं।

प्रमुख विशेषताएं

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

स्क्रिप्ट कोड

कोड यहां भी उपलब्ध है: AI-Powered Markdown Translator

#!/usr/bin/env python3

import os
import argparse
import time
from openai import OpenAI
import re

# Initialisation de la configuration avec les valeurs par défaut
DEFAULT_API_KEY = 'votre-clé-api-par-défaut'
DEFAULT_MODEL = "gpt-4-1106-preview"
DEFAULT_SOURCE_LANG = 'fr'
DEFAULT_TARGET_LANG = 'en'
DEFAULT_SOURCE_DIR = 'content/posts'
DEFAULT_TARGET_DIR = 'traductions_en'

MODEL_TOKEN_LIMITS = {
    "gpt-4-1106-preview": 4096,
    "gpt-4-vision-preview": 4096,
    "gpt-4": 8192,
    "gpt-4-32k": 32768,
    "gpt-4-0613": 8192,
    "gpt-4-32k-0613": 32768
}

# Fonction de traduction
def translate_with_openai(text, client, args):
    """
    Traduit le texte donné du langage source au langage cible en utilisant l'API OpenAI.
    
    Args:
        text (str) : Le texte à traduire.
        client : L'objet client OpenAI.
        args : Les arguments contenant les informations sur le langage source, le langage cible et le modèle.
        
    Returns:
        str : Le texte traduit.
    """
    # Détecter et stocker les blocs de code
    code_blocks = re.findall(r'(^```[a-zA-Z]*\n.*?\n^```)', text, flags=re.MULTILINE | re.DOTALL)
    placeholders = [f"#CODEBLOCK{index}#" for index, _ in enumerate(code_blocks)]
    
    # Remplacer les blocs de code par des placeholders
    for placeholder, code_block in zip(placeholders, code_blocks):
        text = text.replace(code_block, placeholder)
    
    # Création du message pour l'API
    messages = [
        {"role": "system", "content": f"Translate the following text from {args.source_lang} to {args.target_lang}, ensuring that elements such as URLs, image paths, and code blocks (delimited by ```) are not translated. Leave these elements unchanged."},
        {"role": "user", "content": text}
    ]
    
    # Envoi de la demande de traduction
    response = client.chat.completions.create(
        model=args.model,
        messages=messages
    )
    
    # Obtenir le texte traduit et remplacer les placeholders par les blocs de code originaux
    translated_text = response.choices[0].message.content.strip()
    for placeholder, code_block in zip(placeholders, code_blocks):
        translated_text = translated_text.replace(placeholder, code_block)

    return translated_text

def add_translation_note(client, args):
    """
    Ajoute une note de traduction à un document.

    Args:
        client : Le client de traduction.
        args : Arguments supplémentaires.

    Returns:
        La note de traduction formatée.
    """
    # Note de traduction en français
    translation_note_fr = "Ce document a été traduit de la version française du blog par le modèle "
    # Traduire la note en langue cible
    translated_note = translate_with_openai(translation_note_fr + args.model, client, args)
    # Formatage de la note de traduction
    return f"\n\n**{translated_note}**\n\n"

# Traitement des fichiers Markdown
def translate_markdown_file(file_path, output_path, client, args):
    """
    Traduit le contenu d'un fichier markdown en utilisant l'API de traduction OpenAI et écrit le contenu traduit dans un nouveau fichier.

    Args:
        file_path (str): Chemin vers le fichier markdown d'entrée.
        output_path (str): Chemin vers le fichier de sortie où le contenu traduit sera écrit.
        client: Client de traduction OpenAI.
        args: Arguments supplémentaires pour le processus de traduction.

    Returns:
        None
    """
    print(f"Traitement du fichier : {file_path}")
    start_time = time.time()

    with open(file_path, 'r', encoding='utf-8') as f:
        content = f.read()

    translated_content = translate_with_openai(content, client, args)
    
    # Ajouter la note de traduction à la fin du contenu traduit
    translation_note = add_translation_note(client, args)
    translated_content_with_note = translated_content + translation_note

    with open(output_path, 'w', encoding='utf-8') as f:
        f.write(translated_content_with_note)

    end_time = time.time()
    print(f"Traduction terminée en {end_time - start_time:.2f} secondes.")

def translate_directory(input_dir, output_dir, client, args):
    """
    Traduit tous les fichiers markdown dans le répertoire d'entrée et ses sous-répertoires.

    Args:
        input_dir (str): Chemin vers le répertoire d'entrée.
        output_dir (str): Chemin vers le répertoire de sortie.
        client: Objet client de traduction.
        args: Arguments supplémentaires pour la traduction.

    Returns:
        None
    """
    for root, dirs, files in os.walk(input_dir, topdown=True):
        # Exclure les dossiers qui commencent par "traductions_"
        dirs[:] = [d for d in dirs if not d.startswith("traductions_")]

        for file in files:
            if file.endswith('.md'):
                file_path = os.path.join(root, file)
                base, _ = os.path.splitext(file)
                # Ajouter le nom du modèle utilisé dans le nom du fichier de sortie
                output_file = f"{base}-{args.model}-{args.target_lang}.md"
                relative_path = os.path.relpath(root, input_dir)
                output_path = os.path.join(output_dir, relative_path, output_file)

                os.makedirs(os.path.dirname(output_path), exist_ok=True)

                if not os.path.exists(output_path):
                    translate_markdown_file(file_path, output_path, client, args)
                    print(f"Fichier '{file}' traité.")


def main():
    """
    Fonction principale pour traduire les fichiers Markdown.

    Args:
        --source_dir (str): Répertoire source contenant les fichiers Markdown.
        --target_dir (str): Répertoire cible pour sauvegarder les traductions.
        --model (str): Modèle GPT à utiliser.
        --target_lang (str): Langue cible pour la traduction.
        --source_lang (str): Langue source pour la traduction.
    """
    parser = argparse.ArgumentParser(description="Traduit les fichiers Markdown.")
    parser.add_argument('--source_dir', type=str, default=DEFAULT_SOURCE_DIR, help='Répertoire source contenant les fichiers Markdown')
    parser.add_argument('--target_dir', type=str, default=DEFAULT_TARGET_DIR, help='Répertoire cible pour sauvegarder les traductions')
    parser.add_argument('--model', type=str, default=DEFAULT_MODEL, help='Modèle GPT à utiliser')
    parser.add_argument('--target_lang', type=str, default=DEFAULT_TARGET_LANG, help='Langue cible pour la traduction')
    parser.add_argument('--source_lang', type=str, default=DEFAULT_SOURCE_LANG, help='Langue source pour la traduction')

    args = parser.parse_args()

    openai_api_key = os.getenv('OPENAI_API_KEY', DEFAULT_API_KEY)
    with OpenAI(api_key=openai_api_key) as client:
        translate_directory(args.source_dir, args.target_dir, client, args)

if __name__ == "__main__":
    main()

स्क्रिप्ट पर नजर

मॉड्यूल इंपोर्ट्स

सबसे पहले, हमने कुछ आवश्यक मॉड्यूल्स को इंपोर्ट किया है, जैसे os, argparse, time और re। ये मॉड्यूल फाइल सिस्टम ऑपरेशंस, कमांड लाइन आर्गुमेंट्स का विश्लेषण, निष्पादन के समय को मापने और टेक्स्ट सर्च और रिप्लेस ऑपरेशंस करने के लिए उपयोग किए जाते हैं।

स्थिरांक

इसके बाद, हमने कुछ स्थिरांक परिभाषित किए हैं, जैसे कि DEFAULT_API_KEY, DEFAULT_MODEL, DEFAULT_SOURCE_LANG, DEFAULT_TARGET_LANG, DEFAULT_SOURCE_DIR और DEFAULT_TARGET_DIR। ये स्थिरांक स्क्रिप्ट में उपयोग किए जाने वाले डिफ़ॉल्ट मानों का प्रतिनिधित्व करते हैं, लेकिन इन्हें कमांड लाइन आर्गुमेंट्स निर्दिष्ट करके बदला जा सकता है।

फ़ंक्शन translate_with_openai

इसके बाद, हमारे पास फ़ंक्शन translate_with_openai है। यह फ़ंक्शन एक टेक्स्ट, एक OpenAI क्लाइंट ऑब्जेक्ट और आर्गुमेंट्स को पैरामीटर के रूप में लेता है। यह OpenAI API का उपयोग करके टेक्स्ट को स्रोत भाषा से लक्ष्य भाषा में अनुवाद करता है। यह कैसे काम करता है:

  1. फ़ंक्शन नियमित अभिव्यक्ति का उपयोग करके टेक्स्ट में कोड ब्लॉक्स का पता लगाने और उन्हें स्टोर करने के लिए उपयोग करता है। ये कोड ब्लॉक्स ट्रिपल बैक टिक (```) द्वारा सीमित होते हैं। कोड ब्लॉक्स को code_blocks नामक सूची में स्टोर किया जाता है।
  2. इसके बाद, फ़ंक्शन कोड ब्लॉक्स को टेक्स्ट में प्लेसहोल्डर्स से बदल देता है। प्लेसहोल्डर्स इस प्रकार की स्ट्रिंग्स होती हैं #CODEBLOCK{index}#, जहां index सूची code_blocks में संबंधित कोड ब्लॉक का इंडेक्स होता है।
  3. फ़ंक्शन OpenAI API के लिए एक संदेश बनाता है। इस संदेश में दो भाग होते हैं: एक सिस्टम संदेश जो API को निर्देशित करता है कि टेक्स्ट को स्रोत भाषा से लक्ष्य भाषा में अनुवाद करें जबकि URLs, छवि पaths और कोड ब्लॉक्स जैसे तत्वों को अपरिवर्तित छोड़ें, और एक उपयोगकर्ता संदेश जिसमें अनुवाद के लिए टेक्स्ट होता है।
  4. फ़ंक्शन OpenAI API को client.chat.completions.create() विधि का उपयोग करके अनुवाद का अनुरोध भेजता है। यह उपयोग किए जाने वाले मॉडल और अनुवादित संदेश निर्दिष्ट करता है।
  5. API का जवाब अनुवादित टेक्स्ट को शामिल करता है। फ़ंक्शन अनुवादित टेक्स्ट को पुनः प्राप्त करता है और प्लेसहोल्डर्स को मूल कोड ब्लॉक्स से बदल देता है।
  6. अंत में, फ़ंक्शन अनुवादित टेक्स्ट को वापस करता है।

फ़ंक्शन add_translation_note

इसके बाद, हमारे पास फ़ंक्शन add_translation_note है। यह फ़ंक्शन एक दस्तावेज़ में एक अनुवाद नोट जोड़ता है। यह एक OpenAI क्लाइंट ऑब्जेक्ट और आर्गुमेंट्स को पैरामीटर के रूप में लेता है। यह कैसे काम करता है:

  1. फ़ंक्शन translation_note_fr वेरिएबल का उपयोग करके एक फ्रेंच में अनुवाद नोट बनाता है।
  2. इसके बाद, फ़ंक्शन translate_with_openai फ़ंक्शन का उपयोग करके fr-चिया का अनुवाद करने के लिए OpenAI API का उपयोग करता है। translate_with_openai को पारित किए गए आर्गुमेंट्स में फ्रेंच में अनुवाद नोट और अन्य आर्गुमेंट्स शामिल हैं।
  3. फ़ंक्शन अनुवादित अनुवाद नोट को फ़ॉर्मेट करने के लिए फ़ॉर्मेटिंग वर्ण जोड़ता है।
  4. अंत में, फ़ंक्शन फ़ॉर्मेट की गई अनुवाद नोट को वापस करता है।

फ़ंक्शन translate_markdown_file

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

इस स्क्रिप्ट ने न केवल मेरे ब्लॉग आर्टिकल्स की पहुंच को बढ़ाया है, बल्कि कंटेंट निर्माण में ऑटोमेशन के लिए नई संभावनाओं का मार्ग भी खोला है। यह ज्ञान के व्यापक और समावेशी साझाकरण की ओर एक कदम है। ## उपयोगकर्ता अनुभव और प्रसंस्करण समय

उपयोग के उदाहरण

# Création des répertoires cibles
jls42@Boo:~/blog/jls42$ mkdir content/traductions_en content/traductions_es

###############################################
# Demande de traduction à l'IA vers l'anglais #
###############################################
jls42@Boo:~/blog/jls42$ python3 translate.py --source_dir content/ --target_dir content/traductions_en
Traitement du fichier : content/posts/ia/stable-difusion-aws-ec2.md
Traduction terminée en 21.57 secondes.
Fichier 'stable-difusion-aws-ec2.md' traité.
Traitement du fichier : content/posts/ia/poc-openai-api-gpt4.md
Traduction terminée en 34.87 secondes.
Fichier 'poc-openai-api-gpt4.md' traité.
Traitement du fichier : content/posts/ia/poc-mistral-ai-mixtral.md
Traduction terminée en 62.47 secondes.
Fichier 'poc-mistral-ai-mixtral.md' traité.
Traitement du fichier : content/posts/raspberry-pi/installation-de-kubernetes-sur-raspberry-pi-via-ansible.md
Traduction terminée en 46.37 secondes.
Fichier 'installation-de-kubernetes-sur-raspberry-pi-via-ansible.md' traité.
Traitement du fichier : content/posts/raspberry-pi/installation-de-docker-sur-raspberry-pi-via-ansible.md
Traduction terminée en 10.08 secondes.
Fichier 'installation-de-docker-sur-raspberry-pi-via-ansible.md' traité.
Traitement du fichier : content/posts/raspberry-pi/initialisation-auto-de-raspbian-sur-raspberry-pi.md
Traduction terminée en 17.17 secondes.
Fichier 'initialisation-auto-de-raspbian-sur-raspberry-pi.md' traité.
Traitement du fichier : content/posts/blog/nouveau-theme-logo.md
Traduction terminée en 12.91 secondes.
Fichier 'nouveau-theme-logo.md' traité.
Traitement du fichier : content/posts/infrastructure/infrastruture-as-code-serverless-ha-jls42-org.md
Traduction terminée en 12.64 secondes.
Fichier 'infrastruture-as-code-serverless-ha-jls42-org.md' traité.
Traitement du fichier : content/mentions/mentions-legales.md
Traduction terminée en 11.90 secondes.
Fichier 'mentions-legales.md' traité.
Traitement du fichier : content/about/a-propos-du-blog-jls42.md
Traduction terminée en 18.72 secondes.
Fichier 'a-propos-du-blog-jls42.md' traité.

################################################
# Demande de traduction à l'IA vers l'espagnol #
################################################
jls42@Boo:~/blog/jls42$ python3 translate.py --source_dir content/ --target_dir content/traductions_es --target_lang es
Traitement du fichier : content/posts/ia/stable-difusion-aws-ec2.md
Traduction terminée en 33.19 secondes.
Fichier 'stable-difusion-aws-ec2.md' traité.
Traitement du fichier : content/posts/ia/poc-openai-api-gpt4.md
Traduction terminée en 25.24 secondes.
Fichier 'poc-openai-api-gpt4.md' traité.
Traitement du fichier : content/posts/ia/poc-mistral-ai-mixtral.md
Traduction terminée en 58.78 secondes.
Fichier 'poc-mistral-ai-mixtral.md' traité.
Traitement du fichier : content/posts/raspberry-pi/installation-de-kubernetes-sur-raspberry-pi-via-ansible.md
Traduction terminée en 17.64 secondes.
Fichier 'installation-de-kubernetes-sur-raspberry-pi-via-ansible.md' traité.
Traitement du fichier : content/posts/raspberry-pi/installation-de-docker-sur-raspberry-pi-via-ansible.md
Traduction terminée en 19.60 secondes.
Fichier 'installation-de-docker-sur-raspberry-pi-via-ansible.md' traité.
Traitement du fichier : content/posts/raspberry-pi/initialisation-auto-de-raspbian-sur-raspberry-pi.md
Traduction terminée en 37.12 secondes.
Fichier 'initialisation-auto-de-raspbian-sur-raspberry-pi.md' traité.
Traitement du fichier : content/posts/blog/nouveau-theme-logo.md
Traduction terminée en 18.91 secondes.
Fichier 'nouveau-theme-logo.md' traité.
Traitement du fichier : content/posts/infrastructure/infrastruture-as-code-serverless-ha-jls42-org.md
Traduction terminée en 30.73 secondes.
Fichier 'infrastruture-as-code-serverless-ha-jls42-org.md' traité.
Traitement du fichier : content/mentions/mentions-legales.md
Traduction terminée en 13.14 secondes.
Fichier 'mentions-legales.md' traité.
Traitement du fichier : content/about/a-propos-du-blog-jls42.md
Traduction terminée en 11.24 secondes.
Fichier 'a-propos-du-blog-jls42.md' traité.

प्रसंस्करण समय

  • अंग्रेज़ी : लगभग 4 मिनट (248.70 सेकंड)
  • स्पेनिश : लगभग 4.7 मिनट (284.05 सेकंड)
  • कुल योग : लगभग 8.7 मिनट (532.75 सेकंड) ये समय स्क्रिप्ट की दक्षता और तेज़ी को दर्शाते हैं।

परिणाम

आप इन अनुवादित सामग्री की पीढ़ियों के परिणामों को इन लिंक पर एक्सेस कर सकते हैं:

यह ब्लॉग पोस्ट माई एआई के साथ अनुवाद स्वचालन के अनुभव का एक सारांश है। यह एक साक्ष्य है कि, जब प्रोग्रामिंग को कृत्रिम बुद्धिमत्ता के साथ जोड़ा जाता है, तो संभावनाएं लगभग असीमित हो जाती हैं, ज्ञान साझा करने और सामग्री की पहुंच में नए और रोमांचक क्षितिज खोलते हैं।

इस दस्तावेज़ का fr संस्करण से hi भाषा में अनुवाद gpt-4o मॉडल का उपयोग करके किया गया है। अनुवाद प्रक्रिया के बारे में अधिक जानकारी के लिए, https://gitlab.com/jls42/ai-powered-markdown-translator देखें।