Aufbau einer RAG-Pipeline für Hindi-Dokumente mit indischen LLMs

Namaste! Ich komme aus Indien, wo es vier Jahreszeiten gibt: Winter, Sommer, Monsun und Herbst. Können Sie erraten, welche Staffel ich am meisten hasse? Es ist Steuersaison.

Dieses Jahr habe ich mich wie immer mühevoll darum gekümmert, verschiedene Abschnitte und Dokumente zur Einkommensteuer durchzugehen, um meine Ersparnisse zu maximieren (natürlich auf legalem Weg 😉). Ich schaute mir unzählige Movies an und wühlte mich durch Dokumente, einige auf Englisch, andere auf Hindi, in der Hoffnung, die Antworten zu finden, die ich brauchte. Aber als mir nur noch zwei Tage blieben, um die Steuererklärung einzureichen, wurde mir klar, dass ich keine Zeit hatte, alles durchzugehen. Damals wünschte ich mir, es gäbe eine schnelle Möglichkeit, Antworten zu bekommen, egal in welcher Sprache!

Obwohl RAG (Retrieval Augmented Technology) dies leisten konnte, konzentrierten sich die meisten Tutorials und Modelle nur auf englische Dokumente, sodass die nicht-englischen Dokumente weitgehend nicht unterstützt wurden. Da wurde mir klar: Ich könnte eine RAG-Pipeline aufbauen, die auf indische Inhalte zugeschnitten ist, ein RAG-System, das Fragen beantworten kann, indem es Hindi-Dokumente durchblättert. Und so begann die Reise!

Notizbuch: Wenn Sie eher ein Pocket book-Fan sind, habe ich den gesamten Code auch in ein Colab-Notizbuch hochgeladen. Du kannst Überprüfen Sie es hier. Ich empfehle, es in einer T4-GPU-Umgebung auf Colab auszuführen.

Additionally fangen wir an. Tudum!

Lernergebnisse

• Verstehen Sie, wie Sie eine Finish-to-Finish-Lösung aufbauen Retrieval-Augmented Technology (RAG)-Pipeline zur Verarbeitung von Hindi-Dokumenten.
• Lernen Sie Techniken zum Crawlen, Bereinigen und Strukturieren von Hindi-Textdaten für Webdaten NLP-Anwendungen.
• Erfahren Sie, wie Sie indische LLMs nutzen können, um RAG-Pipelines für Dokumente in indischer Sprache aufzubauen und so die Verarbeitung mehrsprachiger Dokumente zu verbessern.
• Entdecken Sie die Verwendung von Open-Supply-Modellen wie Multilingual E5 und Airavata für Einbettungen und Textgenerierung in Hindi.
• Richten Sie Chroma DB für eine effiziente Vektorspeicherung und -abfrage in RAG-Systemen ein und verwalten Sie sie.
• Sammeln Sie praktische Erfahrungen mit der Erfassung, dem Abruf und der Beantwortung von Fragen mithilfe einer RAG-Pipeline in Hindi.

Dieser Artikel wurde im Rahmen der veröffentlicht Knowledge Science-Blogathon.

Datenerfassung: Beschaffung von Hindi-Steuerinformationen

Die Reise begann mit dem Sammeln der Daten. Ich begann mit einigen Nachrichtenartikeln und Web sites zum Thema Einkommensteuerinformationen in Indien, die auf Hindi verfasst waren. Es enthält FAQs und unstrukturierten Textual content zu Steuerabzugsabschnitten, FAQs und erforderlichen Formularen. Sie können sie hier überprüfen:

urls =('https://www.incometax.gov.in/iec/foportal/hello/assist/e-filing-itr1-form-sahaj-faq',
        'https://www.incometax.gov.in/iec/foportal/hello/assist/e-filing-itr4-form-sugam-faq',
       'https://navbharattimes.indiatimes.com/enterprise/price range/budget-classroom/income-tax-sections-know-which-section-can-save-how-much-tax-here-is-all-about-income-tax-law-to-understand-budget-speech/articleshow/89141099.cms',
       'https://www.incometax.gov.in/iec/foportal/hello/assist/particular person/return-applicable-1',
       'https://www.zeebiz.com/hindi/personal-finance/income-tax/tax-deductions-under-section-80g-income-tax-exemption-limit-how-to-save-tax-on-donation-money-to-charitable-trusts-126529'
)

