Gemini vs. ChatGPT: Wer schreibt besseren Code?

| Erstellt: März 1, 2024 | Aktualisiert am: April 2, 2024

Die Zeiten, in denen sich Elektroingenieure durchschlagen konnten, ohne auch nur eine einzige Zeile Code zu schreiben, sind vorbei. Das Beherrschen von Programmierkenntnissen ist mittlerweile eine erforderliche Fähigkeit, die für Ingenieure aller Fachrichtungen notwendig ist. Zwar müssen Ingenieure nicht verstehen, wie man eine komplette Webanwendung programmiert, aber grundlegende Skriptfähigkeiten sind wichtig. Die Analyse großer Datensätze erfordert beispielsweise einige Kenntnisse in der Programmierung. Für komplexere Aufgaben können sich Ingenieure in einer Zwickmühle wiederfinden und manchmal Stunden online nach einer bestimmten Funktion oder Lösung suchen. Mit der Veröffentlichung von ChatGPT hat sich die Welt zweifellos verändert, ebenso wie die Landschaft der automatisierten Codegenerierung. Ingenieure ohne fundierte Kenntnisse können nun mit Hilfe von generativer KI hochwertigen Code schreiben.

In früheren Artikeln wie Using ChatGPT for Altium Scripting und Using ChatGPT for Automated Testing haben wir untersucht, wie man generative KI, insbesondere ChatGPT, nutzen kann, um Code für uns zu schreiben. Bislang hinkte Google Bard (der Konkurrent von ChatGPT) hinterher, aber ein neues Modell, Gemini, hat angekündigt, dass es seinen Konkurrenten auf der Massive Multitask Language Understanding (MMLU)-Skala übertrifft:

Figure 1: Gemini’s MMLU performance metric

Abbildung 1: Leistungsmetrik von Gemini’s MMLU. Quelle: https://deepmind.google/technologies/gemini/#capabilities

In diesem Artikel werden wir ChatGPTs fortschrittlichsten Motor, GPT4, gegen Gemini Advanced (früher bekannt als Ultra), Googles fortschrittlichsten KI-Motor, antreten lassen, um zu sehen, wer besser im Generieren von Code ist.

Boilerplate-Code

Einen vollständig erschöpfenden Vergleich zwischen den beiden Motoren durchzuführen, wäre äußerst herausfordernd. In diesem Artikel werden wir uns anschauen, wie gut diese beiden Motoren Boilerplate-Code in Python generieren (da es eine der am meisten unterstützten Sprachen für das Schreiben von Code durch LLMs ist). Das ist keine exakte Wissenschaft, da gut gegen schlecht sehr subjektiv sein kann. Stattdessen werden wir jeden Motor einfach danach bewerten, ob der Code läuft und wie gut er unsere Anweisungen verstanden hat.

Aufgabe 1: Rekursiver Dateieigenschaften-Ausdruck

Um zu beginnen, schauen wir uns eine sehr einfache Skriptaufgabe an:

Entwickle ein Python-Automatisierungsskript, das, gegeben einen absoluten Pfad zu einem Ordner, die Metadaten jeder Datei rekursiv als Wörterbuchobjekt abruft. Drucke jedes Wörterbuchobjekt Zeile für Zeile aus und schließe den absoluten Pfad ein.

Lassen Sie uns zunächst den Code analysieren, der von GPT4 zurückkommt:

import os

def get_file_metadata(directory):

für foldername, subfolders, filenames in os.walk(directory):

für filename in filenames:

filepath = os.path.join(foldername, filename)

metadata = {

'filename': filename,

'path': filepath,

'size': os.path.getsize(filepath),

'last_modified': os.path.getmtime(filepath)

}

print(metadata)

get_file_metadata(os.path.dirname(os.path.abspath(__file__)))

Es ist prägnant, es funktioniert und erledigt die Aufgabe. Ich würde das durchgehen lassen. Es ist auch eine außergewöhnlich triviale Aufgabe, aber das ist in Ordnung.

Jetzt schauen wir uns den Code an, der von Gemini Advanced zurückkam:

import os

def get_file_metadata(file_path):

metadata = {}

try:

stat = os.stat(file_path)

metadata['name'] = os.path.basename(file_path)

metadata['size'] = stat.st_size # Größe in Bytes

