Fragen beantworten mithilfe von Retrieval Augmented Generation mit Grundlagenmodellen in Amazon SageMaker JumpStart.

von Xin Huang, Rachna Chadha, Hemant Singh, Ashish Khetan, Manas Dadarkar und Kyle Ulrich, übersetzt von Luca Schumann

Heute kündigen wir die Verfügbarkeit von Beispiel-Notebooks an, die Frage-Antwort Aufgaben mit einem Retrieval Augmented Generation (RAG)-basierten Ansatz unter Verwendung von Large Language Models (LLMs) in Amazon SageMaker JumpStart demonstrieren. Die Textgenerierung mit RAG und LLMs ermöglicht es Ihnen, domänenspezifische Textausgaben zu generieren, indem Sie spezifische externe Daten als Teil des Kontexts bereitstellen, der den LLMs zugeführt wird.

JumpStart ist eine Plattform für maschinelles Lernen (ML), die Kunden helfen kann, die Ziele ihrer ML-Projekte schneller zu erreichen. JumpStart bietet viele vortrainierte Grundlagenmodelle (engl. foundational models) an, mit denen Sie Aufgaben wie Artikelzusammenfassung, Fragenbeantwortung und Konversations- und Bildgenerierung durchführen können.

In diesem Beitrag beschreiben wir RAG und seine Vorteile und zeigen, wie Sie schnell mit einem Beispiel-Notebook starten können, um eine Frage-Antwort Aufgabe mit RAG-Implementierung und LLMs in JumpStart zu lösen. Wir demonstrieren zwei Ansätze:

• Wie Sie das Problem mit der Open Source Bibliothek LangChain und Amazon SageMaker Endpunkten mit wenigen Zeilen Code lösen
• Wie Sie den SageMaker KNN Algorithmus anwenden, um semantisches Suchen für große Datenmengen mit Hilfe von SageMaker Endpunkten durchzuführen

LLMs und Einschränkungen

LLMs werden mit großen Mengen an unstrukturierten Daten trainiert und eignen sich hervorragend für die allgemeine Textgenerierung. LLMs können faktisches Wissen speichern, indem sie ihre Parameter mit einem umfangreichen Korpus natürlicher Sprachdaten trainieren.

Es gibt jedoch ein paar Einschränkungen bei der Verwendung von vortrainierten LLMs „von der Stange“:

• Sie werden normalerweise offline trainiert, wodurch dem Modell die neuesten Informationen nicht zur Verfügung stehen (beispielsweise hat ein Chatbot, der von 2011 bis 2018 trainiert wurde, keine Informationen über COVID-19).
• Sie treffen Vorhersagen, indem sie nur auf Informationen zurückgreifen, die in ihren Parametern gespeichert sind, was zu einer geringeren Interpretierbarkeit führt.
• Sie werden grundsätzlich auf domänenübergreifenden Korpussen trainiert, wodurch sie bei domänenspezifischen Aufgaben weniger effektiv sind. Es gibt Situationen, in denen Sie möchten, dass Modelle Text auf der Grundlage spezifischer Daten generieren anstatt generischer Daten. Zum Beispiel möchte ein Krankenversicherungsunternehmen, dass ihr Frage-Antwort-Bot Fragen mithilfe der neuesten Informationen beantwortet, die in ihrem Unternehmensdokumentenarchiv oder ihrer Datenbank gespeichert sind, damit die Antworten präzise sind und ihre einzigartigen Geschäftsregeln widerspiegeln.

Aktuell gibt es zwei beliebte Wege, spezifische Daten in LLMs zu referenzieren:

• Daten als Kontext in die Modell-Eingabeaufforderung einfügen, um dem Modell die Informationen zur Verfügung zu stellen, die es bei der Erstellung des Ergebnisses verwenden kann.
• Das Modell fine-tunen, indem man eine Datei mit Eingabe und Ausgabe Paaren bereitstellt.

Die Herausforderung an der kontextbasierten Herangehensweise ist, dass Modelle eine limitierte Kontextgröße besitzen, und alle Dokumente als Kontext hinzuzufügen die erlaubte Kontextgröße des Modells überschreiten könnte.

