pytorch zahlenfolge vervollständigen

[kugelblitz]

Hallo,
ich habe ein Problem mit Python torch.
Ich möcht (um zu lernen mit troch zu arbeiten) eine kleine Ki bauen die einen Zahlenfolge einliest und dann vervollständigt. Leider Funktioniert das nicht.
Hier mein Script:

Code: Alles auswählen

import torch
import torch.nn as nn
import numpy as np

# Definieren Sie eine Zahlenfolge, die Sie vervollständigen möchten
input_sequence = np.array([1, 3, 5, 7, 9, 11, 13, 15, 17, 19])

# Definieren Sie das Modell
class SequenceCompletionModel(nn.Module):
    def __init__(self):
        super(SequenceCompletionModel, self).__init__()
        self.lstm = nn.LSTM(1, 64, num_layers=2, batch_first=True)
        self.fc = nn.Linear(64, 1)
    
    def forward(self, x):
        x, _ = self.lstm(x)
        x = self.fc(x)
        return x

# Initialisieren Sie das Modell und definieren Sie die Verlustfunktion und den Optimierer
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = SequenceCompletionModel().to(device)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# Trainieren Sie das Modell
num_epochs = 1000

for epoch in range(num_epochs):
    # Konvertieren Sie die Eingangssequenz in ein Tensor-Objekt und senden Sie es zur GPU
    input_tensor = torch.Tensor(input_sequence).view(-1, 1, 1).to(device)
    
    # Vervollständigen Sie die Sequenz, indem Sie das Modell ausführen und senden Sie das Ergebnis zur GPU
    output_tensor = model(input_tensor[:-1]).to(device)
    
    # Berechnen Sie den Verlust und führen Sie die Rückwärtspropagation aus
    loss = criterion(output_tensor, input_tensor[1:])
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    # Drucken Sie den Verlust aus
    if epoch % 100 == 0:
        print(f"Epoch {epoch}. Loss: {loss.item()}")
# Generieren Sie eine vervollständigte Sequenz
with torch.no_grad():
    completed_sequence = input_sequence.tolist()
    input_tensor = torch.Tensor(input_sequence).view(-1, 1, 1).to(device)
    output_tensor = model(input_tensor).to(device)
    completed_sequence.append(int(output_tensor[-1, 0, 0].item()))
    print(completed_sequence)

die ausgabe ist diese:
Epoch 0. Loss: 148.8709259033203
Epoch 100. Loss: 0.3374404013156891
Epoch 200. Loss: 0.04360831528902054
Epoch 300. Loss: 0.005860152654349804
Epoch 400. Loss: 0.00801441166549921
Epoch 500. Loss: 0.00023479858646169305
Epoch 600. Loss: 0.0001443024375475943
Epoch 700. Loss: 0.00013532201410271227
Epoch 800. Loss: 0.00011223236651858315
Epoch 900. Loss: 0.00010470677079865709
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 20]


Ich habe es versucht mit ChatGPT zu verbesser aber das funktioniert nicht. Ich denke, dass das Netz falsch lernt. Denn nach Epoche 600 ist die Fehlerquote sehr gering. Kann mir jemand helfen?

mfg

[pillmuncher]

Zu jeder endlichen Zahlenfolge gibt es unendlich viele unterschiedliche Funktionen der Ordinalzahlen, die mit genau mit dieser Zahlenfolge beginnen. Jede Zahl, die unmittelbar nach dem ender der Ausgangszahlenfolge kommt, ist deswegen eine richtige Zahl:

Code: Alles auswählen

…
1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 17, …
1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 18, …
1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 19, …
1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 20, …
1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, …
1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 22, …
1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 23, …
…

Das sind alles richtige Ergebnisse.

[kugelblitz]

danke für die schnelle Antwort. Ich möchte ja das statt einer 20 als letzte zahl eine 21 da steht.

[pillmuncher]

@kugelblitz: Ja, ich verstehe schon, was du möchtest. Aber welche der folgenden Aussagen trifft auf die von dir gezeigte Liste zu?

• Sie beginnt mit 1 und besteht aus den positiven ungeraden Zahlen in aufsteigender Reihenfolge.
• Sie beginnt mit 1 und jede Zahl ist um zwei größer als die vorhergehende.
• Sie beginnt mit 1 und jede Zahl ist größer als die vorhergehende.

Jede dieser Aussagen trifft zu. Je nachdem kann also 20 die richtige Antwort sein oder auch nicht. Den Computer interessiert hier nur, ob er eine Regelmäßigkeit finden kann. Jede der o.s. Aussagen beschreibt so eine Regelmäßigkeit.

Ich habe vor Jahren mal so einen Intelligenztest gemacht und habe in einer Reihe geometrischer Figuren einen Regelmäßigkeit gefunden, von der die Testerin mir aber sagte, sie sei falsch. Nachdem ich es ihr erklärt hatte, sagte sie ja, das sei schon eine passende Regel die ich da gefunden hätte, aber die Antwort sei trotzdem falsch, "weil es nicht die Antwort aus dem Buch ist". Intelligenz ist denmach die magische Eigenschaft, eine gewünschte Regelmäßigkeit zu finden. Übertragen auf dein Beispiel: Der Computer soll nicht nur eine richtige Anwort geben, sondern zudem auch eine, die du dir wünschst.

[__deets__]

Ich spiele mal teufels advokat: mit linearer Regression läuft’s

[kugelblitz]

Danke für die Hilfe. Mit linearer Regression läuft es sehr gut, es funktioniert jetzt auch mit weniger Lernmaterial.
Hier nochmal der Code:

Code: Alles auswählen

import torch
import torch.nn as nn
import torch.optim as optim
import torch.optim.lr_scheduler as lr_scheduler
import numpy as np
import torch.nn.functional as F

# Definieren Sie eine Zahlenfolge, die Sie vervollständigen möchten
input_sequence = np.array([1, 3, 5, 7, 9])

# Definieren Sie das Modell
class SequenceCompletionModel(nn.Module):
    def __init__(self):
        super(SequenceCompletionModel, self).__init__()
        self.linear1 = nn.Linear(1, 64)
        self.linear2 = nn.Linear(64, 1)
        self.linear3 = nn.Linear(1, 64)
        self.linear4 = nn.Linear(64, 1)

    def forward(self, x):
        x = F.relu(self.linear1(x))
        x = self.linear2(x)
        x = F.relu(self.linear3(x))
        x = self.linear4(x)
        return x

# Initialisieren Sie das Modell und definieren Sie die Verlustfunktion und den Optimierer
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = SequenceCompletionModel().to(device)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
scheduler = lr_scheduler.StepLR(optimizer, step_size=10000, gamma=0.1)

# Trainieren Sie das Modell
num_epochs = 1000
for epoch in range(num_epochs):
    input_tensor = torch.Tensor(input_sequence).view(-1, 1, 1).to(device)
    output_tensor = model(input_tensor[:-2]).to(device)
    loss = criterion(output_tensor, input_tensor[2:])
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    scheduler.step()
    if epoch % 100 == 0:
        print(f"Epoch {epoch}. Loss: {loss.item()}")

# Generieren Sie eine vervollständigte Sequenz
with torch.no_grad():
    completed_sequence = input_sequence.tolist()
    input_tensor = torch.Tensor(input_sequence).view(-1, 1, 1).to(device)
    output_tensor = model(input_tensor).to(device)
    completed_sequence.append(int(output_tensor[-2].item()))    
    completed_sequence.append(int(output_tensor[-1].item()))   
    print(completed_sequence)