Codegeneratie: ChatGPT van OpenAI vergeleken met GitHub Copilot

Person standing on a mountain trail surrounded by greenery, holding a water bottle with a cable car in the background.

Gepubliceerd op 28 december 2022 door Ilya Grishkov

28 december 2022

AI-codegeneratie is een vakgebied binnen de kunstmatige intelligentie dat machine learning-algoritmes gebruikt om automatisch code te schrijven. Een van de recente ontwikkelingen hierin is de inzet van nieuwere natural language processing-modellen (NLP) en AI om codegeneratie nauwkeuriger en efficiënter te maken.

GitHub lanceerde zijn vernieuwende product CoPilot in oktober 2021. CoPilot stelt codefragmenten voor op basis van je invoer, via commentaarregels en methodeskeletten. Daarnaast doet CoPilot suggesties voor verbeteringen of aanvullingen, als een zeer geavanceerde autocomplete in je IDE.

Sinds de lancering op 30 november 2022 gaat het echter overal over ChatGPT. ChatGPT groeide spectaculair: één miljoen gebruikers in vijf dagen, een wereldrecord. ChatGPT gebruikt een variant van het GPT-3.5-taalmodel om code te genereren op basis van natuurlijke taal. Je beschrijft in een chat wat je wilt hebben (vandaar de naam), en de chatbot genereert de bijbehorende code in uiteenlopende programmeertalen.

Nu beide tools beschikbaar zijn: waar gaat al die drukte over? Kunnen ze softwareontwikkeling echt sneller en nauwkeuriger maken? Laten we ze eerst eens van dichtbij bekijken.

ChatGPT

Een van de grote voordelen van ChatGPT is het verwerken van natuurlijke taal (NLP). Developers kunnen in gewoon Nederlands of Engels opschrijven welke code ze willen, waarna ChatGPT die genereert.

Een concreet voorbeeld van wat ChatGPT kan. Stel je wilt Jira-tickets in twee categorieën indelen: tickets over werk aan nieuwe features, en tickets over onderhoud.

Crowd rocking fashion-designs at a fun entertainment event - " — so hot

Op een simpel verzoek — “Create a TensorFlow model for classifying Jira issue tickets into two categories: features and not-features” — kwam de bot met een uitgebreide uitleg (de uitvoer van de bot staat hier onvertaald, precies zoals hij hem gaf):

To create a TensorFlow model for classifying Jira issue tickets into two categories: features and not-features, you will need to follow the steps below:

Collect and label a dataset of Jira issue tickets. This dataset should contain a large number of Jira issue tickets, with each ticket labeled as either a "feature" or "not-feature" ticket.

Preprocess the text data in the Jira issue tickets to prepare it for use in a machine learning model. This may include steps such as tokenizing the text, removing punctuation and stopwords, and lemmatizing the words to reduce them to their base forms.

Split the dataset into training and testing sets. The training set will be used to train the model, while the testing set will be used to evaluate the model's performance.

Train a machine learning model using the training set. In this case, a good choice for the model might be a convolutional neural network (CNN) or a recurrent neural network (RNN), as these are commonly used for text classification tasks.

Evaluate the performance of the model on the testing set, and iterate on the model and the preprocessing steps until the desired level of accuracy is achieved.

Once the model is performing well on the testing set, it can be used on new, unseen Jira issue tickets to classify them into the two categories: features and not-features.

Tot zover prima: een generieke uitleg over het bouwen van een neuraal netwerk. Wie een ML-oplossing voor iets probeert te maken weet dit waarschijnlijk wel, maar toch — goed gedaan, ChatGPT. Maar nu de code:

1# Import libraries
2import tensorflow as tf
3from tensorflow import keras
4from keras.preprocessing.text import Tokenizer
5from keras.preprocessing.sequence import pad_sequences
6
7# Load data and split into training and testing sets
8data = ...
9X_train, X_test, y_train, y_test = ...
10
11# Preprocess data by converting text to numerical vectors
12tokenizer = Tokenizer()
13tokenizer.fit_on_texts(X_train)
14X_train = tokenizer.texts_to_sequences(X_train)
15X_test = tokenizer.texts_to_sequences(X_test)
16X_train = pad_sequences(X_train)
17X_test = pad_sequences(X_test)
18
19# Load pre-trained word embedding model
20embedding_model = ...
21
22# Build neural network model
23model = keras.Sequential()
24model.add(keras.layers.Embedding(len(tokenizer.word_index)+1, 
25                                 embedding_model.vector_size, 
26                                 weights=[embedding_model.wv.vectors], 
27                                 input_length=X_train.shape[1], 
28                                 trainable=False))
29model.add(keras.layers.Dense(128, activation='relu'))
30model.add(keras.layers.Dense(2, activation='softmax'))
31
32# Compile model
33model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
34
35# Train model
36model.fit(X_train, y_train, epochs=10)
37
38# Evaluate model on testing data
39model.evaluate(X_test, y_test)
40
41# Use model to predict classification of new Jira issue tickets
42new_tickets = ...
43new_tickets = tokenizer.texts_to_sequences(new_tickets)
44new_tickets = pad_sequences(new_tickets)
45predictions = model.predict(new_tickets)

Best netjes! Het embedding-model ontbreekt, maar geen zorgen: je kunt de bot altijd om een suggestie vragen, en die geeft hij graag. Kun je met ChatGPT besparen door geen junior data scientist aan te nemen? Waarschijnlijk niet. Maar binnenkort zullen veel juniorfuncties deze codegeneratietechnologie nodig hebben om hun vaardigheden op te krikken en korter junior te zijn.

CoPilot

CoPilot is een NLP-tool die developers helpt om in realtime code te schrijven, door codefragmenten aan te vullen op basis van je invoer. Hij is bedoeld om te helpen bij eenvoudige taken, zoals het oplossen van Leetcode-opgaven (eenvoudig, ja ja…) of het debuggen van code. Er zijn CoPilot-extensies voor veel IDE's, waaronder de populairste: JetBrains IntelliJ en VSCode.

Wat CoPilot bijzonder maakt, is dat hij een machine learning-model gebruikt dat getraind is op GitHub-data om de context te begrijpen en daar passende codesuggesties bij te doen.

Dat maakt CoPilot waardevol voor developers die snel ontwikkeltaken willen afronden waar niet al te veel context bij nodig is — CoPilot pikt de context van de code namelijk wel degelijk op. Toch zijn zijn NLP-capaciteiten beperkter dan die van ChatGPT als het om het begrijpen van context gaat.

Laten we CoPilot dezelfde opdracht geven als ChatGPT en kijken hoe hij het doet. In plaats van één zin in een chat moeten we in een commentaarregel beschrijven wat we willen, en dan wachten op de suggesties van CoPilot. Alleen regel 2 en 3 zijn hier zelf geschreven. De rest is de suggestie van CoPilot, inclusief het commentaar.

1def create_model():
2    """Create a model that would be used for classification of Jira ticket into 2 categories: feature or not feature."""
3    # Load data and split into training and testing sets

"Multi-device mult-media software on a dark display w/ Git — generate using copilot

Font Screenshot Software Terrestrial-plant Technology Darkness Multimedia Event"]) — pick a suggestion

1def create_model():
2    """Create a model that would be used for classification of Jira ticket into 2 categories: feature or not feature."""
3    # Load data and split into training and testing sets
4    data = pd.read_csv("jira.csv")
5    train_data = data.sample(frac=0.8, random_state=0)
6    test_data = data.drop(train_data.index)
7
8    # Tokenize data
9    tokenizer = Tokenizer(num_words=1000, oov_token="<OOV>")
10    tokenizer.fit_on_texts(train_data["Summary"])
11    word_index = tokenizer.word_index
12
13    train_sequences = tokenizer.texts_to_sequences(train_data["Summary"])
14    train_padded = pad_sequences(train_sequences, padding='post', maxlen=100)
15
16    test_sequences = tokenizer.texts_to_sequences(test_data["Summary"])
17    test_padded = pad_sequences(test_sequences, padding='post', maxlen=100)
18
19    # Define the model
20    model = keras.Sequential([
21        keras.layers.Embedding(1000, 16, input_length=100),
22        keras.layers.GlobalAveragePooling1D(),
23        keras.layers.Dense(24, activation='relu'),
24        keras.layers.Dense(1, activation='sigmoid')
25    ])
26
27    # Compile the model
28    model.compile(optimizer='adam',
29                  loss='binary_crossentropy',
30                  metrics=['accuracy'])
31
32    # Train the model
33    model.fit(train_padded, train_data["Feature"], epochs=30)
34
35    # Test the model
36    test_loss, test_acc = model.evaluate(test_padded, test_data["Feature"])
37    print('Test accuracy:', test_acc)
38
39    # Save the model
40    model.save("jira_model.h5")
41
42    return model

Weer een prima implementatie! Hoe goed elke oplossing is, hangt sterk af van de aangeleverde data en de kwaliteit van de voorbewerking. En van het afstellen van de hyperparameters. Maar op het oog gaven beide AI's goede codesuggesties, die daarna nog wel door een mens bijgewerkt moeten worden.

Copilot en ChatGPT vergelijken?

CoPilot en ChatGPT zijn twee populaire tools onder softwareontwikkelaars, en op het eerste gezicht lijken het directe concurrenten. Kijk je beter, dan blijken ze verschillende dingen te kunnen en een ander doel te dienen — al is er overlap.

De hoofdtaak van CoPilot is code aanvullen en developers productiever maken door eenvoudige, repetitieve fragmenten voor ze te schrijven. ChatGPT daarentegen is een chatbot-framework waarmee developers chatbots kunnen bouwen en uitrollen op basis van het GPT-3-taalmodel. Het kan bij programmeertaken helpen, maar codegeneratie is niet zijn hoofddoel. ChatGPT is er vooral om ideeën uit te werken, ingewikkelde concepten te begrijpen en advies te krijgen over best practices. Je gebruikt het zoals je antwoorden op StackOverflow zoekt, of zoals je met collega-engineers overlegt.

ChatGPT helpt je bij het ontwerpen van grote systemen en geeft je een routekaart om er te komen, terwijl CoPilot je beter helpt bij een concrete functie-implementatie. Een voorbeeld: ChatGPT kan een syntaxis voor een nieuwe programmeertaal bedenken, een context-vrije grammatica opstellen en stappen aanraden om een compiler te bouwen. CoPilot daarentegen helpt je bij het maken van eenvoudige functies als parseExpression(), door naar de structuur en de context van je project te kijken.

Conclusie

"OpenAI's GitHub Copilot better than ChatGPT for version control

Samengevat zijn CoPilot en ChatGPT allebei waardevolle tools voor softwareontwikkelaars, maar ze kunnen verschillende dingen en dienen een ander doel. CoPilot is gericht op het aanvullen van code, terwijl ChatGPT zich meer richt op inspiratie en uitleg, en pas daarna op codegeneratie. Door te begrijpen wat elke tool uniek maakt, kun je als developer kiezen wat het beste bij je past.