Dieser Beitrag wurde von einer KI übersetzt und nur oberflächlich durch Rückübersetzung überprüft.

Warum sich mehrsprachiges Bloggen lohnt

Als ich meinen Blog zuletzt aktualisierte, gestaltete ich ihn speziell mit der Möglichkeit, Inhalte in mehreren Sprachen anzubieten. Da sich die meisten meiner Inhalte auf synthetische Biologie, Programmierung und gelegentlich amerikanische Graduiertenschulen beziehen, gehe ich davon aus, dass die meisten meiner Leser wahrscheinlich bereits einigermaßen gut Englisch sprechen, meiner Muttersprache. Etwa 90 % der wissenschaftlichen Literatur werden in Englisch veröffentlicht. Die Programmierung befindet sich in einer ähnlichen Situation, wobei wichtige Sprachen wie Java, C und Python größtenteils (aber nicht ausschließlich) in Englisch programmiert werden. Mir sind keine Biologie-Graduiertenprogramme in den Vereinigten Staaten bekannt, die Kurse außerhalb des Englischen anbieten.

Ein Teil meiner Leser wird jedoch weniger sicher im Englischen sein als in ihrer Muttersprache. Zum Beispiel berichten viele kolumbianische Forscher, dass ihre Arbeiten aufgrund von Grammatik abgelehnt wurden. Es ist sicherlich der Fall, dass einige potenzielle Leser überhaupt kein Englisch lesen können. Dies könnten Studierende oder neugierige nicht-wissenschaftliche Leser sein. Um ein größeres Publikum zu erreichen und meine Inhalte für diese Gemeinschaften zugänglicher zu machen, benötige ich eine Möglichkeit, meine Inhalte schnell und sauber in andere Sprachen zu übersetzen.

Auswahl der Zielsprachen

Ich wünschte, ich könnte sagen, dass ich die Sprachen, die ich gewählt habe, aus einem ausgeklügelten Grund ausgewählt habe, aber ehrlich gesagt geht es hauptsächlich um die Reichweite. Englisch ist meine Muttersprache und die Sprache, in der ich schreibe, also ist das automatisch. Ich wollte auch Deutsch, Französisch und Spanisch einbeziehen, da dies Sprachen sind, die dem Englisch nahe stehen und einen anständigen Maßstab für den Vergleich bieten. Hindi und vereinfachtes Chinesisch sind aufgrund der großen Anzahl von Menschen, die diese Sprachen sprechen, enthalten. Ich habe Arabisch hinzugefügt, weil ich es interessant fand, eine Sprache hinzuzufügen, die von links nach rechts geschrieben wird, mit der eventualen Absicht, sie rechtsbündig auszurichten. Ich habe auch Kollegen, die jede dieser Sprachen sprechen, von denen ich Feedback erhalten kann.

Aufbau der Pipeline

Nutzung von KI für Übersetzungen

Es gibt eine Menge Literatur darüber, warum man generative KI (z. B. OpenAI) im Vergleich zu einem regelbasierten System (z. B. Google Translate) für den Aufbau automatisierter Übersetzungen wählen könnte. Der Hauptgrund, warum ich mich für OpenAI entschieden habe, ist persönliche Erfahrung. Beim Übersetzen von Inhalten aus anderen Sprachen ins Englische habe ich festgestellt, dass regelbasierte Übersetzungen oft eine ungeschickte Grammatik zurückgeben. Ich kann mir nicht vorstellen, dass andere Sprachen eine bessere Erfahrung bieten würden. Durch die Nutzung von KI hoffe ich, natürlichere Übersetzungen zu erhalten.

Einrichtung der OpenAI-Pipeline

OpenAI hat bereits ein einfaches und gut dokumentiertes Python-Paket, das ihre API umschließt. Da ich bereits gut in Python erfahren bin, war die Verwendung dafür für mein Übersetzungssetup eine einfache Entscheidung.

Zuerst müssen Sie sicherstellen, dass Sie einen OpenAI-Schlüssel eingerichtet haben. Dies erfordert auch, dass Sie Geld auf Ihr Konto laden. Ich habe jedoch festgestellt, dass das Übersetzen von Blogbeiträgen auf diese Weise mich mit den aktuellen Preisen und den 4o-mini-Modellen weniger als einen Cent kostet. Diese API ist offensichtlich eher auf kontinuierliche Dienste ausgerichtet, die im Laufe der Zeit viele API-Aufrufe tätigen, als auf unsere Anwendung, die es nur gelegentlich für Übersetzungen aufruft.

