Dabei Mit Daten führen In dieser Sitzung tauchen wir in die Reise von Anand Ranganathan ein, einem Visionär in den Bereichen KI und maschinelles Lernen. Von seinen Anfängen bei IBM bis hin zur Mitgründung innovativer Startups wie Unscramble und 1/0 gibt Anand Einblicke in die Herausforderungen, Transformationen und die Zukunft der KI. Entdecken Sie mit uns seine unternehmerischen Erfahrungen, die Auswirkungen von Deep Studying und seine Imaginative and prescient für die Zukunft der KI und ihrer Anwendungen.

Sie können diese Episode von „Main with Knowledge“ auf beliebten Plattformen wie anhören Spotify, Google PodcastsUnd Apfel. Wählen Sie Ihren Favoriten aus, um die aufschlussreichen Inhalte zu genießen!

Wichtige Erkenntnisse aus unserem Gespräch mit Anand Ranganathan

• Das Gleichgewicht zwischen symbolischer KI und Deep Studying ist der Schlüssel für präzises Denken in bestimmten Bereichen.
• Der Aufstieg des Deep Studying erfordert Agilität bei der Produktentwicklung und den Marktstrategien.
• KI-Dienstleistungsunternehmen konzentrieren sich mehr auf Kundenbeziehungen und maßgeschneiderte Lösungen als Produktunternehmen.
• Agentische Arbeitsabläufe werden die KI-Integration verändern, aber die Grenzen der Zusammenarbeit zwischen Mensch und KI müssen klar sein.
• Für KI/ML-Karrieren sind Domänenkenntnisse und das Bleiben auf dem Laufenden für den Erfolg von entscheidender Bedeutung.
• Die Zukunft der KI wird die Softwareentwicklung neu gestalten und erfordert kontinuierliches Lernen und Anpassung.
• Domänenkenntnisse sind von entscheidender Bedeutung, da KI generische Software program-Engineering-Rollen durcheinander bringt.

Nehmen Sie an unseren kommenden „Main with Knowledge“-Sitzungen teil und erleben Sie aufschlussreiche Diskussionen mit Führungskräften aus den Bereichen KI und Knowledge Science!

Schauen wir uns die Particulars unseres Gesprächs mit Anand Ranganathanl an!

Wie begann Ihre Reise in die KI- und ML-Branche und wie waren die Anfänge für Sie?

Meine Reise in die KI begann mit meiner Doktorarbeit an der College of Illinois, wo ich mich mit der Schnittstelle zwischen KI und verteilten Systemen befasste. Damals ging es bei der KI eher um symbolisches oder logisches Denken, ganz anders als heute. Ich habe an der KI-Planung gearbeitet, bei der es darum geht, die Welt mithilfe einer Reihe von Aktionen von einem Zustand in einen anderen zu überführen. Nach meiner Promotion wechselte ich zu IBM Analysis, wo ich mich mit Huge-Knowledge-Problemen befasste und Teil des Groups battle, das das Stream-Processing-Angebot von IBM aufbaute. Es battle eine Ära, die von klassischer KI dominiert wurde, aber als Deep Studying in den 2010er Jahren an Bedeutung gewann, veränderte sich das Feld dramatisch.

Was hat Sie motiviert, IBM zu verlassen und Ihr eigenes Unternehmen zu gründen?

Nach einem Jahrzehnt bei IBM wollte ich unbedingt interessante Probleme angehen, die ich in der Branche erkannte. Das Treffen mit den richtigen Leuten, die meine Imaginative and prescient teilten, und das Erkennen einer Marktchance waren für mich der Auslöser für die Mitgründung meines ersten Startups, Unscramble. Unser Ziel battle es, bei der Lösung von Herausforderungen flexibel und innovativ zu sein, was eine andere Erfahrung als im Unternehmensumfeld bei IBM battle.

Können Sie die beiden unterschiedlichen Probleme erklären, auf die sich Unscramble konzentrierte, und wie sie miteinander verbunden waren?