metadata['modified_time'] = stat.st_mtime # Zeitstempel der letzten Änderung

metadata['accessed_time'] = stat.st_atime # Zeitstempel des letzten Zugriffs

except OSError:

print(f"Fehler beim Zugriff auf Datei: {file_path}")

return metadata

def retrieve_metadata_recursively(folder_path):

for root, _, files in os.walk(folder_path):

for file in files:

file_path = os.path.join(root, file)

metadata = get_file_metadata(file_path)

if metadata:

print(f"Absoluter Pfad: {file_path}") # Gibt den absoluten Pfad aus

print(metadata)

if __name__ == '__main__':

retrieve_metadata_recursively(os.path.dirname(os.path.abspath(__file__)))

Gemini ist etwas umständlicher, hat aber einige Fehlerbehandlungen hinzugefügt, was, denke ich, nett ist. Es ist etwas lang, aber es funktioniert, also lassen wir es durchgehen.

Aufgabe 2: Web-Scraper

Für die nächste Aufgabe wollte ich sehen, wie gut beide Engines eine gegebene Sprache verstehen und darauf basierend einen Parser erstellen können. In diesem Fall werden wir einen Web-Scraper bauen, der folgende Anweisung verwendet:
Schreibe ein Python-Skript mit BeautifulSoup oder Scrapy, das die Top-Nachrichtenüberschriften von 'https://news.ycombinator.com' abruft und sie in ein Wörterbuch-Objekt ausgibt.

Hier ist ein Ausschnitt der Seitenquelle von 'https://news.ycombinator.com'. Nutze dies, um zu bestimmen, wie die Tags herausgefiltert werden können.

Schreibe ein Python-Skript mit BeautifulSoup oder Scrapy, das die Top-Nachrichtenüberschriften von 'https://news.ycombinator.com' abruft und sie in ein Wörterbuch-Objekt ausgibt.

Hier ist ein Ausschnitt der Seitenquelle von 'https://news.ycombinator.com'. Nutze dies, um zu bestimmen, wie die Tags herausgefiltert werden können.

Wie Sie bemerken werden, habe ich etwas HTML in meine Aufforderung aufgenommen. Mein eigentlicher Aufforderungstext besteht aus mehr HTML, aber ich habe ihn für diesen Artikel gekürzt. Hier ist, was GPT4 generiert hat:

import requests
from bs4 import BeautifulSoup

# URL der zu scrapenden Seite
url = 'https://news.ycombinator.com'

# Senden einer GET-Anfrage an die URL
response = requests.get(url)

# Parsen des HTML-Inhalts der Seite mit BeautifulSoup
soup = BeautifulSoup(response.text, 'html.parser')

# Finden Sie alle Nachrichtenüberschriften
headlines = soup.find_all('tr', class_='athing')

# Wörterbuch zum Speichern von Überschriften, wobei der Schlüssel der Rang und der Wert der Überschriftentext ist
news_headlines = {}

# Durchlaufen Sie jede Überschrift, extrahieren und speichern Sie sie im Wörterbuch
for headline in headlines:
rank = headline.find('span', class_='rank').text.strip('.')
title = headline.find('span', class_='titleline').text
news_headlines[rank] = title

# Ausgabe des Wörterbuchs
print(news_headlines)

Dieser Code funktioniert einwandfrei und tut, was er soll. Ich hatte gehofft, dass er intuitiv erkennen würde, dass ich den Link zu den Artikeln wollte, aber ich war nicht explizit, also kann ich das nicht als Minuspunkt für die Bewertung von GPT4 verwenden.

Hier ist, was Gemini generiert hat:

import requests
from bs4 import BeautifulSoup

# Senden Sie eine HTTP GET-Anfrage an die Hacker News-Website
response = requests.get("https://news.ycombinator.com/")

# Parsen des HTML-Inhalts mit BeautifulSoup
soup = BeautifulSoup(response.content, "html.parser")

# Finden aller Elemente der Klasse 'athing', die die Nachrichtenartikel enthalten
articles = soup.find_all("tr", class_="athing")

# Erstellen eines leeren Wörterbuchs zum Speichern der Schlagzeilen
headlines = {}

