def __init__(self, train_path, test_path, model_file, model, img_h=32, img_w=110, batch_size=64, lr=1e-3, use_unicode=True, best_loss=0.2, use_gpu=True, workers=1): self.model = model self.model_file = model_file self.use_unicode = use_unicode self.img_h = img_h self.img_w = img_w self.batch_size = batch_size self.lr = lr self.best_loss = best_loss self.best_acc = 0.95 self.use_gpu = use_gpu self.workers = workers self.converter = utils.strLabelConverter(alphabet) self.criterion = CTCLoss() if self.use_gpu: print("[use gpu] ...") self.model = self.model.cuda() self.criterion = self.criterion.cuda() if torch.cuda.is_available() and not self.use_gpu: print("[WARNING] You have a CUDA device, so you should probably run with --cuda") # 加载模型 if os.path.exists(self.model_file): self.load(self.model_file) else: print('[Load model] error !!!') self.transform = T.Compose([ T.Resize((self.img_h, self.img_w)), T.ToTensor(), # T.Normalize(mean=[.5, .5, .5], std=[.5, .5, .5]) ]) train_label = os.path.join(train_path, 'labels_normal.txt') train_dataset = my_dataset.MyDataset(root=train_path, label_file=train_label, transform=self.transform, is_train=True, img_h=self.img_h, img_w=self.img_w) self.train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=self.batch_size, shuffle=True, num_workers=int(self.workers)) test_label = os.path.join(test_path, 'labels_normal.txt') test_dataset = my_dataset.MyDataset(root=test_path, label_file=test_label, transform=self.transform, is_train=False, img_h=self.img_h, img_w=self.img_w) self.test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=self.batch_size, shuffle=False, num_workers=int(self.workers)) # setup optimizer # if opt.adam: # self.optimizer = optim.Adam(crnn.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) # elif opt.adadelta: # self.optimizer = optim.Adadelta(crnn.parameters(), lr=opt.lr) # else: # self.optimizer = optim.RMSprop(crnn.parameters(), lr=opt.lr) self.optimizer = optim.Adam(self.model.parameters(), lr=self.lr, weight_decay=1e-5)
IF_WANDB = 0 IF_SAVE = 0 LAYER_UNITS = 2000 LAYERS = 3 CLASS = 10 BATCH_SIZE = 100 NAME = 'neural_400_100' WORKERS = 15 if IF_WANDB: import wandb wandb.init(project='neural', name=NAME) #dataset = my_dataset.MyDataset(train = True, margin = 3, noise_rate = 0.05) dataset_test = my_dataset.MyDataset(train=False) #data_feeder = my_dataset.DataFeeder(dataset, BATCH_SIZE, num_workers = WORKERS) images_t, labels_t = dataset_test.get_all() class Quantized(torch.autograd.Function): @staticmethod def forward(ctx, input): ctx.save_for_backward(input) return (input >= 0).float() @staticmethod def backward(ctx, grad_output): input, = ctx.saved_tensors grad_input = grad_output.clone() grad_input[(input.abs() > 1)] = 0
import math import cv2 IF_WANDB = 1 IF_SAVE = 1 SIX = 6 BATCH_SIZE = 1000 WORKERS = 15 CLASS = 10 import cv2 if IF_WANDB: import wandb wandb.init(project='lut_hard') #, name = '.') dataset = my_dataset.MyDataset(train=True, margin=2, noise_rate=0.01) dataset_test = my_dataset.MyDataset(train=False) data_feeder = my_dataset.DataFeeder(dataset, BATCH_SIZE, num_workers=WORKERS) images_t, labels_t = dataset_test.get_all() delta_map = torch.zeros(2**SIX, SIX, 2).long().cuda() for i in range(2**SIX): bins = ('{0:0%db}' % SIX).format(i) for j in range(SIX): k = 2**j if bins[SIX - 1 - j] == '1': low = -k high = 0 else: low = 0 high = k
train_test_split = config['data']['train_test_split'] split_index = int(len(files)*train_test_split) train_files = files[:split_index] test_files = files[split_index:] # test_files = [f for f in files if np.load(label_dir + "/" + f + ".npy")[1] in range(6,8)] # print(test_files) print(f"Training samples: {len(train_files)}") print(f"Test samples: {len(test_files)}") # print(train_files[0:20]) # print(test_files) # print(np.load(data_dir + "/" + files[0] + ".npy").shape) train_dataset = my_dataset.MyDataset(config, train_files) test_dataset = my_dataset.MyDataset(config, test_files) batch_size = config['model']['batch_size'] train_loader, test_loader = my_dataset.make_variable_dataloader(train_dataset, test_dataset, batch_size = batch_size) print("Performing whole network training.") s = solver.Solver(train_loader, test_loader, config, load_dir = args.checkpoint) if args.load_emo is not None: s.model.load_pretrained_classifier(args.load_emo, map_location = 'cpu') print("Loaded pre-trained emotional classifier.")
if cuda: generator = DataParallel(generator) generator.to(device_for_model) discriminator = DataParallel(discriminator) discriminator.to(device_for_model) # Initialize weights generator.apply(my_model.weights_init_normal) discriminator.apply(my_model.weights_init_normal) transform_train = transforms.Compose([ transforms.Resize((256, 256)), transforms.ToTensor(), ]) dataset = my_dataset.MyDataset(data_path=data_dir, transform=transform_train) dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=0) # Optimizers optimizer_G = torch.optim.Adam(generator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2)) optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=opt.lr * 4, betas=(opt.b1, opt.b2)) optimizer_info = torch.optim.Adam(itertools.chain(generator.parameters(), discriminator.parameters()), lr=opt.lr,
sum_count = 0 for j, (inputs, ground_truth) in enumerate(test_loader): if CUDA: inputs = inputs.cuda() ground_truth = ground_truth.cuda() outputs = model(inputs) correct_count += ((outputs[:, 0] > 0.5) == (ground_truth[:, 0] == 1)).sum().item() sum_count += BATCH_SIZE # bar.update(j) # bar.finish() return correct_count / sum_count * 100 train_set = my_dataset.MyDataset('train') test_set = my_dataset.MyDataset('test') train_loader = torch.utils.data.DataLoader(train_set, BATCH_SIZE,\ shuffle = True, num_workers = 5, drop_last = True) test_loader = torch.utils.data.DataLoader(test_set, BATCH_SIZE,\ shuffle = True, num_workers = 5, drop_last = True) loss_f1 = nn.BCELoss() loss_f2 = nn.MSELoss() m = nn.Sigmoid() mm = nn.ReLU() for epoch in range(20000000): print('----- epoch %d -----' % epoch) time0 = time.time() # test_result = test() # print(test_result)