Fashion MNIST

1번

베이스라인 공통사항

• GPU 모드로 학습하셔야 주어진 시간안에 문제 해결이 가능합니다. (모든 문제 30초 내외 학습 가능)
• 모든 랜덤시드는 777 로 고정하고, Full-Batch로 학습하세요. (Mini-Batch 아님)
• 학습 시 epoch은 최대 2000, learning_rate = 0.001, 나머지는 default 로 설정하세요.

1. 베이스라인 1번 (1점)

• Neural Network 을 단층(1층)으로 설계하세요.
• NN (784=>10)
• SGD 옵티마이저를 사용하세요.

linear=torch.nn.Linear(784,10)
model=torch.nn.Sequential(linear)
model=model.to(device)
optimizer=torch.optim.SGD(model.parameters(),lr=0.0001)
loss=torch.nn.CrossEntropyLoss()
from tqdm import tqdm
model.train()
for i in tqdm(range(2000)):
    #x=x.to(device)
    #y=y.to(device)
    H=model(x)
    cost=loss(H,y)
    optimizer.zero_grad()
    cost.backward()
    optimizer.step()

    if(i%200==0):print(cost)

2. 베이스라인 2번 (1점)

• Neural Network 을 복수층(3층)으로 설계하세요.
• NN (784=>64) + ReLU + NN (64=>64) + ReLU + NN (64=>10)
• Adam 옵티마이저를 사용하세요.
• 초기화 torch.nn.init.xavieruniform 변경 사용

linear1=torch.nn.Linear(784,64)
linear2=torch.nn.Linear(64,64)
linear3=torch.nn.Linear(64,10)
relu=torch.nn.ReLU()

torch.nn.init.xavier_uniform_(linear1.weight)
torch.nn.init.xavier_uniform_(linear2.weight)
torch.nn.init.xavier_uniform_(linear3.weight)

model=torch.nn.Sequential(linear1,relu,linear2,relu,linear3)
model=model.to(device)
optimizer=torch.optim.Adam(model.parameters(),lr=0.001)
loss=torch.nn.CrossEntropyLoss()
from tqdm import tqdm
model.train()
for i in tqdm(range(2000)):
    #x=x.to(device)
    #y=y.to(device)
    H=model(x)
    cost=loss(H,y)
    optimizer.zero_grad()
    cost.backward()
    optimizer.step()

    if(i%200==0):print(cost)

3. 베이스라인 3번 (1.5점)

• Neural Network 을 복수층(3층)으로 설계하세요.
• NN (784=>128) + ReLU + NN (128=>64) + ReLU + NN (64=>10)
• Adam 옵티마이저를 사용하세요.
• 초기화 torch.nn.init.xavieruniform 변경 사용

linear1=torch.nn.Linear(784,128)
linear2=torch.nn.Linear(128,64)
linear3=torch.nn.Linear(64,10)
relu=torch.nn.ReLU()

torch.nn.init.xavier_uniform_(linear1.weight)
torch.nn.init.xavier_uniform_(linear2.weight)
torch.nn.init.xavier_uniform_(linear3.weight)

model=torch.nn.Sequential(linear1,relu,linear2,relu,linear3)
model=model.to(device)
optimizer=torch.optim.Adam(model.parameters(),lr=0.001)
loss=torch.nn.CrossEntropyLoss()
from tqdm import tqdm
model.train()
for i in tqdm(range(2000)):
    #x=x.to(device)
    #y=y.to(device)
    H=model(x)
    cost=loss(H,y)
    optimizer.zero_grad()
    cost.backward()
    optimizer.step()

    if(i%200==0):print(cost)

 

 

4. 베이스라인 4번 (1.5점)

• Neural Network 을 복수층(3층)으로 설계하세요.
• NN (784=>128) + ReLU + NN (128=>64) + ReLU + NN (64=>10)
• 입력 데이터는 StandardScaler() 로 정규화 하세요.
• Adam 옵티마이저를 사용하세요.
• 초기화 torch.nn.init.xavieruniform 변경 사용

linear1=torch.nn.Linear(784,128)
linear2=torch.nn.Linear(128,64)
linear3=torch.nn.Linear(64,10)
relu=torch.nn.ReLU()

torch.nn.init.xavier_uniform_(linear1.weight)
torch.nn.init.xavier_uniform_(linear2.weight)
torch.nn.init.xavier_uniform_(linear3.weight)

