def prediction(model_fp, input_fp, output_fp, limit): model = FCN() model.load_state_dict(tor.load(model_fp)) model.cuda() dir_size = len(os.listdir(input_fp)) limit = limit if limit else float("inf") for i in range(dir_size): if i < limit: file_name = os.path.join(input_fp, "{:0>4}_sat.jpg".format(i)) img = plt.imread(file_name) img = np.moveaxis(img, 2, 0) img = tor.FloatTensor(np.array([img])) img_var = Variable(img).type(tor.FloatTensor).cuda() pred_img = model(img_var) pred_img = tor.max(pred_img, 1)[1] pred_img = pred_img.cpu().data.numpy() pred_img = np.moveaxis(pred_img, 0, 2) output_img = img_recovery(pred_img) scipy.misc.imsave( os.path.join(output_fp, "{:0>4}_mask.png".format(i)), output_img) else: break
noised = hisEqulColor(noised) / 255. # noised -> 64x64x3 Val_train_batch[i] = noised Val_ground_truth[i] = 1 - origin / 255. Val_label_batch[i] = Label[i][0] global generated_size for i in range(1000): # Gets the image, original and the label from generate method in synth.py module id = generated_size % data_size img, origin, label = G.generate() #G is an object of Generator inside the synth file origin = 255. - cv2.cvtColor(origin, cv2.COLOR_RGB2GRAY) Train_batch[id] = hisEqulColor(img) / 255. #G.generate() is used to get the training data Ground_truth[id] = origin / 255. Label_batch[id] = label generated_size += 1 if use_cuda: Decoder = Decoder.cuda() Encoder = Encoder.cuda() def train_bezier(x, img): #Takes the ground truth and Decoder.train() x = x.reshape(-1, 9) bezier = [] for i in range(x.shape[0]): bezier.append(draw(x[i])) bezier = torch.tensor(bezier).float() if use_cuda: bezier = bezier.cuda() optimizerD.zero_grad() loss = criterion(img, bezier) loss.backward() optimizerD.step()
batch_size=1, shuffle=False, num_workers=2) numClass = 8 numPlanes = 32 levels = 5 levelDepth = 2 kernelSize = 3 model = FCN(numPlanes, levels, levelDepth, numClass, kernelSize, 0.1) indices = [] mapLoc = None if haveCuda else {'cuda:0': 'cpu'} if haveCuda: model = model.cuda() criterion = CrossEntropyLoss2d() epochs = 200 lr = 1e-1 weight_decay = 1e-3 momentum = 0.5 patience = 20 optimizer = torch.optim.SGD([ { 'params': model.parameters() }, ], lr=lr,
def train(data_loader, model_index, x_eval_train, y_eval_train): ### Model Initiation fcn = FCN() #print (fcn.b_1_conv_1[0].weight.data) d = tor.load("./models/vgg16_pretrained.pkl") fcn.vgg16_load(d) #d = tor.load("./models/fcn_model_1_1.pkl") #fcn.load_state_dict(d) fcn.cuda() #loss_func = tor.nn.CrossEntropyLoss(weight=w) loss_func = tor.nn.CrossEntropyLoss() #loss_func = tor.nn.MSELoss() #optim = tor.optim.SGD(fcn.parameters(), lr=LR, momentum=MOMENTUM) optim1 = tor.optim.Adam(fcn.b_6_conv_1.parameters(), lr=LR) optim2 = tor.optim.Adam(fcn.b_6_conv_2.parameters(), lr=LR) optim3 = tor.optim.Adam(fcn.b_6_conv_3.parameters(), lr=LR) optim4 = tor.optim.Adam(fcn.b_7_trans_1.parameters(), lr=LR) optim = tor.optim.Adam(fcn.parameters(), lr=LR) ### Training for epoch in range(EPOCH): print("|Epoch: {:>4} |".format(epoch + 1), end="") ### Training for step, (x_batch, y_batch) in enumerate(data_loader): x = Variable(x_batch).type(tor.FloatTensor).cuda() y = Variable(y_batch).type(tor.LongTensor).cuda() pred = fcn(x) optim1.zero_grad() optim2.zero_grad() optim3.zero_grad() optim4.zero_grad() optim.zero_grad() loss = loss_func(pred, y) loss.backward() optim1.step() optim2.step() optim3.step() optim4.step() print(pred[:2]) print(tor.max(pred[:5], 1)[1]) ### Evaluation loss = float(loss.data) acc = evaluate(fcn, x_eval_train, y_eval_train) print("|Loss: {:<8} |Acc: {:<8}".format(loss, acc)) ### Save model if epoch % RECORD_MODEL_PERIOD == 0: tor.save( fcn.state_dict(), os.path.join(MODEL_ROOT, "fcn_model_{}_{}.pkl".format(model_index, epoch))) ### Record record_data = dict() if epoch == 0: record_data["model_name"] = "fcn_model_{}.pkl".format(model_index) record_data["data_size"] = AVAILABLA_SIZE record_data["batch_size"] = BATCHSIZE record_data["decay"] = str((LR_STEPSIZE, LR_GAMMA)) record_data["lr_init"] = float(optim1.param_groups[0]["lr"]) record_data["lr"] = float(optim1.param_groups[0]["lr"]) record_data["record_epoch"] = RECORD_MODEL_PERIOD record_data["loss"] = loss record_data["acc"] = acc else: record_data["model_name"] = "fcn_model_{}.pkl".format(model_index) record_data["lr"] = float(optim1.param_groups[0]["lr"]) record_data["loss"] = loss record_data["acc"] = acc record(RECORD_FP, record_data)
logger.addHandler(console) def weights_init(m): if isinstance(m, nn.Conv2d): torch.nn.init.normal(m.weight.data,mean=0,std=1) torch.nn.init.normal(m.bias.data,mean=0,std=1) with open("/home/yuchen/Programs/cancer-prognosis/best.txt", 'r') as file: best = float(file.readline()) epoch0 = int(file.readline()) print("Last Train: accu %f , epoch0 %d" % (best, epoch0)) try: net = torch.load('/home/yuchen/Programs/cancer-prognosis/seg_model.pkl') except: net = FCN() net.apply(weights_init) net.cuda() optimizer = torch.optim.Adam(net.parameters(),lr=LR, weight_decay=0.5) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.9) loss_func = nn.NLLLoss2d(weight=torch.FloatTensor([1,8000]).cuda()) data_loder = DataLoader() zeros = np.zeros((512,512)) for epoch in range(epoch0, epoch0+EPOCH): scheduler.step() train_step = 0 test_step = 0 train_loss = 0 test_loss = 0