Bei dem Fine-Tuning-Ansatz ist das Problem, dass das Erstellen der korrekt formattierten Informationen zeitaufwändig und mit Kosten verbunden ist. Zusätzlich bedeutet häufiges Ändern der externen Daten, dass das Modell häufiges Fine-Tuning und erneutes Training benötigt, um genaue Ergebnisse zu erzielen. Häufiges Training beeinflusst die Time-to-Market und erhöht die Kosten der Lösung.

Um diese Einschränkungen zu demonstrieren, haben wir ein LLM Flan T5 XXL Modell verwendet und es folgende Frage gestellt:

question = "Welche Instanzen kann ich mit Managed Spot Training in SageMaker verwenden?"

Wir bekommen folgende Antwort:

"""For model: huggingface-text2text-flan-t5-xxl, the generated output is:
das Managed Spot Training ist ein für folgende Instanzen verfügbares Abonnement Produkt: Data Science Virtual Machine (DSVM), DSVM High, und DSVM Low."""

Wie Sie sehen können, ist die Antwort nicht richtig. Die korrekte Antwort sollte lauten: Alle SageMaker-Instanzen unterstützen Managed Spot Training.

Wir haben dieselbe Frage mit zusätzlichem Kontext ausprobiert, der zusammen mit der Frage übergeben wurde:

question + context + prompt = """
Antwort basierend auf Kontext:

Managed Spot Training kann mit allen von Amazon SageMaker unterstützten Instanzen verwendet warden. Managed Spot Training wird von allen AWS Regionen unterstützt in denen Amazon SageMaker aktuell verfügbar ist.

Welche Instanzen kann ich mit Managed Spot Training in SageMaker verwenden?
"""

Diesmal bekamen wir folgende Antwort:

"""For model: huggingface-text2text-flan-t5-xxl, the generated output is:
Instanzen die von Amazon SageMaker unterstützt werden
"""

Die Antwort ist besser, aber immer noch nicht korrekt. In realen Produktions-Anwendungsfällen können Benutzer verschiedene Anfragen senden, und um genaue Antworten bereitzustellen, möchten Sie möglicherweise alle oder die meisten verfügbaren Informationen als Teil des statischen Kontexts einschließen, um genaue Antworten zu generieren. Bei diesem Ansatz könnten wir jedoch die Grenze der Kontextgröße stoßen, da selbst nicht für die gestellte Frage relevante Informationen als Teil des Kontexts gesendet werden. Genau hier kommt der RAG-basierte Ansatz ins Spiel, um skalierbare und präzise Antworten auf Nutzerfragen zu generieren.

Retrieval Augmented Generation

Um die angesprochenen Einschränkungen zu beheben, können wir Retrieval Augmented Generation (RAG) mit LLMs verwenden. RAG ruft Daten von außerhalb des Sprachmodells (nicht-parametrisch) ab und erweitert die Eingabeaufforderungen, indem relevante abgerufene Daten dem Kontext hinzugefügt werden. RAG-Modelle wurden von Lewis et al. 2020 eingeführt. Dabei handelt es sich um ein Modell, bei dem der parametrische Speicher ein vortrainiertes Seq2Seq-Modell ist und der nicht-parametrische Speicher ein dichter Vektorindex von Wikipedia ist, der mit einem vortrainierten neuronalen Retriever abgerufen wird.

In RAG können externe Daten aus mehreren Quellen stammen, wie zum Beispiel einem Dokumentenarchiv, Datenbanken oder APIs. Der erste Schritt besteht darin, die Dokumente und die Nutzerfrage in ein Format umzuwandeln, in dem sie verglichen werden können und eine relevante Suche durchgeführt werden kann. Um die Formate für die Relevanzsuche vergleichbar zu machen, werden eine Dokumentensammlung (Wissensbibliothek) und die Nutzerfrage mithilfe von Einbettungs-Sprachmodellen in eine numerische Darstellung umgewandelt. Die Einbettungen sind im Wesentlichen numerische Darstellungen von Konzepten im Text. Basierend auf der Einbettung der Benutzeranfrage wird der relevante Text in der Dokumentensammlung durch eine Ähnlichkeitssuche im Einbettungsraum identifiziert. Anschließend wird die vom Nutzer bereitgestellte Eingabeaufforderung mit dem durchsuchten relevanten Text erweitert und dem Kontext hinzugefügt. Die Eingabeaufforderung wird nun an das LLM gesendet, und da der Kontext relevante externe Daten zusammen mit der ursprünglichen Eingabeaufforderung enthält, ist die Ausgabe des Modells relevant und präzise.