# Durchlaufen jedes Artikels und Extrahieren der Schlagzeile und URL
for article in articles:
# Finden des Schlagzeilenelements
headline_element = article.find("span", class_="titleline")
headline = headline_element.find("a").text.strip()

# Finden des URL-Elements
url_element = headline_element.find("a")
url = url_element["href"]

# Hinzufügen der Schlagzeile und URL zum Wörterbuch
headlines[headline] = url

# Ausgeben des Wörterbuchs der Schlagzeilen
print(headlines)

Das funktioniert auch und es ist GPT4s Ausgabe ziemlich ähnlich, aber dieser Code extrahiert tatsächlich die URL. Das ist zwar schön, aber wiederum keine Erwartung. In dieser Herausforderung würde ich sagen, sind sie ziemlich gleich. Vielleicht bekommt Gemini einen zusätzlichen Punkt dafür, ein Gedankenleser zu sein.

Aufgabe 3: Aktien-Webanwendung

Für diese Aufgabe möchte ich eine Webanwendung erstellen, die Aktiencharts von einigen verschiedenen Tickersymbolen zeichnet:

Erstelle eine Webanwendung in Python, die Charts der folgenden Aktien zeigt: RIVN, TSLA, NKLA, FSR

Diese war definitiv kniffliger. Sie erfordert eine Frontend-Komponente (d.h. Grafiken/Bilder) und eine Backend-Komponente (d.h. das Abrufen der Daten aus einer Aktiendatenbank). Ich habe unzählige Anwendungen mit GPT4 generiert und wollte sehen, wie sich Gemini im Vergleich dazu schlägt. Hier ist, was GPT4 für mich generiert hat:

from flask import Flask, render_template_string
import yfinance as yf
import plotly.graph_objects as go
from datetime import datetime

app = Flask(__name__)

@app.route('/')
def home():
stocks = ['RIVN', 'TSLA', 'NKLA', 'FSR']
start = datetime(2021, 1, 1)
end = datetime.now()

fig = go.Figure()

für stock in stocks:
df = yf.download(stock, start=start, end=end)
fig.add_trace(go.Scatter(x=df.index, y=df.Close, mode='lines', name=stock))

graph_html = fig.to_html(full_html=False)