model=torch.nn.Sequential(linear1,relu,linear2,relu,linear3)
model=model.to(device)
optimizer=torch.optim.Adam(model.parameters(),lr=0.001)
loss=torch.nn.CrossEntropyLoss()
from tqdm import tqdm
model.train()
for i in tqdm(range(500)):
    #x=x.to(device)
    #y=y.to(device)
    H=model(x)
    cost=loss(H,y)
    optimizer.zero_grad()
    cost.backward()
    optimizer.step()

    if(i%200==0):print(cost)

 

 

 

2번

 

x=np.array(x)
test=np.array(test)
y=np.array(y)
x=np.reshape(x,(-1,1,28,28))
test=np.reshape(test,(-1,1,28,28))
x=torch.Tensor(np.array(x))
y=torch.LongTensor(y)
test=torch.Tensor(np.array(test))
import torch.nn.functional as nnf
x = nnf.interpolate(x, size=(32, 32), mode='bicubic', align_corners=False)
test = nnf.interpolate(test, size=(32, 32), mode='bicubic', align_corners=False)
from torch.utils.data import TensorDataset,DataLoader
dataset=TensorDataset(x,y)
data=DataLoader(dataset,batch_size=100)

 

------------------------------

transform = torchvision.transforms.Resize(32) 쓰고

for X,Y in dataset:안에서

X=transform(X)

 

 

1.

class CNN1(torch.nn.Module):
    def __init__(self):
        super(CNN1,self).__init__()
        self.relu=torch.nn.ReLU()
        self.c1=torch.nn.Conv2d(1,32,kernel_size=3,stride=1,padding=1)
        self.m1=torch.nn.MaxPool2d(kernel_size=2,stride=2)
        self.c2=torch.nn.Conv2d(32,64,kernel_size=3,stride=1,padding=1)
        self.m2=torch.nn.MaxPool2d(kernel_size=2,stride=2)
        self.FC=torch.nn.Linear(3136,10)
        
        torch.nn.init.kaiming_uniform_(self.FC.weight)
        
    def forward(self,x):
        out=self.c1(x)
        out=self.relu(out)
        out=self.m1(out)
        out=self.c2(out)
        out=self.relu(out)
        out=self.m2(out)
        out = out.view(out.size(0),-1) 
        out=self.FC(out)
        
        return out

model=CNN1().to(device)

 

 

2.

class CNN2(torch.nn.Module):
    def __init__(self):
        super(CNN2,self).__init__()
        self.c1=torch.nn.Conv2d(1,6,kernel_size=5,stride=1)
        self.ac=torch.nn.Tanh()
        self.ap1=torch.nn.AvgPool2d(kernel_size=2,stride=2)
        self.c2=torch.nn.Conv2d(6,16,kernel_size=5,stride=1)
        
        self.fc1=torch.nn.Linear(16*5*5,120)
        self.fc2=torch.nn.Linear(120,84)
        self.fc3=torch.nn.Linear(84,10)
        self.softmax=torch.nn.Softmax()
        
    def forward(self,x):
        out=self.c1(x)
        out=self.ac(out)
        out=self.ap1(out)
        
        out=self.c2(out)
        out=self.ac(out)
        out=self.ap1(out)
       
        
        out=out.view(out.size(0),-1)
        
        out=self.fc1(out)
        out=self.ac(out)
        
        out=self.fc2(out)
        out=self.ac(out)
        
        out=self.fc3(out)
        #out=self.softmax(out)
        
        return out

model=CNN2().to(device)

 

 

-------------------------------

학습(공통)

optimizer=torch.optim.Adam(model.parameters(),lr=0.001)
loss=torch.nn.CrossEntropyLoss()
size=len(data)
for i in range(50):
    avg_cost=0
    for X,Y in data:
        X=X.to(device)
        Y=Y.to(device)
        H=model(X)
        cost=loss(H,Y)
        optimizer.zero_grad()
        cost.backward()
        optimizer.step()
        avg_cost+=cost/size
    if(i%10==0):print(avg_cost)

with torch.no_grad():
    model.eval()
    test=test.to(device)
    predict=model(test)
    predict=torch.argmax(predict,dim=1)

submit['Category']=predict.cpu()
submit.to_csv('submit.csv',index=False)

 

 

 

 

------------

제출

https://www.kaggle.com/competitions/2020-ai-exam-fashionmnist-3/leaderboard

2020.AI.기말고사.문제3 | Kaggle

문제

1. https://www.kaggle.com/competitions/2021-ai-finalterm-p1/overview

2. https://www.kaggle.com/competitions/2021-ai-finalterm-p2/overview/baseline