Um Informationen für die Referenzdokumente aktuell zu halten, können Sie die Dokumente asynchron aktualisieren und die Einbettungs-Darstellung der Dokumente aktualisieren. Auf diese Weise werden die aktualisierten Dokumente verwendet, um Antworten auf zukünftige Fragen zu generieren und genaue Antworten bereitzustellen.

Das folgende Diagramm zeigt den konzeptuellen Ablauf bei der Verwendung von RAG mit LLMS.

In diesem Beitrag zeigen wir, wie man eine Frage-Antwort-Anwendung in den folgenden Schritten implementiert:

1. Erstellen Sie eine Einbettung für jedes Dokument in der Wissensbibiliothek mit einem SageMaker GPT-J-6B Einbettungsmodell.
2. Identifizieren Sie die K relevantesten Dokumente basierend auf der Nutzerfrage
   1. Generieren Sie für die Frage die Einbettung der Frage mit demselben Einbettungsmodell
   2. Suchen Sie die Indizes der K relevantesten Dokumente im Einbettungsraum mithilfe einer in-Memory-FAISS-Suche.
   3. Verwenden Sie die Indizes, um die entsprechenden Dokumente abzurufen.
3. Verwenden Sie die abgerufenen relevanten Dokumente zusammen mit der Eingabeaufforderung und der Frage als Kontext und sende sie an das SageMaker LLM, um die Antwort zu generieren.

Wir demonstrieren die folgenden Ansätze:

• Wie man eine Frage-Antwort-Aufgabe mit SageMaker LLMs und Einbettungs-Endpunkten sowie der Open-Source-Bibliothek LangChain in wenigen Zeilen Code löst. Insbesondere verwenden wir zwei SageMaker-Endpunkte für das LLM (Flan T5 XXL) und das Einbettungsmodell (GPT-J 6B), und die verwendete Vektordatenbank ist in-Memory-FAISS. Weitere Details finden Sie im GitHub-Repository.
• Wenn die in-Memory-FAISS nicht für Ihren großen Datensatz geeignet ist, stellen wir Ihnen einen SageMaker KNN-Algorithmus für die semantische Suche zur Verfügung, der ebenfalls FAISS als zugrunde liegenden Suchalgorithmus verwendet. Weitere Informationen finden Sie im GitHub-Repository.

Das nachfolgende Diagramm zeigt die Lösungsarchitektur.

JumpStart RAG-basiertes Implementierungs-Notebook mit LangChain LLM Modell erstellen

LangChain ist ein Open-Source-Framework zur Entwicklung von Anwendungen, die von Sprachmodellen angetrieben werden. LangChain bietet eine generische Schnittstelle für viele verschiedene LLMs. Es erleichtert außerdem Entwicklern die Verkettung verschiedener LLMs und die Erstellung leistungsstarker Anwendungen. LangChain bietet eine standardisierte Schnittstelle für den Arbeitsspeicher und eine Sammlung von Speicherimplementierungen, um den Zustand zwischen den Aufrufen von Agenten oder Ketten zu erhalten.

LangChain bietet viele weitere nützliche Funktionen, die die Produktivität von Entwicklern erhöhen können. Darunter eine Eingabenaufforderungs-Vorlage, die die Anpassung von Eingabeaufforderungen mithilfe von Variablen in der Vorlage erleichtert, Agenten zum Erstellen von Ende-zu-Ende-Anwendungen, Indizes für Such- und Abrufschritte der Kette und vieles mehr. Um die Möglichkeiten von LangChain weiter zu erkunden, schauen Sie bitte in die LangChain Dokumentation.

Das Grundlagenmodell erstellen