Unscramble befasste sich zunächst mit Problemen beim Echtzeit-Streaming von Daten, insbesondere im Telekommunikationssektor. Dann wurde uns klar, dass auch eine Analyse historischer Daten erforderlich battle. Obwohl die Domänen unterschiedlich waren, bestand die zugrunde liegende Gemeinsamkeit in Abfragen zu strukturierten Daten und Triggern zu Streaming-Daten. Unsere Lösungen reichten von Abfragen in natürlicher Sprache in Datenbanken bis hin zur Definition von Marketingkampagnen in Echtzeit über eine Schnittstelle in natürlicher Sprache.

Wie hat sich der Aufstieg des Deep Studying auf Ihre Produkte bei Unscramble ausgewirkt?

Der Aufstieg des Deep Studying battle erheblich, insbesondere für unser Übersetzungsprodukt von natürlicher Sprache in SQL. Wir mussten unsere Techniken weiterentwickeln, da Deep-Studying-Modelle immer besser mit solchen Aufgaben umgehen konnten. Als schließlich fein abgestimmte SQL-Generierungsmodelle auftauchten, battle klar, dass der Raum gestört wurde. Wir prüften bereits eine Ausstiegsstrategie und der Zeitpunkt für den Verkauf des Produkts passte, bevor die Störung zu groß wurde.

Was sind die Unterschiede zwischen der Führung eines Produktunternehmens wie Unscramble und eines Dienstleistungsunternehmens wie 1by0?

Bei der Leitung eines Produktunternehmens geht es darum, zu präsentieren, was man hat, und es an die Bedürfnisse der Kunden anzupassen, während es bei einem Dienstleistungsunternehmen darum geht, das Drawback des Kunden zu verstehen und die richtige Lösung zu entwickeln. Bei 1by0 konzentrieren wir uns mehr auf Konto- und Projektmanagement, Zertifizierungen und die Pflege enger Partnerschaften mit Anbietern wie AWS und Databricks. Es ist ein anderer Weg, mit einem stärkeren Schwerpunkt auf Kundenbeziehungen und der Bereitstellung maßgeschneiderter Lösungen.

Wenn Sie über Ihre unternehmerische Reise nachdenken: Was sind einige wichtige Erkenntnisse und Dinge, die Sie anders machen könnten?

Eine wichtige Erkenntnis ist die Steadiness zwischen der Bewältigung interessanter Probleme und der Fokussierung auf die Marktnachfrage. Bei Unscramble gaben wir manchmal interessanten Herausforderungen Vorrang vor der Marktfähigkeit, was zwar intellektuell zufriedenstellend, aber nicht immer optimum für das Startup-Wachstum battle. Im Dienstleistungsbereich besteht die Herausforderung darin, zu entscheiden, wie viel in explorative Lösungen im Vergleich zu sichereren, intestine verstandenen Lösungen investiert werden soll.

Wie stellen Sie sich die Zukunft der KI vor, insbesondere im Kontext symbolischer KI und Deep Studying?

Ich glaube, dass ein Gleichgewicht zwischen symbolischer KI und Deep Studying erforderlich ist, insbesondere in Bereichen, die präzises Denken erfordern, wie etwa in der Medizin. Während LLMs ihre Denkfähigkeiten verbessern, besteht immer noch Bedarf an nachweisbarem und genauem Wissen, das symbolische KI liefern kann. Durchbrüche bei der Vereinfachung des Aufbaus von Wissensdatenbanken könnten der Schlüssel zur Weiterentwicklung der symbolischen KI sein.

Welche Traits sehen Sie in der nahen Zukunft im Bereich KI und wie sehen Sie die Entwicklung der Agenten-Workflows?

Agenten-Workflows gewinnen an Bedeutung und werden dies auch weiterhin tun. Sie bieten eine Möglichkeit, KI nahtloser in den Arbeitsalltag zu integrieren. Allerdings ist die Grenze zwischen menschlicher und KI-Zusammenarbeit immer noch unklar. Die Entscheidung, wann KI automatisch Maßnahmen ergreifen kann und wann ein Mensch einbezogen werden muss, wird von entscheidender Bedeutung sein. Ich sehe auch, dass KI immer stärker in die Softwareentwicklung integriert wird und sich die für Softwareentwickler erforderlichen Fähigkeiten verändern.

