Die Leistungsfähigkeit großer Sprachmodelle für die Datenintegration nutzen

Begeben Sie sich mit uns auf eine Reise in die Zukunft der Datenintegration – eine Zukunft, in der Large Language Models (LLMs) den Schlüssel zur Revolution dieses Prozesses halten. Entdecken Sie, wie LLMs unterschiedliche Daten aus verschiedenen Quellen und Formaten nahtlos vereinen und so genauere Analysen ermöglichen. Erleben Sie faszinierende Experimente, die zeigen, wie LLMs menschenähnlichen Text erzeugen, um unterschiedliche Datensätze zu integrieren. Und erfahren Sie mehr über künftige Überlegungen und Herausforderungen – darunter Flexibilität, Zuverlässigkeit und Sicherheit.

In diesem Artikel untersuchen wir, wie Large Language Models (LLMs) genutzt werden können, um Daten aus verschiedenen Quellen und Formaten zu integrieren. Wir besprechen die Herausforderungen heterogener Daten, stellen ein interessantes Experiment mit LLMs zur Datenintegration vor und beleuchten die potenziellen Chancen und Risiken dieses Ansatzes. Grundkenntnisse in Python und Datenverarbeitung sind hilfreich, um dem Artikel folgen zu können.

Die Herausforderung: Daten aus verschiedenen Quellen zusammenführen

Werden Daten aus verschiedenen Formaten, Typen und Quellen in einer einheitlichen Datenstruktur zusammengeführt, lassen sich wertvolle Erkenntnisse gewinnen. Dieser Prozess erfordert jedoch oft viel manuelle Arbeit, Aufwand und Zeit – und ist damit kostspielig. Dadurch bleiben wertvolle Erkenntnisse häufig ungenutzt.

Large Language Models (LLMs) haben in den vergangenen Monaten erhebliche Aufmerksamkeit auf sich gezogen. Die Frage liegt nahe: Können diese leistungsstarken KI-Werkzeuge dabei helfen, die Integration von Daten aus verschiedenen Quellen zu beschleunigen oder sogar vollständig zu automatisieren?

Ein interessantes Experiment

Stellen Sie sich vor, Sie haben Daten in einem JSON-ähnlichen Format (z. B. ein Python-Dictionary) und ähnliche Daten in einem anderen Format – etwa einer HTML-Tabelle von einer Website. Wir möchten die Daten aus der HTML-Tabelle einlesen und mit den Daten im Python-Dictionary zusammenführen.

Dazu können wir ein Large Language Model mit einer Python-Bibliothek – beispielsweise OpenAIs GPT-3.5 (Chat GPT) – verwenden und ihm einen Prompt wie diesen übergeben*:

data_json = { "restaurant employees" :[
{"name":"Hans", "email":"hansmeier@gmail.com"},
{"name":"Vanessa", "email":"van1988@gmail.com"},
]}
html_table = """<table>
<caption>Restaurant Employees</caption>
<thead>
<tr>
<th>Name</th>
<th>Email</th>
</tr>
</thead>
<tbody>
<tr>
<td>Shyam</td>
<td>shyamjaiswal@gmail.com</td>
</tr>
<tr>
<td>Bob</td>
<td>bob32@gmail.com</td>
</tr>
<tr>
<td>Jai</td>
<td>jai87@gmail.com</td>
</tr>
</tbody>
</table>"""

prompt = f"""Extract the data from an HTML table and append it to a JSON.
Follow these steps:

Extract the data from the HTML table into a JSON of the same format as the  
provided JSON  
join the two JSONs and return a JSON

The JSON (in python dict format):
{data_json}

The html table:
{html_table}

Structure you output as follows:

extracted_JSON = <json format>

final_JSON = <json format>
"""
response = get_completion(prompt)
print(response)

Der Output dieses Prompts lautet:

extracted_JSON = {'restaurant employees': [{'name': 'Shyam', 'email':
'shyamjaiswal@gmail.com'}, {'name': 'Bob', 'email': 'bob32@gmail.com'},
{'name': 'Jai', 'email': 'jai87@gmail.com'}]}

final_JSON = {'restaurant employees': [{'name': 'Hans', 'email':
'hansmeier@gmail.com'}, {'name': 'Vanessa', 'email': 'van1988@gmail.com'},
{'name': 'Shyam', 'email': 'shyamjaiswal@gmail.com'}, {'name': 'Bob',
'email': 'bob32@gmail.com'}, {'name': 'Jai', 'email': 'jai87@gmail.com'}]}

Dieses Experiment zeigt, dass LLMs verschiedene Datenformate verstehen und ohne menschliches Eingreifen in ein einheitliches Format zusammenführen können.

Die Magie – und die Risiken

So beeindruckend das auch klingen mag: Diesen Ansatz im Produktivbetrieb einzusetzen, wäre leichtsinnig, teuer und sogar gefährlich. Das Übermitteln von Rohdaten an Dritte kann gegen Datenschutzrichtlinien verstoßen, jede Datentransformation erfordert rechenintensive LLM-Aufrufe, und LLMs produzieren gelegentlich unerwartete Outputs oder Fehler, die zu unbrauchbaren Ergebnissen führen können.

Trotz dieser Bedenken sind die Fähigkeiten von LLMs beeindruckend. Lässt sich ein zuverlässigerer und sichererer Einsatz realisieren?

Ein besserer Ansatz: Code mit LLMs generieren

Anstatt das LLM zu bitten, die Daten direkt zu transformieren, können wir es auffordern, Python-Code bereitzustellen, der die Transformation für uns übernimmt.