Bereinigen und Parsen der Daten

Die Aufbereitung der Daten umfasst die folgenden Schritte:

• Crawlen der Daten von Webseiten
• Bereinigen der Daten

Schauen wir uns jeden einzelnen einzeln an

Krabbeln

Ich werde eine meiner Lieblingsbibliotheken zum Crawlen von Web sites verwenden –Markdown-Crawler. Sie können es mit dem unten genannten Befehl installieren. Es analysiert die Web site im Markdown-Format und speichert sie in Markdown-Dateien.

!pip set up markdown-crawler
!pip set up markdownify

Eine interessante Funktion von Markdown Crawler ist seine Fähigkeit, dank seiner Tiefenparameter nicht nur die Hauptwebseiten zu crawlen, sondern auch verlinkte Seiten innerhalb der Web site zu erkunden. Dies ermöglicht ein umfassenderes Web site-Crawling. Aber in unserem Fall brauchen wir das nicht, additionally ist die Tiefe Null.

Hier ist die Funktion zum Crawlen von URLs

from markdown_crawler import md_crawl

def crawl_urls(urls: record, storage_folder_path: str, max_depth=0):
    # Iterate over every URL within the record
    for url in urls:
        print(f"Crawling {url}")  # Output the URL being crawled
        # Crawl the URL and save the outcome within the specified folder
        md_crawl(url, max_depth=max_depth, base_dir=storage_folder_path, is_links=True)

urls =('https://www.incometax.gov.in/iec/foportal/hello/assist/e-filing-itr1-form-sahaj-faq',
        'https://www.incometax.gov.in/iec/foportal/hello/assist/e-filing-itr4-form-sugam-faq',
       'https://navbharattimes.indiatimes.com/enterprise/price range/budget-classroom/income-tax-sections-know-which-section-can-save-how-much-tax-here-is-all-about-income-tax-law-to-understand-budget-speech/articleshow/89141099.cms',
       'https://www.incometax.gov.in/iec/foportal/hello/assist/particular person/return-applicable-1',
       'https://www.zeebiz.com/hindi/personal-finance/income-tax/tax-deductions-under-section-80g-income-tax-exemption-limit-how-to-save-tax-on-donation-money-to-charitable-trusts-126529'
)
crawl_urls(urls= urls, storage_folder_path="./incometax_documents/") 
#you do not want to make a folder intitially. Md Crawler handles that for you.#import csv

Dieser Code speichert die analysierten Markdown-Dateien im Ordner „incometax_documents“.

Bereinigen der Daten

Als nächstes müssen wir einen Parser erstellen, der die Markdown-Dateien liest und sie in Abschnitte unterteilt. Wenn Sie mit anderen Daten arbeiten, die bereits verarbeitet wurden, können Sie diesen Schritt überspringen.

Schreiben wir zunächst Funktionen zum Extrahieren von Inhalten aus einer Datei. Wir verwenden hierfür die Python-Bibliotheken markdown und BeautifulSoup. Nachfolgend finden Sie die Befehle zum Installieren dieser Bibliotheken:

!pip set up beautifulsoup4
!pip set up markdown#import csv

import markdown
from bs4 import BeautifulSoup

def read_markdown_file(file_path):
    """Learn a Markdown file and extract its sections as headers and content material."""
    # Open the markdown file and browse its content material
    with open(file_path, 'r', encoding='utf-8') as file:
        md_content = file.learn()
    
    # Convert markdown to HTML
    html_content = markdown.markdown(md_content)
    
    # Parse HTML content material
    soup = BeautifulSoup(html_content, 'html.parser')
    
    sections = ()
    current_section = None
    
    # Loop by means of HTML tags
    for tag in soup:
        # Begin a brand new part if a header tag is discovered
        if tag.identify and tag.identify.startswith('h'):
            if current_section:
                sections.append(current_section)
            current_section = {'header': tag.textual content, 'content material': ''}
        
        # Add content material to the present part
        elif current_section:
            current_section('content material') += tag.get_text() + 'n'

    # Add the final part
    if current_section:
        sections.append(current_section)

    return sections

#lets have a look at the output of one of many recordsdata:
sections = read_markdown_file('./incometax_documents/business-budget-budget-classroom-income-tax-sections-know-which-section-can-save-how-much-tax-here-is-all-about-income-tax-law-to-understand-budget-speech-articleshow-89141099-cms.md')