Welchen Rat würden Sie denjenigen geben, die gerade ihre Karriere im Bereich KI und ML beginnen?

Konzentrieren Sie sich neben technischen Fähigkeiten auch auf den Erwerb von Fachwissen auf dem Gebiet. Fachwissen ist weniger anfällig für Störungen und kann Ihre technischen Fähigkeiten ergänzen. Bleiben Sie über Fortschritte in der KI auf dem Laufenden und experimentieren Sie mit verschiedenen Instruments und Frameworks, um Ihre Effektivität zu steigern. Da es sich um ein sich schnell veränderndes Feld handelt, ist kontinuierliches Lernen unerlässlich.

Schlussbemerkung

Anand Ranganathans Reise spiegelt die rasante Entwicklung und das Potenzial der KI wider. Von IBM bis hin zu bahnbrechenden Startups unterstreicht seine Geschichte die Bedeutung von Anpassungsfähigkeit, Fachwissen und der Steadiness zwischen Innovation und Marktanforderungen. Während KI Branchen umgestaltet, unterstreichen seine Erkenntnisse die entscheidende Rolle der Zusammenarbeit zwischen Mensch und KI und kontinuierlichem Lernen. Die Zukunft der KI ist spannend und Führungskräfte wie Anand ebnen den Weg für transformative Fortschritte.

Für spannendere Sitzungen zum Thema KI, Datenwissenschaftund GenAI, bleiben Sie mit uns auf dem Laufenden zum Thema Führen mit Daten.

Schauen Sie sich hier unsere bevorstehenden Sitzungen an.

Wir führen jetzt Auswahl Mischen Ensemble indem die Reihenfolge der Antwortmöglichkeiten für jede Testfrage neu gemischt wird, wodurch mehrere Varianten derselben Frage entstehen. Der LLM wird dann mit diesen Varianten zusammen mit den entsprechenden Beispielen aus wenigen Versuchen aufgefordert, Denkschritte und eine Antwort für jede Variante zu generieren. Schließlich führen wir eine Mehrheitsabstimmung über die Vorhersagen aller Varianten durch und wählen die endgültige Vorhersage aus.

Den Code für diese Implementierung finden Sie hier Hyperlink zum GitHub-Repository.

Zur Implementierung und Evaluierung von Medprompt verwenden wir den MedQA (6)-Datensatz. Zunächst definieren wir Hilfsfunktionen zum Parsen der JSONL-Dateien.

def write_jsonl_file(file_path, dict_list):
"""
Write an inventory of dictionaries to a JSON Strains file.
Args:
- file_path (str): The trail to the file the place the information will likely be written.
- dict_list (listing): A listing of dictionaries to jot down to the file.
"""
with open(file_path, 'w') as file:
for dictionary in dict_list:
json_line = json.dumps(dictionary)
file.write(json_line + 'n')
def read_jsonl_file(file_path):
"""
Parses a JSONL (JSON Strains) file and returns an inventory of dictionaries.
Args:
file_path (str): The trail to the JSONL file to be learn.
Returns:
listing of dict: A listing the place every component is a dictionary representing
a JSON object from the file.
"""
jsonl_lines = ()
with open(file_path, 'r', encoding="utf-8") as file:
for line in file:
json_object = json.masses(line)
jsonl_lines.append(json_object)
return jsonl_lines

Implementierung selbstgenerierter CoT

Für unsere Implementierung verwenden wir das Trainingsset von MedQA. Wir implementieren eine Zero-Shot-CoT-Eingabeaufforderung und verarbeiten alle Trainingsfragen. Wir verwenden GPT-4o in unserer Implementierung. Für jede Frage generieren wir den CoT und die entsprechende Antwort. Wir definieren eine Eingabeaufforderung, die auf der im Medprompt-Dokument bereitgestellten Vorlage basiert.