Um Ihren Schlüssel einzurichten, besuchen Sie die Entwicklerplattform von OpenAI, navigieren Sie zu Ihrem Dashboard, dann zu API-Schlüsseln und erstellen Sie einen neuen geheimen Schlüssel. Sie müssen diesen Schlüssel für später aufbewahren. Bewahren Sie ihn an einem sicheren, privaten Ort auf, da er es jedem, der ihn hat, ermöglicht, Ihre OpenAI-Mittel für beliebige Zwecke zu verwenden.

Wir können den Schlüssel mit einem einfachen Python-Skript testen, um sicherzustellen, dass wir ihn korrekt eingerichtet haben.

"""Überprüfen, ob der OpenAI API-Schlüssel gültig ist."""
   key = get_openapi_key()
   client = OpenAI(api_key=key)

   completion = client.chat.completions.create(
   	model="gpt-4o-mini",
   	messages=[
       	{
           	"role": "system",
           	"content": "Sie sind eine Gesundheitsprüfungs-API. Antworten Sie einfach mit 'OK'",
       	},
       	{"role": "user", "content": "Überprüfen"},
   	],
   )
   if completion.choices[0].message.content == "OK":
   	print("OpenAI-Schlüssel ist gültig und funktioniert")
   else:
   	print(completion.choices[0].message)

Jetzt, da wir überprüft haben, dass der Schlüssel funktioniert, können wir die Pipeline einrichten. Wir bieten keinen Live-Service an, daher können wir die Batch-API von OpenAI nutzen, um viel Geld zu sparen. Die Batch-API ist dafür ausgelegt, für große Mengen von Anfragen verwendet zu werden, die keine sofortigen Antworten erfordern, sodass sie langsamer sein können. Es ist jedoch egal, wie viele Anfragen Sie senden, und es kostet zur Zeit des Schreibens nur die Hälfte. Dies senkt die Kosten auf einen Bruchteil eines Cent, um einen Blogbeitrag in jede Sprache zu übersetzen, die uns interessiert.

OpenAPI erfordert, dass ihre Anfragen in einem bestimmten Format vorliegen. Wir müssen der KI mitteilen, was sie ist (ein Übersetzungstool), welches Modell wir verwenden und in welche Sprache wir übersetzen. Ich habe gelesen, dass es hilfreich ist, auch einen bestimmten Dialekt anzugeben, also werden wir diese Option ebenfalls hinzufügen.

def openai_format(
	id: str, model: str, language: str, dialect: str, content: str
) -> dict:
	if dialect:
    	system_message = f"""Sie sind ein Übersetzungs-Backend.
    	Übersetzen Sie die Benutzereingabe ins {language} unter Verwendung eines {dialect}
    	Dialekts. Geben Sie nur die Übersetzung zurück und bewahren Sie die
    	Markdown-Struktur. Es ist möglich, dass Sie mitten in einem Codeblock
    	beginnen."""
	else:
    	system_message = f"""Sie sind ein Übersetzungs-Backend.
    	Übersetzen Sie die Benutzereingabe ins {language}. Geben Sie nur die
    	Übersetzung im passenden Markdown-Format zurück. Es ist
    	möglich, dass Sie mitten in einem Codeblock beginnen."""
	formatted_prompt = {
    	"custom_id": id,
    	"method": "POST",
    	"url": "/v1/chat/completions",
    	"body": {
        	"model": model,
        	"messages": [
            	{"role": "system", "content": system_message},
            	{"role": "user", "content": content},
        	],
        	"temperature": 0.1,
    	},
	}
	return formatted_prompt

Jetzt, da wir eine Funktion haben, die uns hilft, unsere Anfragen zu formatieren, können wir sie mit dem Python-Paket von OpenAI bündeln. Die API mag ihre Anfragen im JSON-Format, also werden wir ein temporäres Verzeichnis verwenden, um unsere Anfragen in eine Datei zu schreiben, und dann das Python-Paket verwenden, um die Anfragen an die API zu senden. Dies gibt uns eine Batch-ID, die wir im Auge behalten müssen, da dies der Weg ist, wie wir die Ergebnisse abrufen.