Als ersten Schritt stellen Sie das JumpStart LLM-Modell Ihrer Wahl bereit. In dieser Demo verwenden wir einen Endpunkt für das Jumpstart Flan T5 XXL-Modell. Anweisungen zur Bereitstellung finden Sie in Zero-shot prompting for the Flan-T5 foundation model in Amazon SageMaker JumpStart. Je nach Anwendungsfall können Sie auch andere anweisungs-getunte Modelle wie Flan T5 UL2 oder BloomZ 7B1 bereitstellen. Weitere Informationen finden Sie im Beispiel-Notebook.

Um den SageMaker LLM-Endpunkt mit LangChain zu verwenden, verwenden wir langchain.llms.sagemaker_endpoint.SagemakerEndpoint, das den SageMaker LLM-Endpunkt abstrahiert. Wir müssen eine Transformation für das Anfrage- und Antwort-Payload durchführen, wie im folgenden Code für die Integration von LangChain und SageMaker gezeigt. Beachten Sie, dass Sie den Code in ContentHandler möglicherweise anpassen müssen, basierend auf dem content_type und dem accepts Format des gewählten LLM-Modells.

from langchain.llms.sagemaker_endpoint import SagemakerEndpoint

class ContentHandler(ContentHandlerBase):
    content_type = "application/json"
    accepts = "application/json"

    def transform_input(self, prompt: str, model_kwargs={}) -> bytes:
        input_str = json.dumps({"text_inputs": prompt, **model_kwargs})
        return input_str.encode("utf-8")

    def transform_output(self, output: bytes) -> str:
        response_json = json.loads(output.read().decode("utf-8"))
        return response_json["generated_texts"][0]

content_handler = ContentHandler()

sm_llm = SagemakerEndpoint(
    endpoint_name=_MODEL_CONFIG_["huggingface-text2text-flan-t5-xxl"]["endpoint_name"],
    region_name=aws_region,
    model_kwargs=parameters,
    content_handler=content_handler,
)

Das Einbettungsmodell erstellen

Als nächstes müssen wir unser eingebettetes Modell vorbereiten. Wir stellen das GPT-J 6B-Modell als das eingebettete Modell bereit. Wenn Sie ein JumpStart-Einbettungsmodell verwenden, müssen Sie die LangChain SageMaker-Endpunkt-Einbettungsklasse anpassen und die Modellanfrage und -antwort transformieren, um sie in LangChain zu integrieren. Für eine detaillierte Implementierung siehe GitHub-Repository.

embeddings = SagemakerEndpointEmbeddingsJumpStart(
    endpoint_name=_MODEL_CONFIG_["huggingface-textembedding-gpt-j-6b"]["endpoint_name"],
    region_name=aws_region,
    content_handler=content_handler,
)

Domänenspezifische Dokumente mithilfe des LangChain Document Loader laden und einen Index erstellen

Wir verwenden das CSVLoader package in LangChain um CSV-formatierte Dokumente in den Document Loader zu laden.

loader = CSVLoader(file_path="rag_data/processed_data.csv")
documents = loader.load()

Als Nächstes verwenden wir den TextSplitter, um die Daten für die Einbettung vorzubereiten und verwenden das SageMaker-Einbettungsmodell GPT-J-6B, um die Einbettung zu erstellen. Wir speichern die Einbettung in einem FAISS-Vektorspeicher, um einen Index zu erstellen. Wir verwenden diesen Index, um relevante Dokumente zu finden, die semantisch ähnlich zur Anfrage des Nutzers sind.

Der folgende Code zeigt, wie all diese Schritte von der Klasse VectorstoreIndexCreator in nur wenigen Zeilen Code in LangChain durchgeführt werden, um eine prägnante Implementierung der Fragebeantwortung mit RAG zu erstellen:

index_creator = VectorstoreIndexCreator(
    vectorstore_cls=FAISS,
    embedding=embeddings,
    text_splitter=CharacterTextSplitter(chunk_size=300, chunk_overlap=0),
)
index = index_creator.from_loaders([loader])

Den Index verwenden, um nach relevantem Kontext zu suchen und ihn an das LLM zu übergeben