system_prompt = """You're an professional medical skilled. You're supplied with a medical query with a number of reply selections.
Your aim is to suppose by means of the query rigorously and clarify your reasoning step-by-step earlier than choosing the ultimate reply.
Reply solely with the reasoning steps and reply as specified beneath.
Under is the format for every query and reply:
Enter:
## Query: {{query}}
{{answer_choices}}
Output:
## Reply
(mannequin generated chain of thought rationalization)
Due to this fact, the reply is (closing mannequin reply (e.g. A,B,C,D))"""

def build_few_shot_prompt(system_prompt, query, examples, include_cot=True):
"""
Builds the zero-shot immediate.
Args:
system_prompt (str): Job Instruction for the LLM
content material (dict): The content material for which to create a question, formatted as
required by `create_query`.
Returns:
listing of dict: A listing of messages, together with a system message defining
the duty and a consumer message with the enter query.
"""
messages = ({"position": "system", "content material": system_prompt})
for elem in examples:
messages.append({"position": "consumer", "content material": create_query(elem)})
if include_cot:
messages.append({"position": "assistant", "content material": format_answer(elem("cot"), elem("answer_idx"))})        
else:           
answer_string = f"""## AnswernTherefore, the reply is {elem("answer_idx")}"""
messages.append({"position": "assistant", "content material": answer_string})
messages.append({"position": "consumer", "content material": create_query(query)})
return messages
def get_response(messages, model_name, temperature = 0.0, max_tokens = 10):
"""
Obtains the responses/solutions of the mannequin by means of the chat-completions API.
Args:
messages (listing of dict): The constructed messages supplied to the API.
model_name (str): Title of the mannequin to entry by means of the API
temperature (float): A price between 0 and 1 that controls the randomness of the output.
A temperature worth of 0 ideally makes the mannequin decide the most certainly token, making the outputs deterministic.
max_tokens (int): Most variety of tokens that the mannequin ought to generate
Returns:
str: The response message content material from the mannequin.
"""
response = shopper.chat.completions.create(
mannequin=model_name,
messages=messages,
temperature=temperature,
max_tokens=max_tokens
)
return response.selections(0).message.content material

Wir definieren auch Hilfsfunktionen zum Parsen der Begründung und der endgültigen Antwortoption aus der LLM-Antwort.

def matches_ans_option(s):
"""
Checks if the string begins with the precise sample 'Due to this fact, the reply is (A-Z)'.
Args:
s (str): The string to be checked.
Returns:
bool: True if the string matches the sample, False in any other case.
"""
return bool(re.match(r'^Due to this fact, the reply is (A-Z)', s))
def extract_ans_option(s):
"""
Extracts the reply possibility (a single capital letter) from the beginning of the string.
Args:
s (str): The string containing the reply sample.
Returns:
str or None: The captured reply possibility if the sample is discovered, in any other case None.
"""
match = re.search(r'^Due to this fact, the reply is ((A-Z))', s)
if match:
return match.group(1)  # Returns the captured alphabet
return None 
def matches_answer_start(s):
"""
Checks if the string begins with the markdown header '## Reply'.
Args:
s (str): The string to be checked.
Returns:
bool: True if the string begins with '## Reply', False in any other case.
"""
return s.startswith("## Reply")
def validate_response(s):
"""
Validates a multi-line string response that it begins with '## Reply' and ends with the reply sample.
Args:
s (str): The multi-line string response to be validated.
Returns:
bool: True if the response is legitimate, False in any other case.
"""
file_content = s.break up("n")
return matches_ans_option(file_content(-1)) and matches_answer_start(s)
def parse_answer(response):
"""
Parses a response that begins with '## Reply', extracting the reasoning and the reply selection.
Args:
response (str): The multi-line string response containing the reply and reasoning.
Returns:
tuple: A tuple containing the extracted CoT reasoning and the reply selection.
"""
split_response = response.break up("n")
assert split_response(0) == "## Reply"
cot_reasoning = "n".be a part of(split_response(1:-1)).strip()
ans_choice = extract_ans_option(split_response(-1))
return cot_reasoning, ans_choice

Wir verarbeiten nun die Fragen im Trainingsset von MedQA. Wir erhalten CoT-Antworten und Antworten für alle Fragen und speichern sie in einem Ordner.