return render_template_string("""
<html>
<body>
{{ graph_html | safe }}
</body>
</html>

Figure 2: Screenshot of GPT4 generated web application

Abbildung 2: Screenshot der von GPT4 generierten Webanwendung

Es ist einfach, übersichtlich und auf den Punkt gebracht. Keine Spielereien, aber erfüllt seinen Zweck. Hier ist, was Gemini für mich generiert hat:

import flask
von flask import render_template
import yfinance als yf
import plotly.graph_objects als go

app = flask.Flask(__name__)

# Aktiensymbole
tickers = ['RIVN', 'TSLA', 'NKLA', 'FSR']

# Aktiendaten mit yfinance abrufen
def get_stock_data(ticker):
start_date = '2023-02-10' # Startdatum nach Bedarf anpassen
end_date = '2024-02-10' # Heutiges Datum
return yf.download(ticker, start=start_date, end=end_date)

@app.route('/')
def index():
stock_data = {}
für ticker in tickers:
stock_data[ticker] = get_stock_data(ticker)

charts = []
for ticker, data in stock_data.items():
fig = go.Figure(data=[go.Candlestick(x=data.index,
open=data['Open'],
high=data['High'],
low=data['Low'],
close=data['Close'])])
fig.update_layout(title=ticker)
charts.append(fig.to_html(full_html=False, include_plotlyjs='cdn'))

return render_template('index.html', charts=charts)

wenn __name__ == '__main__':
app.run(debug=True)

Es erforderte auch, dass ich eine neue Datei, index.html, in einem neuen Verzeichnis namens templates erstelle:

<!DOCTYPE html>
<html>
<head>
<title>Aktiencharts</title>
<script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
</head>
<body>
{% for chart in charts %}
<div id="{{ loop.index0 }}"></div>
<script>
Plotly.newPlot('{{ loop.index0 }}', {{ chart | safe }});
</script>
{% endfor %}
</body>
</html>

Figure 3: Screenshot of Gemini Advanced generated web application

Abbildung 3: Screenshot der von Gemini Advanced generierten Webanwendung

Dies war definitiv ausgefallener, da es ein Histogramm enthielt und den HTML-Inhalt in eine neue Datei abstrahierte. Auch hier waren beide funktional, daher erhalten beide eine bestandene Bewertung.

Fehler und Halluzinationen

Als GPT4 zum ersten Mal herauskam, dauerte es eine Weile, bis man verstand, wie man es richtig „auffordert“. Wenn man generative KI verwendet, um Code zu schreiben, spielen Details eine Rolle. Als Ergebnis sind viele von uns im Laufe des letzten Jahres zu kompetenteren „Prompt-Ingenieuren“ geworden. Leider kann dies einige Vorurteile einführen, wenn man GPT4 mit anderen Engines vergleicht, und das gebe ich gerne zu. Ich weiß, wie GPT4 „funktioniert“, mehr als wie Gemini funktioniert. Die Art und Weise, wie ich Aufforderungen für GPT4 gestalte, könnte anders sein als das, was Gemini erwartet. Trotzdem bin ich auf einige sehr grundlegende Probleme mit Gemini gestoßen.

Ein häufiges Problem, das ich bei der Interpretation von Anweisungen durch Gemini festgestellt habe, war die Generierung von Unit-Tests. Mein ursprüngliches Ziel war es, Unit-Tests in dem Artikel zu behandeln, aber aus Frustration gab ich Gemini vollständig auf, weil es nie den Anweisungen folgte. Zum Beispiel bat ich Gemini, einen Unit-Test mit Pytest zu schreiben und ihn in einer Klasse zu kapseln. Es generierte den Test stattdessen mit UnitTest, ignorierte meine Anfrage offensichtlich, kapselte den Code jedoch in einer Klasse ein. Ich korrigierte es und es erkannte an, dass es versehentlich UnitTest anstelle von Pytest verwendet hatte. Dann würde es den Code mit Pytest neu schreiben, aber vergessen, ihn in eine Klasse zu setzen. Wenn ich es bat, eine Mock-Konstruktion zu verwenden, griff es standardmäßig auf Mock von UnitTest zurück anstatt auf Mock von Pytest. Das sind Nuancen, aber wichtig beim Umgang mit generativer KI.

Figure 4: Gemini Advanced not following directions

Abbildung 4: Gemini Advanced folgt nicht den Anweisungen

Die Fehlersuche war ein weiterer Schmerzpunkt. Die Reasoning-Engine von GPT4 hat sich als ziemlich leistungsfähig erwiesen, wenn es darum geht, Fehler in Python zu debuggen. Gemini… nicht so sehr. Als ich es bat, bestimmte Probleme zu beheben, versuchte es einfach, den Code mit zusätzlichen Einrückungen oder dem Austauschen von Variablen neu zu schreiben… eine völlig nutzlose Antwort.

Manchmal funktionierte Gemini einfach nicht. Es sagte, es könne meine Anfrage nicht verarbeiten. In anderen Fällen begann es, über die... bevorstehende Wahl zu kommentieren?

Gemini Advanced confused about the upcoming elections?

Abbildung 5: Gemini Advanced verwirrt über die bevorstehende Wahl?

Fazit

Insgesamt war die Qualität des generierten Standardcodes von Gemini ziemlich konkurrenzfähig gegenüber GPT4. Die Erfahrung und sein Begründungsmotor ließen jedoch viel zu wünschen übrig. Glücklicherweise für Google sind diese Teile Teil der Implementierung des LLM und nicht das LLM selbst. Mit anderen Worten, das Gemini LLM scheint grundsätzlich ziemlich gut zu sein und auf Augenhöhe mit GPT4, aber der Code, der darum herum geschrieben wird und der in der Chat-Erfahrung verwendet wird, benötigt etwas Hilfe. Mit der Zeit werden wir wahrscheinlich sehen, wie Google an ihrem Code arbeitet und diese Erfahrung und den Begründungsmotor verbessert.

Über den Autor / über die Autorin

Ari ist ein PCB-Designer mit umfassender Erfahrung in der Entwicklung, Herstellung, Prüfung und Integration verschiedener Softwaresysteme. Dabei bringt er leidenschaftlich gern Entwickler aus den Bereichen Design, Prüfung und Abnahme zusammen, um gemeinsam an Projekten zu arbeiten und diese voranzutreiben.

Mehr Beiträge von Ari Mahpour