Der Inhalt sieht jetzt übersichtlicher aus, aber einige Abschnitte sind unnötig, insbesondere solche mit leeren Überschriften. Um dies zu beheben, schreiben wir eine Funktion, die einen Abschnitt nur dann übergibt, wenn sowohl die Kopfzeile als auch der Inhalt nicht leer sind und die Kopfzeile nicht in der Liste enthalten ist („Hauptnavigation“, „Navigation“, „Fußzeile“).

def pass_section(part):
    # Checklist of headers to disregard based mostly on experiments
    headers_to_ignore = ('primary navigation', 'navigation', 'footer', 'commercial') 
    
    # Test if the header shouldn't be within the ignore record and each header and content material are non-empty
    if part('header').decrease() not in headers_to_ignore and part('header').strip() and part('content material').strip():
        return True
    return False

#storing every part in handed sections 
passed_sections = ()
import os
# Iterate by means of all Markdown recordsdata within the folder
for filename in os.listdir('incometax_documents'):
    if filename.endswith('.md'):
        file_path = os.path.be a part of('incometax_documents', filename)
        # Extract sections from the present Markdown file
        sections = read_markdown_file(file_path)
        passed_sections.lengthen(sections)

Der Inhalt sieht jetzt organisiert und sauber aus! und alle Abschnitte werden in passed_sections gespeichert.

Notiz: Möglicherweise benötigen Sie eine Aufteilung basierend auf dem Inhalt, da das Token-Restrict für das Einbettungsmodell 512 beträgt. Da die Abschnitte für meinen Fall jedoch klein sind, werde ich darauf verzichten. Aber Sie können das trotzdem überprüfen Notizbuchfür Chunking-Code.

Modellauswahl: Auswahl der richtigen Einbettungs- und Generierungsmodelle

Wir werden Open Supply verwenden mehrsprachig-E5 als unser Einbettungsmodell und Airavata von ai4Bharataein indisches LLM, das eine auf Anweisungen abgestimmte Model von ist Öffnen Sie Hathiein 7B-Parametermodell von Sarvam AIch basierte auf Llama2 und trainierte Hindi, Englisch und Hinglish als Generationenmodell.

Warum habe ich mich entschieden? mehrsprachig-e5-base als Einbettungsmodell?Laut der Hugging Face-Seite unterstützt es 100 Sprachen, obwohl die Leistung für Sprachen mit geringen Ressourcen variieren kann. Ich habe festgestellt, dass es für Hindi einigermaßen intestine funktioniert. Für eine höhere Genauigkeit ist BGE M3 eine Choice, aber es ist ressourcenintensiv. OpenAI-Einbettungen könnten auch funktionieren, aber vorerst bleiben wir bei Open-Supply-Lösungen. Daher ist E5 eine leichte und effektive Wahl. Warum Airavata? Riesige LLMs wie GPT 3.5 könnten zwar den Job machen, aber sagen wir einfach, ich wollte etwas Open-Supply-Indisches ausprobieren.

Einrichten des Vector Retailer

Ich habe gewählt Chroma DB da ich es ohne Internet hosting in Google Collab verwenden könnte und es intestine zum Experimentieren geeignet ist. Sie können aber auch Vektorshops Ihrer Wahl nutzen. So installieren Sie es.

!pip set up chromadb

Anschließend können wir den chromaDb-Shopper mit den folgenden Befehlen starten

import chromadb
chroma_client = chromadb.Shopper()

Auf diese Weise wird zum Initiieren von Chroma DB eine In-Reminiscence-Instanz von Chroma erstellt. Dies ist für Exams und Entwicklung nützlich, wird jedoch für den Produktionseinsatz nicht empfohlen. Für die Produktion sollten Sie es hosten. Bitte beachten Sie dessen Dokumentation für Einzelheiten.

Als nächstes müssen wir einen Vektorspeicher erstellen. Glücklicherweise bietet Chroma DB integrierte Unterstützung für Open-Supply-Satztransformatoren. So verwenden Sie es:

from chromadb.utils import embedding_functions

#initializing embedding mannequin
sentence_transformer_ef = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="intfloat/multilingual-e5-base")

#creating a set
assortment = chroma_client.create_collection(identify="income_tax_hindi", embedding_function= sentence_transformer_ef, metadata={"hnsw:house": "cosine"})

