def install_model():
model_name = os.listdir("/tmp/model-weights")[0]
model = ResNet18(flatten=True).to("cpu", dtype=torch.float)
model.load_state_dict(
torch.load(os.path.join("/tmp/model-weights", model_name),
map_location="cpu"))
model.eval()
return model
def img_64(EPOCH=10, LR=0.1, Momentum=0.5, no_cuda=False, save_model=False):
train_path = "/users/wangkai/Downloads/271project/train.csv"
# test_path = "petfinder-adoption-prediction/test.csv"
train_img_path = "/users/wangkai/Downloads/271project/data_organized_hist"
# test_img_path = "testdata_organized_hist/"
use_cuda = not no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
kwargs = {'num_workers': 0, 'pin_memory': True} if use_cuda else {}
X, petid, Y = characters(train_path) # load data
train_label = Y[0:10000]
test_label = Y[10000:14993]
IMG = imageread(petid, train_img_path)
train_img = IMG[0:10000, :, :]
test_img = IMG[10000:14993, :, :]
train_dataset = PetDataset(train_img, train_label)
test_dataset = PetDataset(test_img, test_label)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=64,
shuffle=False,
**kwargs)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=100,
shuffle=False,
**kwargs)
model = ResNet18().to(device)
optimizer = optim.SGD(model.parameters(), lr=LR, momentum=Momentum)
for epoch in range(1, EPOCH + 1):
train_img_64 = train(model, device, train_loader, optimizer, epoch)
test_img_64 = test(model, device, test_loader)
if (save_model):
torch.save(model.state_dict(), "pet_resnet.pt")
# train_img_64 = train_out_64.detach().cpu().numpy()
# test_img_64 = test_out_64.detach().cpu().numpy()
return train_img_64, test_img_64
]
if normalization:
layers.append(nn.InstanceNorm2d(out_features))
return layers
self.model = nn.Sequential(
*block(opt.channels, 64, normalization=False), *block(64, 128),
*block(128, 256), *block(256, 512), nn.Conv2d(512, 1, 3, 1, 1))
def forward(self, img):
validity = self.model(img)
return validity
# 模型定义-ResNet
net = ResNet18().to(device)
# Loss function
adversarial_loss = torch.nn.MSELoss()
task_loss = torch.nn.CrossEntropyLoss()
# Loss weights
# lambda_adv = 1
# lambda_task = 0.1
# lambda_rec = 0.1
# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()
classifier = net
out = torch.zeros(batch_size, dim)
out[np.arange(batch_size), labels.long()] = 1
return out
def weights_init_normal(m):
classname = m.__class__.__name__
if classname.find('Linear') != -1:
m.weight.data.normal_(0.0, 0.02)
elif classname.find('BatchNorm') != -1:
m.weight.data.normal_(1.0, 0.02)
m.bias.data.fill_(0)
# 模型定义-ResNet
net = ResNet18().to(device)
# Initialize generator and discriminator
classifier = net
task_loss = torch.nn.CrossEntropyLoss()
if cuda:
classifier.cuda()
task_loss.cuda()
# Initialize weights
classifier.apply(weights_init_normal)
########
writer = SummaryWriter('runs1')
# # model = LeNet()
# dummy_input = torch.rand(64, 3, 32, 32) #假设输入13张1*28*28的图片
# with SummaryWriter(comment='classifier') as w: