[patrickve]

Oorspronkelijk geplaatst door Oma

Er zit wel een programmeur, een méns, achter de algoritmen, achter alle software en ingevoerde data waardoor AI kan bestaan door software matige aansturing om voorspellingen te kunnen doen.

Zoals er ooit een eerste buideldier was dat het concept van "zoogdier" had uitgevonden waar wij nog altijd van copieren he

Het merkwaardige aan die AI toestanden is dat het programmeren totaal onafhankelijk is van het "vakgebied" dat geleerd moet worden. Eenzelfde AI, dus eenzelfde programma, kan naargelang, geleerd worden om voetgangers te herkennen op straat, dan wel om fraude in schilderijen te leren ontdekken. Het hangt enkel af wat je die dingen nadien laat leren.

Natuurlijk is het zo dat sommige manieren om AI programma's te schrijven BETER LEREN voetgangers herkennen, en andere AI programma's BETER leren om schilderij fraude te ontdekken. Maar het is niet de programmeur die zo een programma zegt hoe voetgangers te herkennen.

Het is door met dat programma "rond te lopen" en te zeggen: "kijk, DAT is een voetganger, zie". En "kijk, dat is gene voetganger, maar een fietser". Ga je met DATZELFDE programma tonen "kijk, dit is een vervalste Rubens", en "kijk, dit is een originele van Dijck", dan gaat dat programma een al dan niet goeie kunstwerken kritikus worden. Exact zoals mensen "leren" door "naar de les te gaan" en "ervaring op te doen".

Dus ja, in een grijs verleden zijn er ooit programmeurs geweest die de principes bedacht hadden van hoe men zulke programma's-die-kunnen-leren moest schrijven.

Kijk, ik heb aan ChatGPT het volgende gevraagd:

Write a simple torch.py program that implements a transformer to learn to translate 10 word sentences in English into 256 times 256 pixel images

Op nog geen 3 minuten gaf het mij dit antwoord:

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
from torch.utils.data import Dataset, DataLoader

# Define the transformer model
class Transformer(nn.Module):
def __init__(self, src_vocab_size, trg_vocab_size, embed_size, num_layers, num_heads, dropout):
super(Transformer, self).__init__()
self.src_embedding = nn.Embedding(src_vocab_size, embed_size)
self.trg_embedding = nn.Embedding(trg_vocab_size, embed_size)
self.encoder = nn.TransformerEncoder(nn.TransformerEncoderLayer(e mbed_size, num_heads, dropout), num_layers)
self.decoder = nn.TransformerDecoder(nn.TransformerDecoderLayer(e mbed_size, num_heads, dropout), num_layers)
self.linear = nn.Linear(embed_size, 256 * 256)

def forward(self, src, trg):
src_embed = self.src_embedding(src)
trg_embed = self.trg_embedding(trg)
memory = self.encoder(src_embed)
output = self.decoder(trg_embed, memory)
output = self.linear(output)
return output

# Define the dataset class
class SentenceImageDataset(Dataset):
def __init__(self, sentences, images, transform):
self.sentences = sentences
self.images = images
self.transform = transform

def __len__(self):
return len(self.sentences)

def __getitem__(self, index):
sentence = self.sentences[index]
image = self.images[index]
if self.transform:
image = self.transform(image)
return sentence, image

# Define the training function
def train(model, optimizer, criterion, dataloader):
model.train()
train_loss = 0.0
for i, (sentences, images) in enumerate(dataloader):
optimizer.zero_grad()
src = sentences.transpose(0, 1)
trg = images.transpose(0, 1)
output = model(src, trg[:-1])
loss = criterion(output.reshape(-1, 256 * 256), trg[1:].reshape(-1))
loss.backward()
optimizer.step()
train_loss += loss.item()
return train_loss / len(dataloader)

# Define the main function
def main():
# Set up the device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# Set up the hyperparameters
src_vocab_size = 10
trg_vocab_size = 256 * 256
embed_size = 256
num_layers = 2
num_heads = 8
dropout = 0.1
learning_rate = 0.001
batch_size = 32
num_epochs = 10

# Load the data
sentences = torch.randn(100, 10).long()
images = torch.randn(100, 256, 256).float()
transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((256, 256)),
transforms.ToTensor()
])
dataset = SentenceImageDataset(sentences, images, transform)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

# Initialize the model, optimizer, and loss function
model = Transformer(src_vocab_size, trg_vocab_size, embed_size, num_layers, num_heads, dropout).to(device)
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
criterion = nn.CrossEntropyLoss()

# Train the model
for epoch in range(num_epochs):

Het is maar een stramien omdat ik enkel maar een stramien aangaf van wat te doen. Maar zoals je ziet:

1) schrijft een AI zelf AI code

2) is dat alles behalve gecompliceerd !