def load(self, shuffle=False): if not self.is_valid_path: return # Load train/val files ('data_batch_X' -> X={1,2,3,4,5}) files = [ os.path.join(self.data_dir, 'data_batch_%d' % (i + 1)) for i in range(5) ] labels_train_val, raw_images_train_val = self._load_images_labels( files) # Load test file (test_batch) files = [os.path.join(self.data_dir, 'test_batch')] labels_test, raw_images_test = self._load_images_labels(files) # Split training and validation sets X_train, X_val, y_train, y_val = train_val_split( raw_images_train_val, labels_train_val, proportion_train=0.75, random_state=self.random_seed, shuffle=shuffle) train_set = {'labels': y_train, 'data': X_train} val_set = {'labels': y_val, 'data': X_val} # Create test set test_set = {'labels': labels_test, 'data': raw_images_test} # Now the dataset is lodaded, lets load the mean and std of the train/val data self._load_mean_std({"train": train_set, "validation": val_set}) return {"train": train_set, "validation": val_set, "test": test_set}
def data(): data_root = '/nosave/lange/cu-ssp/data/netsurfp/' file_train = 'train_700' file_test = ['cb513_700', 'ts115_700', 'casp12_700'] X_test = np.load(data_root + file_test[0] + '_input.npy') profiles = np.load(data_root + file_test[0] + '_hmm.npy') mean = np.mean(profiles) std = np.std(profiles) X_aug_test = (profiles - mean) / std X_test_aug = np.concatenate((X_test, X_aug_test), axis=2) y_test = np.load(data_root + file_test[0] + '_q8.npy') X_train = np.load(data_root + file_train + '_input.npy') profiles = np.load(data_root + file_train + '_hmm.npy') mean = np.mean(profiles) std = np.std(profiles) X_aug_train = (profiles - mean) / std X_train_aug = [X_train, X_aug_train] y_train = np.load(data_root + file_train + '_q8.npy') X_train_aug, y_train, X_val_aug, y_val = train_val_split( X_train_aug, y_train) return X_train_aug, y_train, X_val_aug, y_val, X_test_aug, y_test
def train(): print("Starting!") model = VRNN(2, 256, 196, 1) model.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) p1_trajectories = preprocess(1, 32)[:, :, 0:2] p2_trajectories = preprocess(2, 32)[:, :, 0:2] trajectories = np.concatenate((p1_trajectories, p2_trajectories)) np.random.shuffle(trajectories) # randomize trajectories for train/val trajectories, _max, _min = normalize(trajectories) train, test = train_val_split(trajectories, val_split=0.15) train = torch.from_numpy(train).float().to(device) test = torch.from_numpy(test).float().to(device) __max = torch.tensor(_max).float().to(device) __min = torch.tensor(_min).float().to(device) print("Max", __max, "Min", __min) training_generator = data.DataLoader(train, batch_size=32, shuffle=True, drop_last=True) validation_generator = data.DataLoader( test, batch_size=32, shuffle=False, drop_last=True) # for computing overall loss val_loss = float("inf") for epoch in range(1, 2001): for batch in training_generator: optimizer.zero_grad() kld_loss, mse_loss = model.forward(batch, __max, __min) loss = kld_loss + mse_loss loss.backward() optimizer.step() kld_loss = 0 mse_loss = 0 with torch.no_grad(): for batch in validation_generator: _kld_loss, _mse_loss = model.forward(batch, __max, __min) kld_loss += _kld_loss mse_loss += _mse_loss kld_loss /= len(validation_generator) mse_loss /= len(validation_generator) print("Epoch {} kld_loss={}, mse_loss={}".format( epoch, kld_loss, mse_loss)) if kld_loss + mse_loss < val_loss: print("Val_loss lowered from {} to {}. Saving model...".format( val_loss, kld_loss + mse_loss)) torch.save(model.state_dict(), os.path.join(WEIGHTS_DIR, "32_p1-2_vrnn.pth")) val_loss = kld_loss + mse_loss
def main(): # downloading the dataset transform = torchvision.transforms.Compose([ torchvision.transforms.ToTensor(), torchvision.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) trainset = torchvision.datasets.CIFAR10(root="/data", train=True, download=True, transform=transform) testset = torchvision.datasets.CIFAR10(root="/data", train=False, download=True, transform=transform) train_set, train_set_label, validation_set, validation_set_label = ut.train_val_split( trainset) flat_test, labels = ut.process_test_set(testset) print("The splits are: ") print(train_set.shape, train_set_label.shape) print(validation_set.shape) #training myNN = NeuralNetwork(OUTPUTS, IMAGESIZE, BATCHSIZE, LEARNINGRATE, LAYERS) # # starting the training myNN.train(train_set, train_set_label, validation_set, validation_set_label, ITERATIONS) myNN.save() myNN.clean() # testing myNNtest = NeuralNetwork(OUTPUTS, IMAGESIZE, BATCHSIZE, LEARNINGRATE, LAYERS) myNNtest.load(wFile, bFile) print("validation accuracy for current", myNNtest.check(validation_set, validation_set_label)) print("train accuracy for current", myNNtest.check(train_set, train_set_label)) images, label, predictions = myNNtest.pred(flat_test.T, labels) classes = [ 'plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck' ] for x in range(10): ut.imshow(testset[x][0]) print("Ground Truth: ", label[x], classes[label[x]]) print("prediction: ", predictions[x], classes[predictions[x]])
def run_twolayer(out_file, title): net = TwoLayerNet(n_input=in_seq_len, n_hidden=10, n_output=out_seq_len) net.compile("adam", "mse") train_data, val_data = train_val_split(data_points, val_fraction=0.5) train_x, train_y = generate_sequences(train_data, in_seq_len, out_seq_len) val_x, val_y = generate_sequences(val_data, in_seq_len, out_seq_len) history = net.train(train_x, train_y, val_x, val_y, epochs=epochs, verbose=0) train_prediction = net.predict(train_x) val_prediction = net.predict(val_x) # plot results plot_prediction(data_points, train_prediction, val_prediction, in_seq_len, out_file, title) return history
def run_cnn(out_file, title): net = CNNPredictor(n_hidden, out_seq_len) net.compile("adam", "mse") train_data, val_data = train_val_split(data_points, val_fraction=0.5) train_x, train_y = generate_sequences(train_data, in_seq_len, out_seq_len) val_x, val_y = generate_sequences(val_data, in_seq_len, out_seq_len) train_x = train_x.reshape(*train_x.shape, 1) val_x = val_x.reshape(*val_x.shape, 1) history = net.train(train_x, train_y, val_x, val_y, epochs=epochs, verbose=0) train_prediction = net.predict(train_x) val_prediction = net.predict(val_x) # plot results plot_prediction(data_points, train_prediction, val_prediction, in_seq_len, out_file, title) return history
def default_loader(): """ default loading Kuzushiji19 dataset using default transform and default validation set size Returns: train, val, test (three dataloaders) """ transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize([0.5],[0.5]) ]) datasets = [] train_dataset = Kuzhushiji49Dataset(root, transform = transform, train=True) train_dataset, val_dataset = train_val_split(train_dataset) test_dataset = Kuzhushiji49Dataset(root, transform =transform, train=False) datasets = [train_dataset, val_dataset, test_dataset] dataloaders = [] for dataset in datasets: dataloaders.append(DataLoader(dataset, shuffle=True, num_workers=2, batch_size=32)) return dataloaders
def create_patches_dataset_iam(data_path, new_path, height=100, width=100, num_patches=10, seed=None, binary=False, stride=1): if not exists(new_path): makedirs(new_path) d = get_labels_iam() for label, imgs in tqdm(d.items()): train_label_dir = join(new_path, 'train', str(label)) validation_label_dir = join(new_path, 'validation', str(label)) test_label_dir = join(new_path, 'test', str(label)) if not exists(train_label_dir): makedirs(train_label_dir) if not exists(validation_label_dir): makedirs(validation_label_dir) if not exists(test_label_dir): makedirs(test_label_dir) if len(imgs) == 1: if binary: img = imread(data_path + imgs[0], as_gray=True, plugin='pil') otsu = threshold_otsu(img) img = img < otsu else: img = Image.open(data_path + imgs[0]) img = asarray(img) train_img, test_img = halve_image(img) train_img = text_padding3(train_img, max_width=2350, max_height=2195) test_img = text_padding3(test_img, max_width=2350, max_height=2195) else: if binary: train_img = text_padding_numpy(data_path + imgs[0]) otsu = threshold_otsu(train_img) train_img = train_img < otsu test_img = text_padding_numpy(data_path + imgs[1]) otsu = threshold_otsu(test_img) test_img = test_img < otsu else: train_img = text_padding2(data_path + imgs[0], max_width=2350, max_height=2195) test_img = text_padding2(data_path + imgs[1], max_width=2350, max_height=2195) train_img = asarray(train_img) test_img = asarray(test_img) train_and_val_patches = extract_patches_2d(train_img, (height, width), num_patches, random_state=seed, stride=stride, th=1000) train_patches, val_patches = utils.train_val_split( train_and_val_patches, train_ratio=0.9) test_patches = extract_patches_2d(test_img, (height, width), random_state=seed, stride=(height, width), th=1000) a = 1 for p in range(len(train_patches)): patch = train_patches[p] img = fromarray(patch) img_dir = join(train_label_dir, imgs[0].split('.')[0] + '_patch_' + str(a) + '.jpg') if binary: img.save(img_dir, mode=1, optimize=True) else: img.save(img_dir) a = a + 1 b = 1 for p in range(len(val_patches)): patch = val_patches[p] img = fromarray(patch) img_dir = join(validation_label_dir, imgs[0].split('.')[0] + '_patch_' + str(b) + '.jpg') if binary: img.save(img_dir, mode=1, optimize=True) else: img.save(img_dir) b = b + 1 c = 1 for p in range(len(test_patches)): patch = test_patches[p] img = fromarray(patch) try: img_dir = join( test_label_dir, imgs[1].split('.')[0] + '_patch_' + str(c) + '.jpg') except IndexError: img_dir = join( test_label_dir, imgs[0].split('.')[0] + '_patch_' + str(c) + '.jpg') if binary: img.save(img_dir, mode=1, optimize=True) else: img.save(img_dir) c = c + 1
def create_patches_dataset_firemaker(train_path, test_path, new_path, height=256, width=256, num_patches=100, seed=None, binary=False, stride=1): if not exists(new_path): makedirs(new_path) train_file_names = sorted(listdir(train_path)) test_file_names = sorted(listdir(test_path)) for t in tqdm(range(len(train_file_names))): train_label_dir = join(new_path, 'train', str(t)) validation_label_dir = join(new_path, 'validation', str(t)) test_label_dir = join(new_path, 'test', str(t)) if not exists(train_label_dir): makedirs(train_label_dir) if not exists(validation_label_dir): makedirs(validation_label_dir) if not exists(test_label_dir): makedirs(test_label_dir) if binary: train_img = text_padding_numpy(train_path + train_file_names[t]) otsu = threshold_otsu(train_img) train_img = train_img < otsu test_img = text_padding_numpy(test_path + test_file_names[t]) otsu = threshold_otsu(test_img) test_img = test_img < otsu else: train_img = text_padding2(train_path + train_file_names[t], max_width=2480, max_height=2100) test_img = text_padding2(test_path + test_file_names[t], max_width=2480, max_height=2100) train_img = asarray(train_img) test_img = asarray(test_img) train_and_val_patches = extract_patches_2d(train_img, (height, width), num_patches, random_state=seed, stride=stride) train_patches, val_patches = utils.train_val_split( train_and_val_patches, train_ratio=0.9) test_patches = extract_patches_2d(test_img, (height, width), random_state=seed, stride=(height, width)) a = 1 for p in range(len(train_patches)): patch = train_patches[p] img = fromarray(patch) img_dir = join( train_label_dir, train_file_names[t].split('.')[0] + '_patch_' + str(a) + '.jpg') if binary: img.save(img_dir, mode=1, optimize=True) else: img.save(img_dir) a = a + 1 b = 1 for p in range(len(val_patches)): patch = val_patches[p] img = fromarray(patch) img_dir = join( validation_label_dir, train_file_names[t].split('.')[0] + '_patch_' + str(b) + '.jpg') if binary: img.save(img_dir, mode=1, optimize=True) else: img.save(img_dir) b = b + 1 c = 1 for p in range(len(test_patches)): patch = test_patches[p] img = fromarray(patch) img_dir = join( test_label_dir, test_file_names[t].split('.')[0] + '_patch_' + str(c) + '.jpg') if binary: img.save(img_dir, mode=1, optimize=True) else: img.save(img_dir) c = c + 1
def train_geometric_matching(): trans_params = { 'rotation': (0, 0), 'offset': (0, 0), 'flip': (False, False), 'shear': (0., 0.), 'stretch': (1. / 2, 2), } print('building model') layers = vgg16.build_model((None, 3, 227, 227)) # file to store the learned weights weightsfile = join('weights', 'weights.pickle') # initialize the feature extraction layers pretrainfile = join('weights', 'vgg16.pkl') print('initializing feature extraction layers from %s' % (pretrainfile)) with open(pretrainfile, 'rb') as f: data = pickle.load(f) # weights are tied, no need to initialize a and b set_all_param_values(layers['pool4a'], data['param values'][0:20]) # used to initialize from learned weights #with open(weightsfile, 'rb') as f: # param_values = pickle.load(f) #set_all_param_values(layers['trans'], param_values) mean = data['mean value'] max_epochs = 5000 batch_size = 16 sample_every = 25 # visualizes network output every n epochs sample_dir = join('data', 'samples') # set this to point to the root of Pascal VOC-2011 voc_fpath = '/media/hdd/hendrik/datasets/pascal-2011' train_fpaths, valid_fpaths = utils.train_val_split(voc_fpath) print('compiling theano functions for training') train_func = theano_funcs.create_train_func(layers) print('compiling theano functions for validation') valid_func = theano_funcs.create_valid_func(layers) try: for epoch in range(1, max_epochs + 1): print('epoch %d' % (epoch)) train_losses = [] num_train_idx = (len(train_fpaths) + batch_size - 1) / batch_size train_iter = utils.get_batch_idx(len(train_fpaths), batch_size) for i, idx in tqdm(train_iter, total=num_train_idx, leave=False): X_crop_train, X_warp_train, M_train =\ utils.prepare_synth_batch(train_fpaths[idx], mean, trans_params) M, train_loss = train_func(X_crop_train, X_warp_train, M_train) train_losses.append(train_loss) if epoch % sample_every == 0: utils.plot_samples(X_crop_train, X_warp_train, M, mean, prefix=join(sample_dir, 'train_%d' % i)) print(' train loss = %.6f' % (np.mean(train_losses))) valid_losses = [] num_valid_idx = (len(valid_fpaths) + batch_size - 1) / batch_size valid_iter = utils.get_batch_idx(len(valid_fpaths), batch_size) for i, idx in tqdm(valid_iter, total=num_valid_idx, leave=False): X_crop_valid, X_warp_valid, M_valid =\ utils.prepare_synth_batch(valid_fpaths[idx], mean, trans_params) M, valid_loss = valid_func(X_crop_valid, X_warp_valid, M_valid) valid_losses.append(valid_loss) if epoch % sample_every == 0: utils.plot_samples(X_crop_valid, X_warp_valid, M, mean, prefix=join(sample_dir, 'valid_%d' % i)) print(' valid loss = %.6f' % (np.mean(valid_losses))) except KeyboardInterrupt: print('caught ctrl-c, stopped training') print('saving weights to %s' % (weightsfile)) weights = get_all_param_values(layers['trans']) with open(weightsfile, 'wb') as f: pickle.dump(weights, f, protocol=pickle.HIGHEST_PROTOCOL)
from utils import load_data, train_val_split from model import UnetBrain from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau import sys import matplotlib.pyplot as plt plt.style.use("ggplot") train_data = load_data('./machine_learning_challenge/train_data.csv') train_label = load_data('./machine_learning_challenge/train_label.csv') test_data = load_data('./machine_learning_challenge/test_data.csv') test_label = load_data('./machine_learning_challenge/test_label.csv') X_train, y_train, X_val, y_val = train_val_split(train_data, train_label, val_size=0.20) X_train.shape fig, axes = plt.subplots(nrows=1, ncols=2) ax = axes.ravel() ax[0].imshow(np.squeeze(X_train[100])) ax[0].set_title("image") ax[1].imshow(np.squeeze(y_train[100])) ax[1].set_title("label") plt.show() # input parameters params = {}
from NeuralNetwork import * from Layer import * #mnist.init() X_train, Y_train, X_test, Y_test = mnist.load() # Pre-process data. For computers with less RAM, we must slice the training set X_train = X_train[0:50000] Y_train = Y_train[0:50000] X_train, X_test = (X_train / 127.5) - 1, (X_test / 127.5) - 1 X_train = utils.bias_trick(X_train) X_test = utils.bias_trick(X_test) Y_train, Y_test = utils.onehot_encode(Y_train), utils.onehot_encode(Y_test) X_train, Y_train, X_val, Y_val = utils.train_val_split(X_train, Y_train, 0.1) #Add Layers hidden_layer = Layer(num_input=X_train.shape[1], num_neurons=64, activation_func=utils.relu, activation_func_der=utils.relu_der) output_layer = Layer( num_input=64, num_neurons=Y_train.shape[1], activation_func=utils.softmax ) #The derivation of the activation function of the output layer is not used #Create network model = NeuralNetwork(max_epochs=20, learning_rate=0.01, should_gradient_check=False, batch_size=256,
patches_img = np.array(patches_img) patches_mask = np.array(patches_mask) return patches_img, patches_mask ########## ## MAIN ## ########## def parse_args(): parser = argparse.ArgumentParser(description="Arguments for training") parser.add_argument("-i", "--images_folder", dest="images_folder", help="Path to images (and mask) folder", required=True) parser.add_argument("-o", "--output_folder", dest="output_folder", help="Path to the output folder (for patches)", required=True) parser.add_argument("-ps", "--patch_size", dest="patch_size", help="Patch size", default=constants.PATCH_SIZE, type=int) parser.add_argument("-p", "--train_prop", dest="train_prop", help="Proportion of train set", default=constants.TRAIN_PROPORTION, type=float) return parser.parse_args() if __name__ == "__main__": args = parse_args() img_ids = utils.get_img_ids(args.images_folder) train_img_ids, val_img_ids = utils.train_val_split(img_ids, args.train_prop) for img_id in tqdm(train_img_ids): patches_img, patches_mask = extract_patches(img_id, args.images_folder, args.patch_size) for k in range(len(patches_img)): cv2.imwrite("{}/train/images/{}_{}.jpg".format(args.output_folder, img_id, k), patches_img[k]) cv2.imwrite("{}/train/masks/{}_{}.jpg".format(args.output_folder, img_id, k), patches_mask[k]) for img_id in tqdm(val_img_ids): patches_img, patches_mask = extract_patches(img_id, args.images_folder, args.patch_size) for k in range(len(patches_img)): cv2.imwrite("{}/val/images/{}_{}.jpg".format(args.output_folder, img_id, k), patches_img[k]) cv2.imwrite("{}/val/masks/{}_{}.jpg".format(args.output_folder, img_id, k), patches_mask[k])
import dataloader import settings import utils K = settings.folds cnn = model.CNN() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(cnn.parameters(), lr=settings.lr, momentum=settings.momentum) trainset = dataloader.trainset start = time.time() for k in range(K): train_loss, val_loss = [], [] trainloader, valloader = utils.train_val_split(trainset, K) print("data loaded") for epoch in range(settings.epochs): for i, data in enumerate(trainloader): inputs, labels = data optimizer.zero_grad() outputs = cnn(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() train_loss.append(loss.item()) for i, data in enumerate(valloader): inputs, labels = data outputs = cnn(inputs) loss = criterion(outputs, labels) val_loss.append(loss.item())
NB_AS = X_train_aug.shape[2] print("y train shape: ", y_train.shape) time_data = time.time() - start_time save_results = True if cross_validate: cv_scores, model_history = crossValidation(load_file, X_train_aug, y_train) test_accs = save_cv(weights_file, cv_scores, file_scores, file_scores_mean, N_FOLDS) test_acc = test_accs[file_test[0] + '_mean'] else: X_train_aug, y_train, X_val_aug, y_val = train_val_split( hmm, X_train_aug, y_train, tv_perc, embedding) model, history = build_and_train(X_train_aug, y_train, X_val_aug, y_val, epochs=epochs) test_acc = evaluate_model(model=model, load_file=load_file, file_test=file_test, hmm=hmm, normalize=normalize, standardize=standardize, embedding=embedding) time_end = time.time() - start_time m, s = divmod(time_end, 60)
def main(): data_name = "augmented_1" data_path = os.path.join("./data", data_name) csv_name = data_name + ".csv" train_df = pd.read_csv(os.path.join(data_path, csv_name)) keypoint_names = list( map(lambda x: x[:-2], train_df.columns.to_list()[1::2])) keypoint_flip_map = [ ("left_eye", "right_eye"), ("left_ear", "right_ear"), ("left_shoulder", "right_shoulder"), ("left_elbow", "right_elbow"), ("left_wrist", "right_wrist"), ("left_hip", "right_hip"), ("left_knee", "right_knee"), ("left_ankle", "right_ankle"), ("left_palm", "right_palm"), ("left_instep", "right_instep"), ] image_list = train_df.iloc[:, 0].to_numpy() keypoints_list = train_df.iloc[:, 1:].to_numpy() train_imgs, valid_imgs, train_keypoints, valid_keypoints = train_val_split( image_list, keypoints_list, random_state=42) image_set = {"train": train_imgs, "valid": valid_imgs} keypoints_set = {"train": train_keypoints, "valid": valid_keypoints} hyper_params = { "augmented_ver": data_name, "learning_rate": 0.001, "num_epochs": 10000, "batch_size": 256, "description": "Final training" } for phase in ["train", "valid"]: DatasetCatalog.register( "keypoints_" + phase, lambda phase=phase: get_data_dicts(data_path, image_set[phase], keypoints_set[phase])) MetadataCatalog.get("keypoints_" + phase).set(thing_classes=["human"]) MetadataCatalog.get("keypoints_" + phase).set(keypoint_names=keypoint_names) MetadataCatalog.get("keypoints_" + phase).set(keypoint_flip_map=keypoint_flip_map) MetadataCatalog.get("keypoints_" + phase).set(evaluator_type="coco") cfg = get_cfg() cfg.merge_from_file( model_zoo.get_config_file( "COCO-Keypoints/keypoint_rcnn_X_101_32x8d_FPN_3x.yaml")) cfg.DATASETS.TRAIN = ("keypoints_train", ) cfg.DATASETS.TEST = ("keypoints_valid", ) cfg.DATALOADER.NUM_WORKERS = 16 # On Windows environment, this value must be 0. cfg.SOLVER.IMS_PER_BATCH = 2 # mini batch size would be (SOLVER.IMS_PER_BATCH) * (ROI_HEADS.BATCH_SIZE_PER_IMAGE). cfg.SOLVER.BASE_LR = hyper_params["learning_rate"] # Learning Rate. cfg.SOLVER.MAX_ITER = hyper_params["num_epochs"] # Max iteration. cfg.SOLVER.GAMMA = 0.8 cfg.SOLVER.STEPS = [ 3000, 4000, 5000, 6000, 7000, 8000 ] # The iteration number to decrease learning rate by GAMMA. cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url( "COCO-Keypoints/keypoint_rcnn_X_101_32x8d_FPN_3x.yaml") cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = hyper_params[ "batch_size"] # Use to calculate RPN loss. cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1 cfg.MODEL.ROI_KEYPOINT_HEAD.NUM_KEYPOINTS = 24 cfg.TEST.KEYPOINT_OKS_SIGMAS = np.ones((24, 1), dtype=float).tolist() cfg.TEST.EVAL_PERIOD = 5000 # Evaluation would occur for every cfg.TEST.EVAL_PERIOD value. cfg.OUTPUT_DIR = os.path.join("./output", data_name) os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) trainer = Trainer(cfg) trainer.resume_or_load(resume=False) trainer.train() # Inference should use the config with parameters that are used in training # cfg now already contains everything we've set previously. We changed it a little bit for inference: cfg.MODEL.WEIGHTS = os.path.join( cfg.OUTPUT_DIR, "model_final.pth") # path to the model we just trained cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.7 # set a custom testing threshold predictor = DefaultPredictor(cfg) test_dir = os.path.join("data", "test_imgs") test_list = os.listdir(test_dir) test_list.sort() except_list = [] files = [] preds = [] for file in tqdm(test_list): filepath = os.path.join(test_dir, file) im = cv2.imread(filepath) outputs = predictor(im) outputs = outputs["instances"].to("cpu").get("pred_keypoints").numpy() files.append(file) pred = [] try: for out in outputs[0]: pred.extend([float(e) for e in out[:2]]) except IndexError: pred.extend([0] * 48) except_list.append(filepath) preds.append(pred) df_sub = pd.read_csv("./data/sample_submission.csv") df = pd.DataFrame(columns=df_sub.columns) df["image"] = files df.iloc[:, 1:] = preds df.to_csv(os.path.join(cfg.OUTPUT_DIR, f"{data_name}_submission.csv"), index=False) if except_list: print( "The following images are not detected keypoints. The row corresponding that images names would be filled with 0 value." ) print(*except_list) save_samples(cfg.OUTPUT_DIR, test_dir, os.path.join(cfg.OUTPUT_DIR, f"{data_name}_submission.csv"), mode="random", size=5)
print() print('+------------------------------------+') print('| PRODUVIA |') print('+------------------------------------+') print() PATH = Path(kvargs['data_path']) DEVICE = kvargs['device'] padding = partial(dynamic_ws_padding, max_sent=kvargs['max_sent'], max_words=kvargs['max_sent_words']) # create mapping text <-> sent data = imdb_extraction(PATH/'train') test = imdb_extraction(PATH/'test') # split data into train & validation train, valid = train_val_split(data, train_ptg=.8) # create vocabulary t2i, i2t = create_vocab(train) # create datasets train_ds = ha_dataset(train, t2i) valid_ds = ha_dataset(valid, t2i) # create dataloaders train_dl = DataLoader(train_ds, shuffle=True, batch_size=kvargs['bs'], collate_fn=padding, drop_last=True) valid_dl = DataLoader(valid_ds, shuffle=False, batch_size=kvargs['bs'], collate_fn=padding, drop_last=True) # define architecutre
images_per_video = 250 num_training_images = 200 img_height = 288 img_width = 160 frames_to_mix = 3 input_shape = (3, img_height, img_width) remake_images = False ImageMaker = VideoToBlurredImgConverter(images_per_video, frames_to_mix, img_height, img_width, vid_dir = './data/', rebuild_target_dir=False) if remake_images: ImageMaker.make_and_save_images() train_fnames, val_fnames = train_val_split('./data', num_training_images, images_per_video) data_feeder = DataFeeder(batch_size=20, gen_only_batch_size=20, fnames=train_fnames) gen_model, disc_model, gen_disc_model = make_models(input_shape, n_filters_in_res_blocks=[64 for _ in range(3)], gen_filter_size=3, layers_in_res_blocks=2, res_block_subsample=(2, 2), filters_in_deconv=[32 for _ in range(3)], deconv_filter_size=3, n_disc_filters=[64, 32, 32]) trainer = Trainer(gen_model, disc_model, gen_disc_model, data_feeder, report_freq=10) trainer.train(n_steps=1000) gen_model, disc_model, gen_disc_model = trainer.get_models() save_predicted_images(gen_model, val_fnames)