train_data = read_jsonl_file("knowledge/phrases_no_exclude_train.jsonl")
cot_responses = ()
# os.mkdir("cot_responses")
existing_files = os.listdir("cot_responses/")
for idx, merchandise in enumerate(tqdm(train_data)):
if str(idx) + ".txt" in existing_files:
proceed
immediate = build_zero_shot_prompt(system_prompt, merchandise)
attempt:
response = get_response(immediate, model_name="gpt-4o", max_tokens=500)
cot_responses.append(response)
with open(os.path.be a part of("cot_responses", str(idx) + ".txt"), "w", encoding="utf-8") as f:
f.write(response)           
besides Exception as e :
print(str(e))
cot_responses.append("")

Wir durchlaufen nun alle generierten Antworten, um zu prüfen, ob sie gültig sind und dem in der Eingabeaufforderung definierten Vorhersageformat entsprechen. Wir verwerfen Antworten, die nicht dem erforderlichen Format entsprechen. Danach überprüfen wir die vorhergesagten Antworten anhand der Grundwahrheit für jede Frage und behalten nur Fragen bei, deren vorhergesagte Antworten mit der Grundwahrheit übereinstimmen.

questions_dict = ()
ctr = 0
for idx, query in enumerate(tqdm(train_data)):
file =  open(os.path.be a part of("cot_responses/", str(idx) + ".txt"), encoding="utf-8").learn()
if not validate_response(file):
proceed
cot, pred_ans = parse_answer(file)
dict_elem = {}
dict_elem("idx") = idx
dict_elem("query") = query("query")
dict_elem("reply") = query("reply")
dict_elem("choices") = query("choices")
dict_elem("cot") = cot
dict_elem("pred_ans") = pred_ans
questions_dict.append(dict_elem)        
filtered_questions_dict = ()
for merchandise in tqdm(questions_dict):
pred_ans = merchandise("choices")(merchandise("pred_ans"))
if pred_ans == merchandise("reply"):
filtered_questions_dict.append(merchandise)

Implementierung des KNN-Modells

Nachdem wir den Trainingssatz verarbeitet und die CoT-Antwort für alle diese Fragen erhalten haben, betten wir nun alle Fragen ein mit dem Texteinbettung-ada-002 von OpenAI.

def get_embedding(textual content, mannequin="text-embedding-ada-002"):
return shopper.embeddings.create(enter = (textual content), mannequin=mannequin).knowledge(0).embedding
for merchandise in tqdm(filtered_questions_dict):
merchandise("embedding") = get_embedding(merchandise("query"))
inv_options_map = {v:okay for okay,v in merchandise("choices").gadgets()}
merchandise("answer_idx") = inv_options_map(merchandise("reply"))    

Wir trainieren nun ein KNN-Modell mit diesen Frageeinbettungen. Dies fungiert zur Inferenzzeit als Retriever, da es uns hilft, ähnliche Datenpunkte aus dem Trainingsset abzurufen, die der Frage aus dem Testset am ähnlichsten sind.

import numpy as np
from sklearn.neighbors import NearestNeighbors
embeddings = np.array((d("embedding") for d in filtered_questions_dict))
indices = listing(vary(len(filtered_questions_dict)))
knn = NearestNeighbors(n_neighbors=5, algorithm='auto', metric='cosine').match(embeddings)

Implementierung der dynamischen Few-Shot- und Alternative-Shuffling-Ensemble-Logik

Wir können jetzt Inferenzen ausführen. Für unsere Auswertung nehmen wir eine Teilstichprobe von 500 Fragen aus dem MedQA-Testset. Für jede Frage rufen wir mithilfe des KNN-Moduls die 5 ähnlichsten Fragen aus dem Trainingsset ab, zusammen mit ihren jeweiligen CoT-Argumentationsschritten und vorhergesagten Antworten. Anhand dieser Beispiele konstruieren wir eine Eingabeaufforderung mit wenigen Versuchen.