Versuchen wir folgenden Prompt:

prompt = f"""
Write a python code that Extracts the data from an HTML table and append  
it to a python dict.
It should follow these steps:
Extract the data from the HTML table into a python dict of the same format  
as the provided python dict  
join the two python dict and return a python dict

The python dict:
{data_json}

The html table:
{html_table}

your outout should be three python functions:
transfrom_html_to_dict(html)
,
join_dicts(dict1,dict2)
and  
transform_and_join(htms, dict)
"""

Das LLM gibt Python-Code wie diesen aus:

Here's the code for the three functions:

from bs4 import BeautifulSoup

def transform_html_to_dict(html):
    soup = BeautifulSoup(html, 'html.parser')
    table = soup.find('table')
    rows = table.find_all('tr')
    headers = [header.text.strip() for header in rows[0].find_all('th')]
    data = []
    for row in rows[1:]:
values = [value.text.strip() for value in row.find_all('td')]
data.append(dict(zip(headers, values)))
    return {'restaurant employees': data}

def join_dicts(dict1, dict2):
    for key in dict2:
if key in dict1:
    dict1[key].extend(dict2[key])
else:
    dict1[key] = dict2[key]
    return dict1

def transform_and_join(html, dict1):
    dict2 = transform_html_to_dict(html)
    return join_dicts(dict1, dict2)

Die Funktion transform_html_to_dict nimmt einen HTML-String als Eingabe, nutzt BeautifulSoup zum Parsen und extrahiert die Daten aus der Tabelle in ein Python-Dict. Das resultierende Dict hat dasselbe Format wie das bereitgestellte Dict.

Die Funktion join_dicts nimmt zwei Dicts als Eingabe und führt sie zu einem einzigen Dict zusammen. Existiert ein Key in beiden Dicts, werden die Werte zu einer einzelnen Liste kombiniert.

Die Funktion transform_and_join vereint die Funktionalität der beiden vorherigen Funktionen: Sie transformiert zunächst das HTML mithilfe von transform_html_to_dict in ein Dict und führt dieses anschließend über join_dicts mit dem bereitgestellten Dict zusammen. Das Endergebnis wird als einzelnes Dict zurückgegeben.

Diesen Code in ein Python-Skript zu kopieren und auszuführen, liefert folgendes Ergebnis:

{'restaurant employees': [{'name': 'Hans', 'email': 'hansmeier@gmail.com'}, 
{'name': 'Vanessa', 'email': 'van1988@gmail.com'}, 
{'Name': 'Shyam', 'Email': 'shyamjaiswal@gmail.com'}, 
{'Name': 'Bob', 'Email': 'bob32@gmail.com'}, 
{'Name': 'Jai', 'Email': 'jai87@gmail.com'}]}

Abgesehen von der Großschreibung der Keys 'Name' und 'Email' entspricht das Ergebnis den Erwartungen.

Obwohl für Feinabstimmung und Schutzmechanismen noch Entwicklungsarbeit nötig ist, kann dieser Ansatz einige der Herausforderungen der ursprünglichen Methode adressieren:

• Es müssen nur Beispieldaten – die anonymisiert oder als Dummy-Daten vorliegen können – an den KI-Anbieter übermittelt werden.
• Weniger API-Aufrufe sind erforderlich, was die Kosten senkt.
• Datentransformationen können On-Premises erfolgen und so die Einhaltung von Datenschutzvorschriften sicherstellen.
• Sind die Funktionen einmal getestet, arbeiten sie so zuverlässig wie jedes andere Python-Skript.

Künftige Überlegungen und Herausforderungen

Die hier besprochenen Experimente deuten auf enormes Potenzial beim Einsatz von LLMs zur Vereinheitlichung heterogener Daten hin. Bevor dieser Ansatz jedoch im Produktivbetrieb breit eingesetzt werden kann, müssen mehrere Fragen geklärt werden:

• Flexibilität: Können Prompts so formuliert werden, dass sie mit einer breiten Palette von Datenformaten funktionieren – oder müssen für jeden neuen Datentyp neue Prompts entwickelt werden?
• Zuverlässigkeit: Lassen sich ausreichend allgemeine Tests entwickeln, um sicherzustellen, dass die generierten Funktionen wie vorgesehen funktionieren? Kann der Testprozess – einschließlich der Testerstellung – automatisiert werden?
• Sicherheit: Das automatisierte Ausführen von KI-generiertem Code wirft neue Cybersicherheitsfragen auf, die adressiert werden müssen.

Auch wenn LLMs noch einen weiten Weg vor sich haben, um die Datenintegration grundlegend zu revolutionieren, sind die ersten Experimente vielversprechend. Es ist essenziell, diese Richtung weiterzuverfolgen – nicht nur, um das volle Potenzial der KI auszuschöpfen, sondern auch, um Data Scientists von Routineaufgaben zu entlasten und ihnen Raum für kreativere und erfüllendere Arbeit zu geben. Vorwärts!

Fußnoten:

Die Methode get_completion kapselt einen API-Aufruf an OpenAI unter Verwendung des openai-Python-Pakets.

def get_completion(prompt, model="gpt-3.5-turbo", temperature=0):
    messages = [{"role": "user", "content": prompt}]
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=temperature,
    )
    return response.choices[0].message["content"]

Bitte beachten Sie: Dieser Code setzt die OpenAI API voraus. Sie benötigen gültige API-Zugangsdaten sowie das installierte openai-Python-Paket, um ihn nutzen zu können.