Wir verwenden metadata={“hnsw:house“: „cosine“}, da der Standardabstand von ChromaDB euklidisch ist, der Kosinusabstand jedoch normalerweise für RAG-Zwecke bevorzugt wird.

In chromaDb können wir keine Sammlung mit demselben Namen erstellen, wenn diese bereits vorhanden ist. Während Sie additionally experimentieren, müssen Sie möglicherweise die Sammlung löschen, um sie neu zu erstellen. Hier ist der Befehl zum Löschen:

# command for deletion
chroma_client.delete_collection(identify="income_tax_hindi")

Aufnahme und Abruf von Dokumenten

Nachdem wir die Daten nun in „passed_sections“ gespeichert haben, ist es an der Zeit, diesen Inhalt in ChromaDB aufzunehmen. Wir werden auch Metadaten und IDs einbeziehen. Metadaten sind non-compulsory, aber da wir Kopfzeilen haben, behalten wir sie für zusätzlichen Kontext bei.

#ingestion paperwork 

assortment.add(
    paperwork=(part('content material') for part in passed_sections), 
    metadatas = ({'header': part('header')} for part in passed_sections),
    ids=(str(i) for _ in vary(len(passed_sections)))
)

#apparently we have to move some ids to paperwork in chroma db, therefore utilizing id

Es ist an der Zeit, beginnen wir mit der Abfrage des Vektorspeichers.

docs = assortment.question(
    query_texts=("सेक्शन 80 C की लिमिट क्या होती है"),
    n_results=3
)
print(docs)

Wie Sie sehen, verfügen wir über relevante Dokumente, die auf Kosinusabständen basieren. Versuchen wir, damit eine Antwort zu generieren. Dafür bräuchten wir ein LLM.

Antwortgenerierung mit Airavata

Wie bereits erwähnt, werden wir Airavta verwenden und da es Open Supply ist, werden wir Transformatoren und Quantisierungstechniken verwenden, um das Modell zu laden. Weitere Informationen zum Laden von Open-Supply-LLMs finden Sie hier Hier Und Hier. Für die Zusammenarbeit ist eine T4-GPU-Umgebung erforderlich.

Beginnen wir mit der Set up der relevanten Bibliotheken

!pip set up bitsandbytes>=0.39.0
!pip set up --upgrade speed up transformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig

machine = "cuda" if torch.cuda.is_available() else "cpu"
print(machine)
# it ought to print Cuda

Hier ist der Code zum Laden des quantisierten Modells.

model_name = "ai4bharat/Airavata"
tokenizer = AutoTokenizer.from_pretrained(model_name, padding_side="left")
tokenizer.pad_token = tokenizer.eos_token
quantization_config = BitsAndBytesConfig(load_in_8bit=True)
mannequin = AutoModelForCausalLM.from_pretrained(model_name,  quantization_config=quantization_config, torch_dtype=torch.bfloat16)

Das Modell wurde so optimiert, dass es den Anweisungen folgt, und es funktioniert am besten, wenn die Anweisungen dasselbe Format wie die Trainingsdaten haben. Deshalb werden wir eine Funktion schreiben, um alles in einem passenden Format zu organisieren.

Die folgenden Funktionen mögen überwältigend erscheinen, aber sie stammen aus dem Offizielle Hugging Face-Seite des Fashions. Solche Funktionen sind für die meisten Open-Supply-Modelle verfügbar. Machen Sie sich additionally keine Sorgen, wenn Sie sie nicht vollständig verstehen.

def create_prompt_with_chat_format(messages, bos="<s>", eos="</s>", add_bos=True):
    formatted_text = ""
    for message in messages:
        if message("position") == "system":
            formatted_text += "<|system|>n" + message("content material") + "n"
        elif message("position") == "person":
            formatted_text += "<|person|>n" + message("content material") + "n"
        elif message("position") == "assistant":
            formatted_text += "<|assistant|>n" + message("content material").strip() + eos + "n"
        else:
            increase ValueError(
                "Tulu chat template solely helps 'system', 'person' and 'assistant' roles. Invalid position: {}.".format(
                    message("position")
                )
            )
    formatted_text += "<|assistant|>n"
    formatted_text = bos + formatted_text if add_bos else formatted_text
    return formatted_text

Zur Schlussfolgerung verwenden wir diese Funktion