Für jede Frage mischen wir außerdem die Reihenfolge der Optionen fünfmal, um verschiedene Varianten zu erstellen. Anschließend verwenden wir die erstellte Eingabeaufforderung mit wenigen Versuchen, um die vorhergesagte Antwort für jede der Varianten mit gemischten Optionen zu erhalten.

def shuffle_option_labels(answer_options):
"""
Shuffles the choices of the query.
Parameters:
answer_options (dict): A dictionary with the choices.
Returns:
dict: A brand new dictionary with the shuffled choices.
"""
choices = listing(answer_options.values())
random.shuffle(choices)
labels = (chr(i) for i in vary(ord('A'), ord('A') + len(choices)))
shuffled_options_dict = {label: possibility for label, possibility in zip(labels, choices)}
return shuffled_options_dict

test_samples = read_jsonl_file("final_processed_test_set_responses_medprompt.jsonl")
for query in tqdm(test_samples, color ="inexperienced"):
question_variants = ()
prompt_variants = ()
cot_responses = ()
question_embedding = get_embedding(query("query"))
distances, top_k_indices = knn.kneighbors((question_embedding), n_neighbors=5)
top_k_dicts = (filtered_questions_dict(i) for i in top_k_indices(0))
query("outputs") = ()
for idx in vary(5):
question_copy = query.copy()
shuffled_options = shuffle_option_labels(query("choices"))
inv_map = {v:okay for okay,v in shuffled_options.gadgets()}
question_copy("choices") = shuffled_options
question_copy("answer_idx") = inv_map(question_copy("reply"))
question_variants.append(question_copy)
immediate = build_few_shot_prompt(system_prompt,  question_copy, top_k_dicts)
prompt_variants.append(immediate)
for immediate in tqdm(prompt_variants):
response = get_response(immediate, model_name="gpt-4o", max_tokens=500)
cot_responses.append(response)
for question_sample, reply in zip(question_variants, cot_responses):
if validate_response(reply):
cot, pred_ans = parse_answer(reply)
else:
cot = ""
pred_ans = ""
query("outputs").append({"query": question_sample("query"), "choices": question_sample("choices"), "cot": cot, "pred_ans": question_sample("choices").get(pred_ans, "")})

Wir bewerten nun die Ergebnisse von Medprompt anhand des Testsatzes. Für jede Frage haben wir fünf Vorhersagen, die durch die Ensemble-Logik generiert wurden. Wir nehmen den Modus oder die am häufigsten auftretende Vorhersage für jede Frage als endgültige Vorhersage und bewerten die Leistung. Hier sind zwei Randfälle möglich:

1. Es werden jeweils zwei unterschiedliche Antwortmöglichkeiten vorhergesagt, wobei es keinen klaren Sieger gibt.
2. Bei der generierten Antwort liegt ein Fehler vor. Dies bedeutet, dass uns keine vorhergesagte Antwortoption zur Verfügung steht.

In beiden Randfällen gehen wir davon aus, dass die Frage vom LLM falsch beantwortet wurde.

def find_mode_string_list(string_list):
"""
Finds essentially the most regularly occurring strings.
Parameters:
string_list (listing of str): A listing of strings.
Returns:
listing of str or None: A listing containing essentially the most frequent string(s) from the enter listing.
Returns None if the enter listing is empty.
"""    
if not string_list:
return None  
string_counts = Counter(string_list)
max_freq = max(string_counts.values())
mode_strings = (string for string, depend in string_counts.gadgets() if depend == max_freq)
return mode_strings
ctr = 0 
for merchandise in test_samples:
pred_ans = (x("pred_ans") for x in merchandise("outputs"))
freq_ans = find_mode_string_list(pred_ans)
if len(freq_ans) > 1:
final_prediction = ""
else:
final_prediction = freq_ans(0)
if final_prediction == merchandise("reply"):
ctr +=1
print(ctr / len(test_samples))

Wir bewerten die Leistung von Medprompt mit GPT-4o hinsichtlich der Genauigkeit im MedQA-Check-Subset. Darüber hinaus vergleichen wir die Leistung von Zero-Shot-Prompting, Random Few-Shot-Prompting und Random Few-Shot mit CoT-Prompting.