Als nächstes verwenden Sie die Abfrage-Methode auf dem erstellten Index und übergeben die Nutzerfrage dem SageMaker Endpunkt LLM. LangChain wählt die vier nähesten Dokumente (K=4) aus und übermittelt den relevanten Kontext, der aus den Dokumenten extrahiert wurde, um eine genaue Antwort zu generieren. Siehe folgender Code:

index.query(question=question, llm=sm_llm)

Wir kriegen folgende Antwort auf die Anfrage mit der RAG basierten Herangehensweise mit Flan T5 XXL:

"""For model: huggingface-text2text-flan-t5-xxl, the generated output is: 
Managed Spot Training kann mit allen von Amazon SageMaker unterstützten Instanzen verwendet werden
"""

Die Antwort wirkt genauer im Vergleich zur Antwort, die wir mit anderen Ansätzen erhalten haben, die wir zuvor demonstriert haben und die keinen Kontext oder einen statischen Kontext haben, der möglicherweise nicht immer relevant ist.

Alternative Herangehensweise um RAG mit mehr Anpassungsmöglichkeiten mithilfe von SageMaker und LangChain zu implementieren

In diesem Abschnitt zeigen wir Ihnen einen anderen Ansatz, um RAG mit SageMaker und LangChain zu implementieren. Dieser Ansatz bietet die Flexibilität, die „top K“ Parameter für eine Relevanzsuche in den Dokumenten zu konfigurieren. Außerdem ermöglicht er Ihnen die Verwendung der LangChain-Funktion für Vorlagen, mit der Sie die Erstellung der Eingabeaufforderung leicht parameterisieren können, anstatt sie hart zu codieren.

Im folgenden Code verwenden wir explizit FAISS, um für jedes Dokument in der Wissensbibliothek eine Einbettung zu generieren, und zwar mit dem SageMaker GPT-J-6B-Einbettungsmodell. Anschließend identifizieren wir die K (K=3) relevantesten Dokumente basierend auf der Benutzeranfrage.

docsearch = FAISS.from_documents(documents, embeddings)
docs = docsearch.similarity_search(question, k=3)

Als nächstes verwenden wir eine Eingabeaufforderungsvorlage und verketten sie mit SageMaker LLM:

prompt_template = """Answer based on context:\n\n{context}\n\n{question}"""
PROMPT = PromptTemplate(template=prompt_template, input_variables=["context", "question"])
chain = load_qa_chain(llm=sm_llm, prompt=PROMPT)

Wir senden die drei relevantesten Dokumente (K=3), die wir gefunden haben, als Kontext zur Eingabeaufforderung, indem wir eine LangChain-Kette verwenden:

result = chain({"input_documents": docs, "question": question}, return_only_outputs=True)["output_text"]

Mit diesem Ansatz der RAG-Implementierung konnten wir die zusätzliche Flexibilität von LangChain- Eingabeaufforderungsvorlagen nutzen und die Anzahl der durchsuchten Dokumente für eine Relevanzübereinstimmung mit dem Hyperparameter „top K“ anpassen.

JumpStart RAG-basiertes Implementierungs-Notebook mit SageMaker KNN

In diesem Abschnitt implementieren wir den RAG-basierten Ansatz unter Verwendung des KNN-Algorithmus zur Suche nach relevanten Dokumenten zur Erstellung eines erweiterten Kontexts. Bei diesem Ansatz verwenden wir nicht LangChain, sondern die Amazon SageMaker FAQs als Wissensdokumente und betten die Modelle GPT-J-6B und LLM Flan T5 XXL ein, genauso wie im vorherigen LangChain-Ansatz.

Wenn Sie einen großen Datensatz haben, kann Ihnen der SageMaker KNN Algorithmus eine effektiven semantische Suche ermöglichen. Der SageMaker KNN-Algorithmus verwendet ebenfalls FAISS als zugrunde liegenden Suchalgorithmus. Das Notebook für diese Lösung finden Sie auf GitHub.

Zunächst stellen wir die Einbettungsmodelle LLM Flan T5 XXL und GPT-J 6B auf dieselbe Weise bereit wie im vorherigen Abschnitt. Für jeden Eintrag in der Wissensdatenbank generieren wir einen Einbettungsvektor unter Verwendung des GPT-J-Einbettungsmodells.