import json
from tempfile import TemporaryDirectory
from openai import OpenAI

def send_openai_batch(formatted_prompts: list, description=None):
	key = get_openapi_key()
	client = OpenAI(api_key=key)
	if not description:
    	description = "Markdown-Übersetzungsbatch"
	with TemporaryDirectory() as tmpdirname:
    	with open(f"{tmpdirname}/batchinput.json", "a") as f:
        	for prompt in formatted_prompts:
            	f.write(json.dumps(prompt) + "\n")

    	batch_input_file = client.files.create(
        	file=open(f"{tmpdirname}/batchinput.json", "rb"),
        	purpose="batch"
    	)

    	batch_input_file_id = batch_input_file.id

    	batch = client.batches.create(
        	input_file_id=batch_input_file_id,
        	endpoint="/v1/chat/completions",
        	completion_window="24h",
        	metadata={"description": description},
    	)
	return batch

Jetzt, da wir unsere Anfrage gesendet haben, müssen wir warten, bis der Batch abgeschlossen ist. Auch wenn wir die langsamere Batch-API verwenden, dauert dieser Prozess normalerweise nur ein paar Minuten. Wenn wir versuchen, die Ergebnisse abzurufen, bevor es fertig ist, wird ein Fehler auftreten. Stattdessen können wir die ID verwenden, um den Batch in einer Schleife zu überprüfen und die Ergebnisse danach abzurufen.

from time import sleep

def openai_check_results(batch_id: str):
	key = get_openapi_key()
	client = OpenAI(api_key=key)
	result = client.batches.retrieve(batch_id)
	return result


def wait_for_openai(batch_id: str):
	while True:
    	result = openai_check_results(batch_id)
    	if result.status in ["validating", "in_progress"]:
        	print(f"Warten auf OpenAI (Batch ist {result.status})")
        	sleep(5)
        	continue
    	else:
        	break
	if result.status in ["failed", "expired",
                 	"canceling", "canceled"]:
    	raise ValueError(f"OpenAI-Batch {batch_id} fehlgeschlagen")

Das tatsächliche Ergebnis zu erhalten, ist sehr einfach. Sobald wir das grüne Licht bekommen, können wir einfach den Text aus dem Ergebnisobjekt abrufen. Der zurückgegebene Wert ist eine Reihe von im JSON-Format formatierten Zeichenfolgen in einem ähnlichen Format, das wir für die Anfrage verwendet haben. Sobald wir das JSON laden, ist die Antwort von OpenAI in result["response"]["body"]["choices"][0]["message"]["content"] verborgen.

from collections import defaultdict

def build_openai_results(batch_id: str):
	key = get_openapi_key()
	client = OpenAI(api_key=key)
	result = openai_check_results(batch_id)

	file_response = client.files.content(result.output_file_id
	).text.split("\n")

	result_dict = defaultdict(dict)

	for json_str in file_response:
    	if json_str == "":
        	continue
    	result = json.loads(json_str)
    	id = result["custom_id"]
    	result_dict[id] = result["response"]["body"][
            	"choices"][0]["message" ]["content"]

	return result_dict

Fazit

Und das war's! Wir können jetzt OpenAI nutzen, um unsere Blogbeiträge (oder jeden anderen Inhalt) in jede Sprache zu übersetzen, die wir wollen. Stellen Sie sicher, dass Sie vor der Durchführung von Übersetzungen alle Korrekturen vornehmen, da ich nicht garantieren kann, wie sich das Modell verhalten könnte. Ich habe dies ein wenig weitergeführt, indem ich mehr von dem Prozess automatisiert habe. Mein System nimmt automatisch Markdown-Dateien entgegen. Es teilt die Dateien auch in kleinere Abschnitte auf, da ich festgestellt habe, dass die KI etwas abgelenkt werden kann, wenn sie eine große Datei zum Übersetzen erhält. Ich habe dies in ein separates Repository gepackt, das Sie hier finden können. Der Code ist MIT-lizenziert, also fühlen Sie sich frei, ihn nach Belieben zu verwenden.