Wir beobachten, dass die Eingabeaufforderungen Medprompt und Random Few-Shot CoT die Baselines Zero und Few-Shot übertreffen. Überraschenderweise stellen wir jedoch fest, dass Random Few-Shot CoT unsere Medprompt-Leistung übertrifft. Dies könnte mehrere Gründe haben:

1. Im ursprünglichen Medprompt-Artikel wurde die Leistung von GPT-4 getestet. Wir stellen fest, dass GPT-4o GPT-4T und GPT-4 bei verschiedenen Textual content-Benchmarks deutlich übertrifft (https://openai.com/index/hello-gpt-4o/), was darauf hindeutet, dass Medprompt auf ein stärkeres Modell wie GPT-4o einen geringeren Effekt haben könnte.
2. Wir beschränken unsere Auswertung auf 500 Fragen, die aus MedQA ausgewählt wurden. Das Medprompt-Papier wertet andere medizinische MCQA-Datensätze und die Vollversion von MedQA aus. Die Auswertung von GPT-4o anhand der vollständigen Versionen der Datensätze könnte ein besseres Bild der Gesamtleistung vermitteln.

Medprompt ist ein interessantes Framework zum Erstellen anspruchsvoller Prompting-Pipelines, insbesondere zum Anpassen eines allgemeinen LLM an eine bestimmte Domäne, ohne dass eine Feinabstimmung erforderlich ist. Es hebt auch die Überlegungen hervor, die bei der Entscheidung zwischen Prompting und Feinabstimmung für verschiedene Anwendungsfälle anfallen. Es ist wichtig zu untersuchen, wie weit Prompting getrieben werden kann, um die LLM-Leistung zu verbessern, da es eine ressourcen- und kosteneffiziente Different zur Feinabstimmung bietet.

(1) Nori, H., Lee, YT, Zhang, S., Carignan, D., Edgar, R., Fusi, N., … & Horvitz, E. (2023). Können generalistische Grundlagenmodelle Spezialtuning übertreffen? Fallstudie in der Medizin. arXiv-Vorabdruck arXiv:2311.16452. (https://arxiv.org/abs/2311.16452)

(2) Wei, J., Wang, X., Schuurmans, D., Bosma, M., Xia, F., Chi, E., … & Zhou, D. (2022). Gedankenketten-Aufforderungen führen zum Denken in großen Sprachmodellen. Fortschritte bei neuronalen Informationsverarbeitungssystemen, 3524824–24837. (https://openreview.web/pdf?id=_VjQlMeSB_J)

(3) Gekhman, Z., Yona, G., Aharoni, R., Eyal, M., Feder, A., Reichart, R., & Herzig, J. (2024). Fördert die Feinabstimmung von LLMs auf neues Wissen Halluzinationen? arXiv-Vorabdruck arXiv:2405.05904. (https://arxiv.org/abs/2405.05904)

(4) Singhal, Okay., Azizi, S., Tu, T., Mahdavi, SS, Wei, J., Chung, HW, … & Natarajan, V. (2023). Große Sprachmodelle kodieren klinisches Wissen. Natur, 620(7972), 172–180. (https://www.nature.com/articles/s41586-023-06291-2)

(5) Singhal, Okay., Tu, T., Gottweis, J., Sayres, R., Wulczyn, E., Hou, L., … & Natarajan, V. (2023). Auf dem Weg zur Beantwortung medizinischer Fragen auf Expertenniveau mit großen Sprachmodellen. arXiv-Vorabdruck arXiv:2305.09617. (https://arxiv.org/abs/2305.09617)

(6) Jin, D., Pan, E., Oufattole, N., Weng, WH, Fang, H., & Szolovits, P. (2021). Welche Krankheit hat dieser Affected person? Ein umfangreicher Open-Area-Frage-Antwort-Datensatz aus medizinischen Untersuchungen. Angewandte Wissenschaften, 11(14), 6421. (https://arxiv.org/abs/2009.13081) (Der ursprüngliche Datensatz wird unter einer MIT-Lizenz veröffentlicht)