def inference(input_prompts, mannequin, tokenizer):
    input_prompts = (
        create_prompt_with_chat_format(({"position": "person", "content material": input_prompt}), add_bos=False)
        for input_prompt in input_prompts
    )

    encodings = tokenizer(input_prompts, padding=True, return_tensors="pt")
    encodings = encodings.to(machine)

    with torch.inference_mode():
        outputs = mannequin.generate(encodings.input_ids, do_sample=False, max_new_tokens=1024)

    output_texts = tokenizer.batch_decode(outputs.detach(), skip_special_tokens=True)

    input_prompts = (
        tokenizer.decode(tokenizer.encode(input_prompt), skip_special_tokens=True) for input_prompt in input_prompts
    )
    output_texts = (output_text(len(input_prompt) :) for input_prompt, output_text in zip(input_prompts, output_texts))
    return output_texts

Nun der interessante Teil: Aufforderung zur Generierung der Antwort. Hier erstellen wir eine Eingabeaufforderung, die das Sprachmodell anweist, Antworten basierend auf bestimmten Richtlinien zu generieren. Die Anweisungen sind einfach: Zuerst liest und versteht das Modell die Frage und überprüft dann den bereitgestellten Kontext. Es nutzt diese Informationen, um eine klare, prägnante und genaue Antwort zu formulieren. Wenn Sie es genau betrachten, ist dies die Hindi-Model der typischen RAG-Eingabeaufforderung.

Die Anweisungen sind auf Hindi, da das Airavta-Modell so optimiert wurde, dass es den Anweisungen in Hindi folgt. Sie können mehr über seine Ausbildung lesen Hier.

immediate=""'आप एक बड़े भाषा मॉडल हैं जो दिए गए संदर्भ के आधार पर सवालों का उत्तर देते हैं। नीचे दिए गए निर्देशों का पालन करें:

1. **प्रश्न पढ़ें**:
    - दिए गए सवाल को ध्यान से पढ़ें और समझें।

2. **संदर्भ पढ़ें**:
    - नीचे दिए गए संदर्भ को ध्यानपूर्वक पढ़ें और समझें।

3. **सूचना उत्पन्न करना**:
    - संदर्भ का उपयोग करते हुए, प्रश्न का विस्तृत और स्पष्ट उत्तर तैयार करें।
    - यह सुनिश्चित करें कि उत्तर सीधा, समझने में आसान और तथ्यों पर आधारित हो।

### उदाहरण:

**संदर्भ**:
    "नई दिल्ली भारत की राजधानी है और यह देश का प्रमुख राजनीतिक और प्रशासनिक केंद्र है। यह शहर ऐतिहासिक स्मारकों, संग्रहालयों और विविध संस्कृति के लिए जाना जाता है।"

**प्रश्न**:
    "भारत की राजधानी क्या है और यह क्यों महत्वपूर्ण है?"

**प्रत्याशित उत्तर**:
    "भारत की राजधानी नई दिल्ली है। यह देश का प्रमुख राजनीतिक और प्रशासनिक केंद्र है और ऐतिहासिक स्मारकों, संग्रहालयों और विविध संस्कृति के लिए जाना जाता है।"

### निर्देश:

अब, दिए गए संदर्भ और प्रश्न का उपयोग करके उत्तर दें:

**संदर्भ**:
{docs}

**प्रश्न**:
{question}

