Hello! Now im trying to understand how I can use pictures in pytorch. Im quite new to everything here. Now my problem is, i am expecting a output with a list with two numbers. But the output has the format [1, 18, 12, 2].
How do I get the format i desire?
There is a different thing i dont get, the output of the last convolution layer has 18 channels, but why does it output something with 12 layers?
Any advice is appreciated!
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from os import listdir
from torch.autograd import Variable
from torchvision import transforms
from PIL import Image

class Netz(nn.Module): # Das Netz
    
    def __init__(self):
        super(Netz,self).__init__()
        
        self.cn1 = nn.Conv2d(3,5, kernel_size=5) 
        self.cn2 = nn.Conv2d(5,7, kernel_size=5)
        self.cn3 = nn.Conv2d(7,12, kernel_size=5)
        self.cn4 = nn.Conv2d(12,18, kernel_size=5)
        self.ln1 = nn.Linear(12,200)
        self.ln2 = nn.Linear(200,20)
        self.ln3 = nn.Linear(20,10)
        self.ln4 = nn.Linear(10,2)

    def forward(self, x): 

        x = self.cn1(x)
        x = F.max_pool2d(x,2) 
        x = F.relu(x)
        x = self.cn2(x)
        x = F.max_pool2d(x,2)
        x = F.relu(x)
        x = self.cn3(x)
        x = F.max_pool2d(x,2)
        x = F.relu(x)
        x = self.cn4(x)
        x = F.max_pool2d(x,2)
        x = F.relu(x)

        x = F.relu(self.ln1(x)) 
        x = F.relu(self.ln2(x))
        x = F.relu(self.ln3(x))
        return F.relu(self.ln4(x)) 
    
model = Netz()


train_data_list = []
target_list = []
train_data = []
normalize = transforms.Normalize(
    mean = [0.485, 0.456, 0.406],
    std = [0.229, 0.224, 0.225]
    ) 
transform = transforms.Compose([transforms.Resize(256),
                                transforms.CenterCrop(256),
                                transforms.ToTensor(),
                                normalize]); #Liste von "Befehlen" die ausgeführt werden bei Aufruf
for f in listdir("E:/DataAI"):
    img = Image.open("E:/DataAI/" + f)
    img_tensor = transform(img)
    img_tensor.unsqueeze_(0)
    train_data_list.append(img_tensor)
    splitFN = f.split("-")
    x = splitFN[1].replace('x', '')
    y = splitFN[2].replace('y','')
    
    #print("x: " + x + " y: " + y)
    target = [int(x),int(y)]
    target_list.append(target)
    
    train_data.append((img_tensor, target))
    if len(train_data_list) >= 5:
        train_data.append((torch.stack(train_data_list), target_list))
        train_data_list = []
        target_list = []
    
    
optimizer = optim.Adam(model.parameters(), lr=0.01)
def train(gen):
    size = len(train_data)
    count = 0
    model.train()
    for data, target in train_data:
        data = Variable(data)
        target = torch.Tensor(target)
        target = Variable(target)
        optimizer.zero_grad()
        out = model(data)

        criterion = F.binary_cross_entropy
        loss = criterion(out, target)
        loss.backward()
        optimizer.step()
        count+=1
        print("Gen: {gene} Count: {counte} Percantage: {per}".format(gene=gen, counte=count, perc = (count/size)*100))
        

train(1)