def train(args): model = Unet(3, 1).to(device) batch_size = args.batch_size criterion = nn.BCEWithLogitsLoss() optimizer = optim.Adam(model.parameters()) liver_dataset = LiverDataset("data/train",transform=x_transforms,target_transform=y_transforms) dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=4) train_model(model, criterion, optimizer, dataloaders)
def train(): x_transforms = transforms.Compose([ transforms.ToTensor(), transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) ]) y_transforms = transforms.ToTensor() model = Unet(3, 1).to(device) model.load_state_dict(torch.load(r"./results/weights.pth")) batch_size = 1 num_epochs = 2 criterion = torch.nn.BCELoss() optimizer = optim.Adam(model.parameters()) liver_dataset = LiverDataset(r'D:\project\data_sets\liver\train', transform=x_transforms, target_transform=y_transforms) data_loaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=0) print("Start training at ", strftime("%Y-%m-%d %H:%M:%S", localtime())) for epoch in range(num_epochs): prev_time = datetime.now() print('Epoch{}/{}'.format(epoch, num_epochs)) print('-' * 10) dt_size = len(data_loaders.dataset) epoch_loss = 0 step = 0 for x, y in data_loaders: step += 1 inputs = x.to(device) labels = y.to(device) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() epoch_loss += loss.item() if (step % 10) == 0: print("%d/%d, train_loss:%0.3f" % (step, (dt_size - 1) // data_loaders.batch_size + 1, loss.item())) # print the results of the current training cur_time = datetime.now() h, remainder = divmod((cur_time - prev_time).seconds, 3600) m, s = divmod(remainder, 60) time_str = 'Time:{:.0f}:{:.0f}:{:.0f}'.format(h, m, s) epoch_str = "epoch {} loss:{:.4f} ".format(epoch, epoch_loss / 400) print(epoch_str + time_str) res_record("Time:" + strftime("%Y-%m-%d %H:%M:%S ", localtime())) res_record(epoch_str + '\n') print("End training at ", strftime("%Y-%m-%d %H:%M:%S", localtime())) # 记录数据 torch.save( model.state_dict(), './results/weights{}_{}_{}.pth'.format(localtime().tm_mday, localtime().tm_hour, localtime().tm_sec))
def train(self): model = Unet(in_ch=2, out_ch=2).to(device) # batch_size = 1 # criterion = nn.BCEWithLogitsLoss() criterion = nn.BCELoss() # criterion = nn.CrossEntropyLoss() # optimizer = optim.Adam(model.parameters(),lr = 0.01) optimizer = optim.SGD(model.parameters(), lr=0.005, momentum=0.9) # data_set = Train_Data(data_root='./train', mask_root='./Train_GT') self.train_model(model, criterion, optimizer)
def train(): model = Unet(5, 2).to(device) model.train() batch_size = args.batch_size criterion = torch.nn.BCELoss() optimizer = optim.Adam(model.parameters()) PAVE_dataset = SSFPDataset("train", transform=1, target_transform=1) dataloaders = DataLoader(PAVE_dataset, batch_size=batch_size, shuffle=True, num_workers=0) train_model(model, criterion, optimizer, dataloaders)
def train(args): model = Unet(1, 1).to(device) batch_size = args.batch_size criterion = nn.BCEWithLogitsLoss() optimizer = optim.Adam(model.parameters(), lr=0.01) liver_dataset = LiverDataset("/gs/home/majg/liupeng/code", transform=x_transforms, target_transform=y_transforms) dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=10) train_model(model, criterion, optimizer, dataloaders)
def train(): model = Unet(3, 1).to(device) batch_size = 8 criterion = torch.nn.BCELoss() optimizer = optim.Adam(model.parameters()) liver_dataset = LiverDataset("/home/xm/Program/ALL-Data/unetdata/test", transform=x_transforms, target_transform=y_transforms) dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=4) train_model(model, criterion, optimizer, dataloaders)
def train(): model = Unet(3, 1).to(device) model.load_state_dict(torch.load(r"./results/weights4_13_40.pth")) batch_size = 5 criterion = torch.nn.BCELoss() optimizer = optim.Adam(model.parameters()) liver_dataset = LiverDataset(r"D:\project\data_sets\data_sci\train", transform=x_transforms, target_transform=y_transforms) dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=0) train_model(model, criterion, optimizer, dataloaders)
def train(): model = Unet(3, 1).to(device) batch_size = args.batch_size criterion = torch.nn.BCELoss() optimizer = optim.Adam(model.parameters()) liver_dataset = LiverDataset( r"H:\BaiduNetdisk\BaiduDownload\u_net_liver-master\data\train", transform=x_transforms, target_transform=y_transforms) dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=0) train_model(model, criterion, optimizer, dataloaders)
def train(): #logging.basicConfig(stream=sys.stdout, level=logging.DEBUG) model = Unet(3, 1).to(device) batch_size = 1 criterion = nn.BCEWithLogitsLoss() optimizer = optim.Adam(model.parameters()) liver_dataset = LiverDataset("data/train", transform=x_transforms, target_transform=y_transforms) dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=4) train_model(model, criterion, optimizer, dataloaders)
def train(): model = Unet(1, 1).to(device) batch_size = 1 criterion = nn.BCEWithLogitsLoss() optimizer = optim.Adam(model.parameters()) train_dataset = TrainDataset("dataset/train/image", "dataset/train/label", transform=x_transforms, target_transform=y_transforms) dataloaders = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4) train_model(model, criterion, optimizer, dataloaders)
def train(): model = Unet(3, 3).to(device) batch_size = 3 criterion = torch.nn.BCELoss() optimizer = optim.Adam(model.parameters(), lr=1e-5) liver_dataset = LiverDataset("data/train_xin/liver_bmp", "data/train_xin/mask_bw", transform=x_transforms, target_transform=y_transforms) dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=0) train_model(model, criterion, optimizer, dataloaders)
def train(): model = Unet(3, 1).to(device) #model.load_state_dict(torch.load('./checkpoints/weights_39.pth')) batch_size = args.batch_size criterion = torch.nn.BCELoss() optimizer = optim.Adam(model.parameters()) liver_dataset = LiverDataset("data/train", transform=x_transforms, target_transform=y_transforms) dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=4) #4 train_model(model, criterion, optimizer, dataloaders)
def train(): model = Unet(3, 1).to(device) #summary(model,(3,512,512)) batch_size = 1 criterion = torch.nn.BCELoss() optimizer = optim.Adam(model.parameters()) liver_dataset = LiverDataset("data/image", "data/mask", transform=x_transforms, target_transform=y_transforms) dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=4) train_model(model, criterion, optimizer, dataloaders)
def train(args): model = Unet(3, 1).to(device) #begin add # checkpoint = torch.load("./weights_19.pth",map_location=device) # model.load_state_dict(checkpoint['model_state_dict']) #end add batch_size = args.batch_size criterion = nn.BCEWithLogitsLoss() optimizer = optim.Adam(model.parameters()) liver_dataset = LiverDataset("./data/train", transform=x_transforms, target_transform=y_transforms) dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=4) train_model(model, criterion, optimizer, dataloaders)
def train(args): model = Unet(3, 1).to(device) # 输入3通道,输出1通道 batch_size = args.batch_size criterion = nn.BCEWithLogitsLoss() # 损失函数 optimizer = optim.Adam(model.parameters()) # 获得模型的参数 liver_dataset = LiverDataset("data/train", transform=x_transforms, target_transform=y_transforms) # 加载数据集,返回的是一对原图+掩膜,和所有图片的数目 dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=4) # DataLoader接口是自定义数据接口输出输入接口,将已有的数据输入按照batch size封装成Tensor # batch_size=4,epoch=10,共100个minbatch # shuffle,每个epoch将数据打乱 # num_workers: 多个进程倒入数据,加速倒入速度 train_model(model, criterion, optimizer, dataloaders) # 训练
def train(args): model = Unet(3, 1).to(device) batch_size = args.batch_size criterion = nn.BCEWithLogitsLoss() optimizer = optim.Adam(model.parameters()) liver_dataset = LiverDataset("data/train", transform=x_transforms, target_transform=y_transforms) dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=1) # shuffle = True, # 乱序 # num_workers = 2 # 多进程 # DataLoader:该接口主要用来将自定义的数据读取接口的输出或者PyTorch已有的数据读取接口的输入按照batch size封装成Tensor # batch_size:how many samples per minibatch to load,这里为4,数据集大小400,所以一共有100个minibatch # shuffle:每个epoch将数据打乱,这里epoch=10。一般在训练数据中会采用 # num_workers:表示通过多个进程来导入数据,可以加快数据导入速度 train_model(model, criterion, optimizer, dataloaders)
def train(args): model = Unet(3, 1).to(device) batch_size = args.batch_size LR = 0.005 optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=0.9, weight_decay=0.0005) criterion = nn.BCEWithLogitsLoss() lr_list = [] liver_dataset = LiverDataset("data/train", transform=x_transforms, target_transform=y_transforms) dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=4) train_model(model, criterion, optimizer, dataloaders)
def train(args): model = Unet(3, 1).to(device) batch_size = args.batch_size # 损失函数,该类主要用来创建衡量目标和输出之间的二进制交叉熵的标准。 criterion = nn.BCEWithLogitsLoss() optimizer = optim.Adam(model.parameters()) # 初始化 liver_dataset = LiverDataSet( "/home/ming/code/u-net-liver-pytorch/data/train", transform=x_transforms, target_transform=y_transforms) # 读取数据集 # 它为我们提供的常用操作有:batch_size(每个batch的大小), # shuffle(是否进行shuffle操作), num_workers(加载数据的时候使用几个子进程) # shuffle是否将数据打乱; dataloaders = DataLoader(liver_dataset, batch_size=batch_size, shuffle=True, num_workers=4) train_model(model, criterion, optimizer, dataloaders)
def dnp(run_name, noisy_file, samples_dir, LR=0.001, num_iter=5000, save_every=50): # initiate model nlayers = 6 model = Unet(nlayers=nlayers, nefilters=60).cuda() samples_dir = os.path.join(samples_dir, run_name) utils.makedirs(samples_dir) # load data target, sr = utils.load_wav_to_torch(noisy_file) target = target[:(len(target) // 2**nlayers) * 2**nlayers] target = target / utils.MAX_WAV_VALUE input = torch.rand_like(target) input = (input - 0.5) * 2 target, input = target.cuda(), input.cuda() criterion = torch.nn.MSELoss() optimize(model.parameters(), model, criterion, input, target, samples_dir, LR, num_iter, sr, save_every)
reuse_weights = True if reuse_weights: net.load_state_dict(torch.load('./models/model_{}.pth'.format(name))) try: best_val_loss = np.load('./models/best_val_loss_{}.npy'.format(name)) except: best_val_loss = np.finfo(np.float64).max print("Model reloaded. Previous lowest validation loss =", str(best_val_loss)) else: best_val_loss = np.finfo(np.float64).max device = torch.device("cuda" if torch.cuda.is_available() else "cpu") net.to(device) criterion = nn.MSELoss() optimizer = torch.optim.Adam(net.parameters(), lr=5e-4, weight_decay=1e-4) best_weights = net.state_dict() num_epochs = 5 train_loss = np.zeros(num_epochs) validation_loss = np.zeros(num_epochs) print('\nStart training') np.savetxt('epochs_completed.txt', np.zeros(1), fmt='%d') for epoch in range(num_epochs): #TODO decide epochs print('-----------------Epoch = %d-----------------' % (epoch + 1)) train_loss[epoch], _ = train(train_loader, net, criterion, optimizer, device, epoch + 1) # TODO create your evaluation set, load the evaluation set and test on evaluation set val_loss = test(eval_loader, net, criterion, device)
experiment2( exp2, optimizer, scheduler, dataloaders, dataset_sizes, num_epochs=25 ) if exp == 'exp3': enhanced_vgg = EnhancedVGGNet(freeze_max=False) exp3 = Unet('exp3', enhanced_vgg) all_trainable_layers = [param for param in exp3.parameters() if param.requires_grad ] optimizer = optim.Adam(all_trainable_layers, lr=lr, weight_decay=w_decay) scheduler = lr_scheduler.StepLR(optimizer, step_size=step_size, gamma=gamma) # decay LR by a factor of 0.5 every 30 epochs print('Configs:') print('Exp3- Learning Rate %f, Number of epochs: %d, Batch size: %d' % (lr, epochs, batch_size) ) experiment3( exp3, optimizer, scheduler, dataloaders, dataset_sizes, num_epochs=25
print(labels.shape, labels.min(), labels.max(), labels.dtype) ######################################################################## # Model if args.model == 'resnet34' or args.model == 'se_resnet50': net = Unet(args.model, encoder_weights="imagenet", classes=4, activation=None, args=args).to( device) # pass model specification to the resnet32 ######################################################################## # optimizer # if args.optim == 'adam': optimizer = optim.Adam(net.parameters(), lr=0.001) ######################################################################## # Train the network seed_everything(seed=args.seed) if args.load_mod: history = { 'Train_loss': [], 'Train_dice': [], 'Valid_loss': [], 'Valid_dice': [] } net.load_state_dict(torch.load(MODEL_FILE)) else: net_swa, history = train_net(net, optimizer, device, args, LOG_FILE, MODEL_FILE)
from utils import plot_fig, get_mnist_loaders from torchvision.utils import save_image tp = 'ddpm' # if tp == 'ddpm': epochs = 10 ema_decay = 0.9999 update_ema_every = 10 model = Unet(dim=16, channels=1, dim_mults=(1, 2, 4)).cuda() # betas = cosine_beta_schedule(1000, ) betas = np.linspace(1e-4, 1e-2, 1000) diffusion = gaussian_ddpm(model, loss_type='l2', betas=betas).cuda() ema_model = copy.deepcopy(model) optim = torch.optim.Adam(model.parameters(), lr=1e-3) train_loader, test_loader, val_loader = get_mnist_loaders() ema = EMA(ema_decay) num = 0 for epoch in range(epochs): with tqdm(train_loader) as it: for x, label in it: num += 1 optim.zero_grad() loss = diffusion(x.cuda()) loss.backward() optim.step() it.set_postfix(ordered_dict={ 'train loss': loss.item(), 'epoch': epoch
torch.backends.cudnn.enabled = True torch.backends.cudnn.benchmark = True train_data_dir = 'data/train/' batch_size = 16 print("load training images") data = utils.np_from_imgs(train_data_dir, batch_size) batch_num = len(data) device = torch.device('cuda') dtype = torch.cuda.FloatTensor print("build unet") net = Unet().to(device) # net.apply(utils.weights_init) optimizer = torch.optim.Adam(net.parameters()) criterion = nn.MSELoss() def train(epoch): epoch_loss = 0. for j in range(1, batch_num + 1): clean_data = data[j - 1] sigma = np.random.uniform(0, 51) input_data = np.clip( clean_data + np.random.normal(scale=sigma, size=clean_data.shape), 0, 255) input_tensor = torch.from_numpy(input_data).type(dtype).to(device) optimizer.zero_grad() output_tensor = net(input_tensor) target_tensor = torch.from_numpy(clean_data).type(dtype).to(device)
num_workers=10, worker_init_fn=worker_init_fn) loadtest = data.DataLoader(test_set, batch_size=1, num_workers=10) loadval = data.DataLoader(validation_set, batch_size=6, num_workers=10, worker_init_fn=worker_init_fn) # In[6]: #model = Unet(skipDim, quantization_channels, residualDim,device) model = Unet() #model = nn.DataParallel(model) model = model.cuda() criterion = nn.MSELoss() # in wavenet paper, they said crossentropyloss is far better than MSELoss optimizer = optim.Adam(model.parameters(), lr=1e-4, weight_decay=1e-6, betas=(0.5, 0.999)) # use adam to train maxloss = np.zeros(50) + 100 # In[7]: iteration = 0 start_epoch = 0 if continueTrain: # if continueTrain, the program will find the checkpoints if os.path.isfile(resumefile): print("=> loading checkpoint '{}'".format(resumefile)) checkpoint = torch.load(resumefile) start_epoch = checkpoint['epoch'] iteration = checkpoint['iteration']
path_to_data=path_to_data_test, paired=True) testloader = data.DataLoader(loader, batch_size=1, num_workers=1, shuffle=False, drop_last=False, pin_memory=False) unet_qpi2dapi = Unet(feature_scale=8).cuda() unet_dapi2qpi = Unet(feature_scale=8).cuda() D_dapi = ResnetLike128(K=16).cuda() D_qpi = ResnetLike128(K=16).cuda() optimizer_unet_qpi2dapi = optim.Adam(unet_qpi2dapi.parameters(), lr=init_lr, betas=(0.5, 0.9)) optimizer_unet_dapi2qpi = optim.Adam(unet_dapi2qpi.parameters(), lr=init_lr, betas=(0.5, 0.9)) optimizer_D_dapi = optim.Adam(D_dapi.parameters(), lr=init_lr, betas=(0.5, 0.9)) optimizer_D_qpi = optim.Adam(D_qpi.parameters(), lr=init_lr, betas=(0.5, 0.9)) scheduler_unet_qpi2dapi = optim.lr_scheduler.StepLR( optimizer_unet_qpi2dapi, 2000, gamma=0.1, last_epoch=-1)
help='Run model fp16 mode.') args = parser.parse_args() train_dataset = dataset.MarsDataset() val_dataset = dataset.MarsDataset(val=True) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True) model = Unet(1, 1) model.cuda() lr=0.01 momentum=0.9 if args.fp16: assert torch.backends.cudnn.enabled, "fp16 mode requires cudnn backend to be enabled." model = network_to_half(model) param_copy = [param.clone().type(torch.cuda.FloatTensor).detach() for param in model.parameters()] for param in param_copy: param.requires_grad = True else: param_copy = list(model.parameters()) optimizer = torch.optim.SGD(param_copy, lr,momentum=momentum) if args.fp16: model.zero_grad() #optimizer = optim.Adagrad(model.parameters(), lr=0.01) def train(epoch): start = time.time() if args.fp16: loss_fn = nn.MSELoss().cuda().half() else:
loader = DataLoader(split='test', path_to_data='D:\jakubicek\spectral_CT_data', ids=test_ids) testloader = data.DataLoader(loader, batch_size=1, num_workers=0, shuffle=False, drop_last=False, pin_memory=False) unet = Unet(filters=[8, 16, 32, 32]).cuda() D = ResnetLike128(K=16).cuda() optimizer_unet = optim.Adam(unet.parameters(), lr=init_lr, betas=(0.5, 0.9)) optimizer_D = optim.Adam(D.parameters(), lr=init_lr, betas=(0.5, 0.9)) scheduler1 = optim.lr_scheduler.StepLR(optimizer_unet, 6000, gamma=0.1, last_epoch=-1) scheduler2 = optim.lr_scheduler.StepLR(optimizer_D, 6000, gamma=0.1, last_epoch=-1) # l2_loss = nn.MSELoss()
train_dataloader = DataLoader(dataset=SunnybrookDataset( TRAIN_IMG_PATH, TRAIN_CONTOUR_PATH, contour_type, crop_size), batch_size=2, shuffle=True, num_workers=4) validate_dataloader = DataLoader(dataset=SunnybrookDataset( VALID_IMG_PATH, VALID_CONTOUR_PATH, contour_type, crop_size), batch_size=2, shuffle=False, num_workers=4) unet = Unet(1, num_class, crop_size).to(device) criterion = MultiLoss() optimizer = optim.Adam(unet.parameters()) epochs = 100 for epoch in range(epochs): print("train epoch ", epoch + 1) epoch_loss = 0 for step, (img_batch, mask_batch) in enumerate(train_dataloader): img_batch = img_batch.float().to( device) # batch_size*channel*height*width mask_batch = mask_batch.long().to( device) # batch_size*height*width
import numpy as np from tqdm import tqdm import matplotlib.pyplot as plt from unet import Unet, Layer import time import cv2 MODEL_NAME = f"model-{int(time.time())}" # gives a dynamic model name, to just help with things getting messy over time. learning_rate = 0.001 epochs = 4 validation_percentage = 0.1 u_net = Unet() device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") u_net.to(device) optimizer = optim.Adam(u_net.parameters(), lr=learning_rate) loss_func = nn.MSELoss() def filter_img(img00, img01): kernel = np.ones((4, 4), np.uint8) subtract = cv2.subtract((img00 + 15), img01) kernel2 = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]]) img03 = cv2.filter2D(subtract, -1, kernel2) img03 = cv2.GaussianBlur(img03, (5, 5), 0) img03 = cv2.Canny(img03, 85, 255) img03 = cv2.morphologyEx(img03, cv2.MORPH_CLOSE, kernel, iterations=1) img03 = cv2.bitwise_not(img03) img03 = img03 & img00