Anschließend verwenden wir einen SageMaker KNN Trainingsjob, um die Einbettung der Wissensdaten zu indizieren. Der zugrunde liegende Algorithmus zur Indizierung der Daten ist FAISS. Wir möchten die top fünf relevantesten Dokumente finden, daher setzen wir die Variable TOP_K auf 5. Wir erstellen den Schätzer für den KNN-Algorithmus, führen den Trainingsjob aus und stellen das KNN-Modell bereit, um die Indizes der fünf besten Dokumente zu finden, die der Anfrage entsprechen. Siehe folgender Code:

from sagemaker.amazon.amazon_estimator import get_image_uri

def trained_estimator_from_hyperparams(s3_train_data, hyperparams, output_path):
    """
    Create an Estimator from the given hyperparams, fit to training data,
    and return a deployed predictor

    """
    # set up the estimator
    knn = sagemaker.estimator.Estimator(
        get_image_uri(boto3.Session().region_name, "knn"),
        aws_role,
        instance_count=1,
        instance_type="ml.m5.2xlarge",
        output_path=output_path,
        sagemaker_session=sess,
    )
    knn.set_hyperparameters(**hyperparams)

    # train a model. fit_input contains the locations of the train data
    fit_input = {"train": s3_train_data}
    knn.fit(fit_input)
    return knn

hyperparams = {"feature_dim": train_features.shape[1], "k": TOP_K,"sample_size": train_features.shape[0], "predictor_type": "classifier"}
output_path = f"s3://{bucket}/{prefix}/default_example/output"
knn_estimator = trained_estimator_from_hyperparams(
    s3_train_data, hyperparams, output_path)

Als nächstes erstellen wir eine Einbettungsdarstellung der Anfrage mit Hilfe des GPT-J-6B-Einbettungsmodells, welches wir für die Einbettung der Wissensbibliothek verwendet haben.

query_response = query_endpoint_with_json_payload(question, endpoint_name_embed, content_type="application/x-text")
question_embedding = parse_response_text_embed(query_response)

Dann verwenden wir den KNN Endpunkt und übergeben die Einbettung der Anfrage an den KNN Endpunkt, um die Indizes der K relevantesten Dokumente zu erhalten. Wir verwenden die Indizes, um die entsprechenden Textdokumente abzurufen. Anschließend verketten wir die Dokumente und stellen sicher, dass die maximale zulässige Länge des Kontexts nicht überschritten wird. Siehe folgender Code:

"""With maximum sequence length 500, selected top 4 document sections:
Managed Spot Training kann mit allen von Amazon SageMaker unterstützten Instanzen verwendet werden.
Managed Spot Training wird in allen AWS-Regionen unterstützt, in denen Amazon SageMaker derzeit verfügbar ist.
Der Unterschied zwischen Savings Plans für Amazon SageMaker und Savings Plans für EC2 besteht in den enthaltenen Diensten.
SageMaker Savings Plans gelten nur für die Verwendung von SageMaker ML-Instanzen.
Es gibt keine festen Grenzen für die Größe des Datensatzes, den Sie für das Training von Modellen mit Amazon SageMaker verwenden können.
"""

Nun kommen wir zum letzten Schritt, bei dem wir die Anfrage, die Eingabeaufforderung und den Kontext mit Texten aus relevanten Dokumenten kombinieren und sie dem Textgenerierungs LLM Flan T5 XXL Modell übergeben, um die Antwort zu generieren.

Wir bekommen folgende Antwort für unsere Anfrage mittels der RAG-basierten Herangehensweise mit Flan T5 XXL:

"""
For model: huggingface-text2text-flan-t5-xxl, the generated output is:

Das Managed Spot Training kann mit allen Instanzen verwendet werden, die von Amazon SageMaker unterstützt werden.
"""

Aufräumarbeiten

Stellen Sie sicher, dass Sie alle von dem Notebook erstellten Endpunkte löschen, wenn Sie sie nicht mehr verwenden, um fortlaufende Kosten zu vermeiden.

Fazit

In diesem Beitrag haben wir die Implementierung eines RAG-basierten Ansatzes mit LLMs für Frage-Antwort-Aufgaben mit zwei verschiedenen Ansätzen demonstriert: LangChain und dem integrierten KNN-Algorithmus. Der RAG-basierte Ansatz optimiert die Genauigkeit der Textgenerierung unter Verwendung von Flan T5 XXL, indem er dynamisch relevanten Kontext bereitstellt, der durch die Suche in einer Liste von Dokumenten erstellt wurde.

Sie können diese Notebooks in SageMaker verwenden, wie sie sind, oder sie nach Belieben anpassen. Zur Anpassung können Sie Ihre eigenen Dokumente in der Wissensbibliothek verwenden, andere Implementierungen für die Relevanzsuche wie OpenSearch nutzen und andere Einbettungsmodelle und Textgenerierungs-LLMs, die auf JumpStart verfügbar sind, verwenden.

Wir freuen uns darauf, zu sehen, was Sie mit Hilfe eines RAG-basierten Ansatzes auf JumpStart kreiren!

Über die Autoren

	Dr. Xin Huang ist ein Senior Applied Scientist für Amazon SageMaker JumpStart und die integrierten Algorithmen von Amazon SageMaker. Er konzentriert sich auf die Entwicklung skalierbarer ML-Algorithmen. Seine Forschungsinteressen liegen im Bereich der natürlichen Sprachverarbeitung, erklärbares Deep Learning für tabellarische Daten und robuste Analysen von nichtparametrischem Raum-Zeit-Clustering. Er hat viele Artikel auf Konferenzen wie ACL, ICDM, KDD und der Royal Statistical Society: Series A veröffentlicht.
	Rachna Chadha ist Principal Solution Architect AI/ML in Strategic Accounts bei AWS. Rachna ist eine Optimistin, die daran glaubt, dass der ethische und verantwortungsbewusste Einsatz von KI die Gesellschaft in Zukunft verbessern und zu wirtschaftlichem und sozialem Wohlstand führen kann. In ihrer Freizeit verbringt Rachna gerne Zeit mit ihrer Familie, wandert und hört Musik.
	Dr. Kyle Ulrich ist ein Applied Scientist im Team der integrierten Algorithmen von Amazon SageMaker. Seine Forschungsinteressen umfassen skalierbare Machine-Learning-Algorithmen, Computer Vision, Zeitreihen, Bayes’sche Nichtparametrik und Gauss’sche Prozesse. Seinen Doktortitel hat er von der Duke University und er hat Artikel auf Konferenzen wie NeurIPS, Cell und Neuron veröffentlicht.
	Hemant Singh ist ein Machine Learning Engineer mit Erfahrung in Amazon SageMaker JumpStart und den integrierten Algorithmen von Amazon SageMaker. Er hat seinen Masterabschluss vom Courant Institute of Mathematical Sciences und seinen B.Tech vom IIT Delhi. Er hat Erfahrung in der Bearbeitung einer Vielzahl von ML-Problemen im Bereich der natürlichen Sprachverarbeitung, Computer Vision und Zeitreihenanalyse.
	Manas Dadarkar ist Softwareentwicklungsmanager und verantwortlich für die Entwicklung des Amazon Forecast-Dienstes. Er ist leidenschaftlich daran interessiert, Anwendungen von Maschinelles Lernen voranzutreiben und ML-Technologien für jedermann leicht zugänglich zu machen, um sie in die Produktion zu bringen. Außerhalb der Arbeit hat er vielfältige Interessen, darunter Reisen, Lesen und Zeit mit Freunden und Familie verbringen.
	Dr. Ashish Khetan ist ein Senior Applied Scientist für die integrierten Algorithmen von Amazon SageMaker und unterstützt bei der Entwicklung von Machine-Learning-Algorithmen. Er hat seinen Doktortitel von der University of Illinois Urbana-Champaign. Er ist ein aktiver Forscher im Bereich Maschinelles Lernen und statistische Inferenz und hat viele Artikel auf Konferenzen wie NeurIPS, ICML, ICLR, JMLR, ACL und EMNLP veröffentlicht.