उत्तर:'''

Prüfung und Bewertung

Wenn man alles kombiniert, ergibt sich die Funktion:

def generate_answer(question):
  docs =  assortment.question(
    query_texts=(question),
    n_results=3
) #taking high 3 outcomes 
  docs = (doc for doc in docs('paperwork')(0))
  docs = "n".be a part of(docs)
  formatted_prompt = immediate.format(docs = docs,question = question)
  solutions = inference((formatted_prompt), mannequin, tokenizer)
  return solutions(0)

Probieren wir es mal für einige Fragen aus:

questions = (
    'सेक्शन 80डीडी के तहत विकलांग आश्रित के लिए कौन से मेडिकल खर्च पर टैक्स छूट मिल सकती है?',
    'क्या सेक्शन 80यू और सेक्शन 80डीडी का लाभ एक साथ उठाया जा सकता है?',
    'सेक्शन 80 C की लिमिट क्या होती है?'
)

for query in questions:
    reply = generate_answer(query)
    print(f"Query: {query}nAnswer: {reply}n")

#OUTPUT 

Query: सेक्शन 80डीडी के तहत विकलांग आश्रित के लिए कौन से मेडिकल खर्च पर टैक्स छूट मिल सकती है?
Reply: आश्रित के लिए टैक्स छूट उन खर्चों पर उपलब्ध है जो 40 फीसदी से अधिक विकलांगता वाले व्यक्ति के लिए आवश्यक हैं। इन खर्चों में अस्पताल में भर्ती होना, सर्जरी, दवाएं और चिकित्सा उपकरण शामिल हैं।

Query: क्या सेक्शन 80यू और सेक्शन 80डीडी का लाभ एक साथ उठाया जा सकता है?
Reply: नहीं।

Query: सेक्शन 80 C की लिमिट क्या होती है?
Reply: सेक्शन 80सी की सीमा 1.5 लाख रुपये है।

Schöne Antworten! Sie können auch mit Eingabeaufforderungen experimentieren, um detaillierte oder kurze Antworten zurückzugeben oder den Ton des Modells zu ändern. Ich würde gerne Ihre Experimente sehen. 😊

Das ist das Ende des Blogs! Ich hoffe, es hat Ihnen gefallen. In diesem Beitrag haben wir einkommenssteuerbezogene Informationen von einer Web site übernommen, sie mithilfe eines mehrsprachigen Open-Supply-Transformers in ChromaDB aufgenommen und Antworten mit einem Open-Supply-Indic-LLM generiert.

Ich battle mir etwas unsicher, welche Particulars ich einbeziehen sollte, aber ich habe versucht, es prägnant zu halten. Wenn Sie weitere Informationen wünschen, schauen Sie sich gerne mein GitHub-Repo an. Ich würde gerne Ihr Suggestions hören – ob Ihrer Meinung nach etwas anderes hätte enthalten sein sollen oder ob das so intestine battle, wie es ist. Bis bald, oder wie wir auf Hindi sagen: फिर मिलेंगे!

Abschluss

Die Entwicklung einer auf indische Sprachen zugeschnittenen RAG-Pipeline zeigt die wachsenden Fähigkeiten indischer LLMs bei der Bewältigung komplexer, mehrsprachiger Anforderungen. Indische LLMs ermöglichen es Organisationen, Hindi- und andere regionale Dokumente genauer zu verarbeiten und stellen so die Zugänglichkeit von Informationen über unterschiedliche sprachliche Hintergründe hinweg sicher. Wenn wir diese Modelle verfeinern, wird der Einfluss indischer LLMs auf lokale Sprachanwendungen nur noch zunehmen und neue Möglichkeiten für ein verbessertes Verständnis, einen besseren Abruf und eine bessere Antwortgenerierung in Muttersprachen bieten. Diese Innovation stellt einen spannenden Fortschritt für die Verarbeitung natürlicher Sprache in Indien und darüber hinaus dar.

Wichtige Erkenntnisse

• Die Verwendung von mehrsprachigen E5-Einbettungen ermöglicht eine effektive Handhabung der Suche in Hindi und das Verständnis von Abfragen.
• Kleine Open-Supply-LLMs wie Airavata, die speziell auf Hindi abgestimmt sind, ermöglichen genaue und kulturell relevante Antworten, ohne dass umfangreiche Rechenressourcen erforderlich sind.
• ChromaDB vereinfacht das Speichern und Abrufen von Vektoren, erleichtert die Verwaltung mehrsprachiger Daten im Speicher und erhöht die Reaktionsgeschwindigkeit.
• Der Ansatz nutzt Open-Supply-Modelle und -Instruments, wodurch die Abhängigkeit von kostenintensiven proprietären APIs verringert und gleichzeitig eine zuverlässige Leistung erzielt wird.
• Indische LLMs ermöglichen einen effektiveren Abruf und eine effektivere Analyse von Dokumenten in indischer Sprache und verbessern so die Zugänglichkeit in der Landessprache und die NLP-Fähigkeiten.

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Ich bin ein Datenwissenschaftler, der sich auf NLP, Chatbots und generative KI spezialisiert hat. Da ich eine Leidenschaft für das Schreiben habe, möchte ich mein Wissen und meine Erkenntnisse teilen, die ich durch die Erkundung verschiedener On-line-Ressourcen gewonnen habe. Bei meiner Arbeit geht es darum, die Leistungsfähigkeit von Sprachmodellen zu nutzen, um reale Herausforderungen zu lösen, und es macht mir Spaß, meine Reise dabei zu dokumentieren.