def get_data_loader(name, train=True): """Get data loader by name.""" if name == "MNIST": return get_mnist(train) elif name == "USPS": return get_usps(train) elif name == "SVHN": return get_svhn(train)
def get_data_loader(name, train=True, get_dataset=False): """Get data loader by name.""" if name == "MNIST": return get_mnist(train, get_dataset) elif name == "MNIST-M": return get_mnist_m(train, get_dataset) elif name == "SVHN": return get_svhn(train, get_dataset) elif name == "USPS": return get_usps(train, get_dataset)
def get_data_loader(name, train=True): """Get data loader by name.""" if name == "MNIST": return get_mnist(train) elif name == "USPS": return get_usps(train) elif name == "CIFAR10": return get_cifar10(train) elif "CIFAR10-" in name: corruption = name.split('-')[1] return get_cifar10(train, corruption=corruption)
def get_data_loader(name, train=True,domain=None,visualize=False): """Get data loader by name.""" if name == "MNIST": raise NotImplementedError return get_mnist(train) elif name == "USPS": raise NotImplementedError return get_usps(train) elif name == "Dollarstreet": return get_dollarstreet(visualize,domain) else: raise NotImplementedError
def get_data_loader(name, dataset_root, batch_size, train=True): """Get data loader by name.""" if name == "mnist": return get_mnist(dataset_root, batch_size, train) elif name == "mnistm": return get_mnistm(dataset_root, batch_size, train) elif name == "svhn": return get_svhn(dataset_root, batch_size, train) elif name == "amazon31": return get_office(dataset_root, batch_size, 'amazon') elif name == "webcam31": return get_office(dataset_root, batch_size, 'webcam') elif name == "webcam10": return get_officecaltech(dataset_root, batch_size, 'webcam')
def get_data_loader(name, train=True): """Get data loader by name.""" if name == "MNIST": dataset = get_mnist(train) elif name == "MNISTM": dataset = get_mnistm(train) elif name == "USPS": dataset = get_usps(train) elif name == "SVHN": dataset = get_svhn(train) if train: data_loader = torch.utils.data.DataLoader(dataset=dataset, batch_size=params.batch_size, shuffle=True) else: data_loader = torch.utils.data.DataLoader(dataset=dataset, batch_size=1, shuffle=False) return data_loader
def get_data_loader(name, train=True, dataset=None, sample=False): """Get data loader by name.""" if name == "MNIST": return get_mnist(train, sample) elif name == "MNIST-M": return get_mnist_m(train) elif name == "SVHN": return get_svhn(train) elif name == "USPS": return get_usps(train, sample) elif name == "SYNTH": return get_synth(train) elif name == "SYNTHSIGN": return get_synthsign(train) elif name == "GTSRB": return get_gtsrb(train) elif name == "STL": return get_stl(train) elif name == "CIFA": return get_cifa(train) elif name == "PIE27": return get_pie27(train) elif name == "PIE05": return get_pie05(train) elif name == "PIE09": return get_pie09(train) elif name == "PIE37": return get_pie37(train) elif name == "PIE25": return get_pie25(train) elif name == "PIE02": return get_pie02(train) elif name == "taskcv_S": return get_taskcv_s(train) elif name == "taskcv_T": return get_taskcv_t(train) elif name == "OFFICE": return get_office(dataset)
p.add_argument('-g', '--gen-input-dim', type=int, default=100, help='Generator input dimension.') p.add_argument('--num-gen', type=int, default=0, help='Number of digits to generate after training.') p.add_argument('-v', '--verbose', action='store_true', help='Print losses after each epoch') args = p.parse_args() train_x, train_y, test_x, test_y = get_mnist() # normalize inputs to [0, 1] train_x /= 255 test_x /= 255 if torch.cuda.is_available(): dev = torch.device('cuda') else: dev = torch.device('cpu') numbers = range(10) # subset of numbers to train on train_mask = make_mask(train_y, numbers) xs = train_x[train_mask] dataset = MyDataset(xs) m = GAN(28 * 28, gen_input_dim=args.gen_input_dim,
fit the recursive clustering model to the data """ self.data = data data_index = np.array([(i, False) for i in range(data.shape[0])]) self.data_index = data_index self._recursiveClustering(data=data, depth=0, index=data_index) self.labels_ = self.data_index[:, 1] if __name__ == '__main__': from datasets import get_mnist mnist_train, _, mnist_test, mnist_test_lable = get_mnist() mnist_train = mnist_train.astype('float32') / 255. mnist_train = mnist_train.reshape( (len(mnist_train), np.prod(mnist_train.shape[1:]))) from time import time start_time = time() gmeans = GMeans(min_obs=3000, random_state=1010, max_depth=10, strictness=0) gmeans.fit(mnist_train) print("=" * 88) print("K = {} Time = {}".format(len(set(list(gmeans.labels_))), int(time() - start_time))) print("=" * 88)
from nn.graph import Graph import nn.model as model from datasets import get_mnist import nn_model import tf_model from barray import BArrayOs from tester import Tester BATCH_SIZE = 32 LEARNING_RATE = 1e-3 NUM_EPOCHS = 25 (X_train, y_train), (X_test, y_test) = get_mnist() print(X_train.shape) print(y_train.shape) model_base, model_probs, optimizer = nn_model.build_nn_model( BATCH_SIZE, LEARNING_RATE) tf_model_base, tf_model_probs, tf_weights = tf_model.build_tf_model() def check_forward(): model_base.assign_weights(tf_weights) tester = Tester() tf_logits = tf_model_base(X_train[:BATCH_SIZE]).numpy() nn_logits = model_base(X_train[:BATCH_SIZE], dump_code=True)
parser.add_argument('--path', type=str, default=r'alexnet/alexnet_cifar10_strip_pruned_90.h5', help='path to model ') parser.add_argument('--train', default=False, help='Initial train') parser.add_argument('--plot_model', default=False, help='plot model') parser.add_argument('--lra_algo', type=str, default='rrqr', help='lra algorithm') args = parser.parse_args() # Get Dataset if args.dataset == 'mnist': img_rows, img_cols, img_channels = 28, 28, 1 num_classes = 10 (x_train, y_train), (x_test, y_test), input_shape = datasets.get_mnist( (img_rows, img_cols, img_channels)) elif args.dataset == 'cifar10': img_rows, img_cols, img_channels = 32, 32, 3 num_classes = 10 (x_train, y_train), (x_test, y_test), input_shape = datasets.get_cifar10( (img_rows, img_cols, img_channels)) else: img_rows, img_cols, img_channels = 32, 32, 3 num_classes = 100 (x_train, y_train), (x_test, y_test), input_shape = datasets.get_cifar100( (img_rows, img_cols, img_channels)) # Get model if args.arch == 'alexnet': model = models.AlexNetModel(input_shape, num_classes)
model.add(Conv2D(28, kernel_size=(3, 3), input_shape=mnist_input_shape)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(128, activation=tf.nn.relu)) model.add(Dropout(0.2)) model.add(Dense(10, activation=tf.nn.softmax)) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) return model np.random.seed(42) rn.seed(12345) tf.compat.v1.set_random_seed(1234) x_train, y_train, x_test, y_test = datasets.get_mnist() #is_labeled, x_labeled, y_labeled = init_generators.default_init(x_train, y_train, INIT_SIZE) x_train1, y_train1 = x_train.copy(), y_train.copy() x_train2, y_train2 = x_train.copy(), y_train.copy() tf.compat.v1.keras.backend.clear_session() np.random.seed(42) rn.seed(12345) tf.compat.v1.set_random_seed(1234) session_conf = tf.compat.v1.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1) sess = tf.compat.v1.Session(graph=tf.compat.v1.get_default_graph(), config=session_conf) K.set_session(sess) print("random:", rn.random())
class ocr(obeject): def __init__(self): self.mnist = datasets.get_mnist()
import matplotlib.pyplot as plt config_dict = { 'score': 'accuracy', 'query': 'entropy', 'model': 'mnist_1', 'init_size': 2000, 'batch_size': 1, 'total_size': 10000, 'queries_number': 10, 'random_state': 0 } config = scenarios.Config(config_dict) print(config) x, y, x_test, y_test = ds.get_mnist() experiment = scenarios.Experiment(config, 'uncertainty', x, y, (x_test, y_test)) unc = experiment.run() plots.plot_single(unc, 'unc') config_2 = config.set_query_f('default') experiment_2 = scenarios.Experiment(config_2, 'uncertainty', x, y, (x_test, y_test)) passive = experiment_2.run() plots.plot_single(passive, 'passive') config_3 = config_2.set_query_f('entropy').set_encoder('mnist_2') experiment_3 = scenarios.Experiment(config_3, 'sbc', x, y, (x_test, y_test)) sbc = experiment_3.run() plots.plot_single(sbc, 'sbc')
import plots import matplotlib.pyplot as plt import encoders simple_learner = learners.EntropyLearner() encoder = encoders.get_mnist_encoder() sud_learner = learners.SudLearner(simple_learner, encoder) sbc_sud_learner = learners.SbcLearner(sud_learner, encoder) sbc_sud_learner.compile(init_size=2000, train_size=10000, queries_number=5, batch_size=1, random_state=0) import datasets as ds x_train_mnist, y_train_mnist, x_test_mnist, y_test_mnist = ds.get_mnist() from models import create_sequential_model model = create_sequential_model() sbc_sud_learner.learn(model, x_train_mnist, y_train_mnist, validation_data=(x_test_mnist, y_test_mnist)) plots.plot_single(sbc_sud_learner.get_stat(), 'test') plt.xlabel('labeled set size') plt.ylabel('accuracy') plt.legend(loc='lower right') plt.show()
def main(): global args, switched args = parser.parse_args() print(args) if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True if args.dataset == "mnist": (trainX, trainY), (testX, testY) = get_mnist() _trainY, _testY = binarize_mnist_class(trainY, testY) dataset_test = MNIST_Dataset_FixSample(1000, 60000, trainX, _trainY, testX, _testY, split='test', type="clean", seed=args.seed) elif args.dataset == 'cifar': data_transforms = { 'train': transforms.Compose([ transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]), 'val': transforms.Compose([ transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]) } (trainX, trainY), (testX, testY) = get_cifar() _trainY, _testY = binarize_cifar_class(trainY, testY) dataset_test = CIFAR_Dataset(1000, 50000, trainX, _trainY, testX, _testY, split='test', transform=data_transforms['val'], type="clean", seed=args.seed) dataloader_test = DataLoader(dataset_test, batch_size=1, num_workers=args.workers, shuffle=False, pin_memory=True) consistency_criterion = losses.softmax_mse_loss if args.dataset == 'mnist': model = create_model() elif args.dataset == 'cifar': model = create_cifar_model() if args.gpu is not None: model = model.cuda() else: model = model.cuda() print("Evaluation mode!") if args.model is None: raise RuntimeError("Please specify a model file.") else: state_dict = torch.load(args.model)['state_dict'] model.load_state_dict(state_dict) valPacc, valNacc, valPNacc = validate(dataloader_test, model)
LATENT_SHAPE = 2 LOG_DIR = 'tensorboard' CHECKPOINT_DIR = './checkpoints/' # Initialize callbacks tb_callback = tf.keras.callbacks.TensorBoard(LOG_DIR) model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint( filepath=CHECKPOINT_DIR, monitor='total_loss', mode='min', save_freq=5, save_best_only=True) # Get dataset train_dataset, test_dataset, shape = get_mnist() vae = VAE(shape, LATENT_SHAPE) tb_callback.set_model(vae) vae.load_weights(CHECKPOINT_DIR) vae.compile(optimizer="adam") vae.fit(train_dataset, epochs=20, callbacks=[tb_callback, model_checkpoint_callback]) # Validate vae.evaluate(test_dataset) # Save sampes in tensorboard predictions = vae.random_sample()
def get_dataset(dataset_name): if dataset_name.lower() == 'digits': return get_sklearn_digits() elif dataset_name.lower() == "mnist": return get_mnist(data_dir='data')
def main(): global args, switched, single_epoch_steps, step args = parser.parse_args() criterion = get_criterion() torch.cuda.set_device(int(args.gpu)) cudnn.benchmark = True if args.dataset == "mnist": (trainX, trainY), (testX, testY) = get_mnist() _trainY, _testY = binarize_mnist_class(trainY, testY) dataset_train_clean = MNIST_Dataset(1000, 60000, trainX, _trainY, testX, _testY, split='train', ids=[], increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, top = args.top, type="clean", seed = args.seed) # clean dataset初始化为空 dataset_train_noisy = MNIST_Dataset(1000, 60000, trainX, _trainY, testX, _testY, split='train', increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, top = args.top, type="noisy", seed = args.seed) dataset_train_noisy.copy(dataset_train_clean) # 和clean dataset使用相同的随机顺序 dataset_train_noisy.reset_ids() # 让初始化的noisy dataset使用全部数据 dataset_test = MNIST_Dataset(1000, 60000, trainX, _trainY, testX, _testY, split='test', increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, top = args.top, type="clean", seed = args.seed) elif args.dataset == 'cifar': data_transforms = { 'train': transforms.Compose([ transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]), 'val': transforms.Compose([ transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]) } (trainX, trainY), (testX, testY) = get_cifar() _trainY, _testY = binarize_cifar_class(trainY, testY) dataset_train_clean = CIFAR_Dataset(1000, 50000, trainX, _trainY, testX, _testY, split='train', ids=[], increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, top = args.top, transform = data_transforms['train'], type="clean", seed = args.seed) # clean dataset初始化为空 dataset_train_noisy = CIFAR_Dataset(1000, 50000, trainX, _trainY, testX, _testY, split='train', increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, top = args.top, transform = data_transforms['train'], type="noisy", seed = args.seed) dataset_train_noisy.copy(dataset_train_clean) # 和clean dataset使用相同的随机顺序 dataset_train_noisy.reset_ids() # 让初始化的noisy dataset使用全部数据 dataset_test = CIFAR_Dataset(1000, 50000, trainX, _trainY, testX, _testY, split='test', increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, top = args.top, transform = data_transforms['val'], type="clean", seed = args.seed) criterion.update_p(0.4) assert np.all(dataset_train_noisy.X == dataset_train_clean.X) assert np.all(dataset_train_noisy.Y == dataset_train_clean.Y) assert np.all(dataset_train_noisy.oids == dataset_train_clean.oids) assert np.all(dataset_train_noisy.T == dataset_train_clean.T) #step = args.ema_start * 2 + 1 if len(dataset_train_clean) > 0: dataloader_train_clean = DataLoader(dataset_train_clean, batch_size=args.batch_size, num_workers=args.workers, shuffle=True, pin_memory=True) else: dataloader_train_clean = None if len(dataset_train_noisy) > 0: dataloader_train_noisy = DataLoader(dataset_train_noisy, batch_size=args.batch_size, num_workers=args.workers, shuffle=False, pin_memory=True) else: dataloader_train_noisy = None if len(dataset_test): dataloader_test = DataLoader(dataset_test, batch_size=args.batch_size, num_workers=0, shuffle=False, pin_memory=True) else: dataloader_test = None single_epoch_steps = len(dataloader_train_noisy) + 1 print('Steps: {}'.format(single_epoch_steps)) consistency_criterion = losses.softmax_mse_loss if args.dataset == 'mnist': model = create_model() ema_model = create_model(ema = True) elif args.dataset == 'cifar': model = create_cifar_model() ema_model = create_cifar_model(ema = True) if args.gpu is not None: model = model.cuda() ema_model = ema_model.cuda() else: model = model.cuda() ema_model = ema_model.cuda() params_list = [{'params': model.parameters(), 'lr': args.lr},] #optimizer = torch.optim.Adam(params_list, lr=args.lr, # weight_decay=args.weight_decay #) optimizer = torch.optim.Adam(params_list, lr=args.lr, weight_decay=args.weight_decay ) stats_ = stats(args.modeldir, 0) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, args.epochs, eta_min = args.lr * 0.2) #scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[40, 80], gamma=0.6) if args.evaluation: print("Evaluation mode!") best_acc = 0 for epoch in range(args.warmup): print("Warming up {}/{}".format(epoch + 1, args.warmup)) trainPacc, trainNacc, trainPNacc = train(dataloader_train_clean, dataloader_train_noisy, model, ema_model, criterion, consistency_criterion, optimizer, scheduler, -1, warmup = True) valPacc, valNacc, valPNacc = validate(dataloader_test, model, ema_model, criterion, consistency_criterion, -1) dataset_train_noisy.shuffle() dataloader_train_noisy = DataLoader(dataset_train_noisy, batch_size=args.batch_size, num_workers=args.workers, shuffle=False, pin_memory=True) val = [] for epoch in range(args.epochs): print("Self paced status: {}".format(check_self_paced(epoch))) print("Mean teacher status: {}".format(check_mean_teacher(epoch))) print("Noisy status: {}".format(check_noisy(epoch))) if check_mean_teacher(epoch) and (not check_mean_teacher(epoch - 1)) and not switched: model.eval() ema_model.eval() ema_model.load_state_dict(model.state_dict()) switched = True print("SWITCHED!") validate(dataloader_test, model, ema_model, criterion, consistency_criterion, epoch) validate(dataloader_test, ema_model, model, criterion, consistency_criterion, epoch) model.train() ema_model.train() if epoch == 0: switched = False if (not check_mean_teacher(epoch)) and check_mean_teacher(epoch - 1) and not switched: model.eval() ema_model.eval() model.load_state_dict(ema_model.state_dict()) switched = True print("SWITCHED!") validate(dataloader_test, model, ema_model, criterion, consistency_criterion, epoch) validate(dataloader_test, ema_model, model, criterion, consistency_criterion, epoch) model.train() ema_model.train() trainPacc, trainNacc, trainPNacc = train(dataloader_train_clean, dataloader_train_noisy, model, ema_model, criterion, consistency_criterion, optimizer, scheduler, epoch, self_paced_pick = len(dataset_train_clean)) valPacc, valNacc, valPNacc = validate(dataloader_test, model, ema_model, criterion, consistency_criterion, epoch) val.append(valPNacc) #validate_2(dataloader_test, model, ema_model, criterion, consistency_criterion, epoch) stats_._update(trainPacc, trainNacc, trainPNacc, valPacc, valNacc, valPNacc) is_best = valPNacc > best_acc best_acc = max(valPNacc, best_acc) filename = [] filename.append(os.path.join(args.modeldir, 'checkpoint.pth.tar')) filename.append(os.path.join(args.modeldir, 'model_best.pth.tar')) if (check_self_paced(epoch)) and (epoch - args.self_paced_start) % args.self_paced_frequency == 0: dataloader_train_clean, dataloader_train_noisy = update_dataset(model, ema_model, dataset_train_clean, dataset_train_noisy, epoch) plot_curve(stats_, args.modeldir, 'model', True) save_checkpoint({ 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'best_prec1': best_acc, 'optimizer' : optimizer.state_dict(), }, is_best, filename) dataset_train_noisy.shuffle() #dataloader_train_clean = DataLoader(dataset_train_clean, batch_size=args.batch_size, num_workers=args.workers, shuffle=True, pin_memory=True) dataloader_train_noisy = DataLoader(dataset_train_noisy, batch_size=args.batch_size, num_workers=args.workers, shuffle=False, pin_memory=True) print(best_acc) print(val)
def main(): global args, switched args = parser.parse_args() print(args) criterion = get_criterion() if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True if args.dataset == "mnist": (trainX, trainY), (testX, testY) = get_mnist() _trainY, _testY = binarize_mnist_class(trainY, testY) dataset_train1_clean = MNIST_Dataset_FixSample(1000, 60000, trainX, _trainY, testX, _testY, split='train', ids=[], increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, top = args.top1, type="clean", seed = args.seed) # clean dataset初始化为空 dataset_train1_noisy = MNIST_Dataset_FixSample(1000, 60000, trainX, _trainY, testX, _testY, split='train', increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, top = args.top1, type="noisy", seed = args.seed) dataset_train1_noisy.copy(dataset_train1_clean) # 和clean dataset使用相同的随机顺序 dataset_train1_noisy.reset_ids() # 让初始化的noisy dataset使用全部数据 dataset_test = MNIST_Dataset_FixSample(1000, 60000, trainX, _trainY, testX, _testY, split='test', increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, type="clean") dataset_train2_noisy = MNIST_Dataset_FixSample(1000, 60000, trainX, _trainY, testX, _testY, split='train', increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, top = args.top2, type="noisy", seed = args.seed) dataset_train2_clean = MNIST_Dataset_FixSample(1000, 60000, trainX, _trainY, testX, _testY, split='train', ids=[], increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, top = args.top2, type="clean", seed = args.seed) dataset_train2_noisy.copy(dataset_train1_noisy) dataset_train2_noisy.reset_ids() dataset_train2_clean.copy(dataset_train1_clean) #dataset_train2_clean.set_ids([]) assert np.all(dataset_train1_clean.X == dataset_train1_noisy.X) assert np.all(dataset_train2_clean.X == dataset_train1_noisy.X) assert np.all(dataset_train2_noisy.X == dataset_train1_noisy.X) elif args.dataset == 'cifar': data_transforms = { 'train': transforms.Compose([ transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]), 'val': transforms.Compose([ transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]) } (trainX, trainY), (testX, testY) = get_cifar() _trainY, _testY = binarize_cifar_class(trainY, testY) dataset_train1_clean = CIFAR_Dataset(1000, 50000, trainX, _trainY, testX, _testY, split='train', ids=[], increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, top = args.top1, transform = data_transforms['train'], type="clean", seed = args.seed) # clean dataset初始化为空 dataset_train1_noisy = CIFAR_Dataset(1000, 50000, trainX, _trainY, testX, _testY, split='train', increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, top = args.top1, transform = data_transforms['train'], type="noisy", seed = args.seed) dataset_train1_noisy.copy(dataset_train1_clean) # 和clean dataset使用相同的随机顺序 dataset_train1_noisy.reset_ids() # 让初始化的noisy dataset使用全部数据 dataset_test = CIFAR_Dataset(1000, 50000, trainX, _trainY, testX, _testY, split='test', increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, transform = data_transforms['val'], type="clean", seed = args.seed) dataset_train2_noisy = CIFAR_Dataset(1000, 50000, trainX, _trainY, testX, _testY, split='train', increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, transform = data_transforms['train'], top = args.top2, type="noisy", seed = args.seed) dataset_train2_clean = CIFAR_Dataset(1000, 50000, trainX, _trainY, testX, _testY, split='train', ids=[], increasing=args.increasing, replacement=args.replacement, mode=args.self_paced_type, transform = data_transforms['train'], top = args.top2, type="clean",) dataset_train2_noisy.copy(dataset_train1_noisy) dataset_train2_noisy.reset_ids() dataset_train2_clean.copy(dataset_train1_clean) #dataset_train2_clean.set_ids([]) assert np.all(dataset_train1_clean.X == dataset_train1_noisy.X) assert np.all(dataset_train2_clean.X == dataset_train1_noisy.X) assert np.all(dataset_train2_noisy.X == dataset_train1_noisy.X) assert np.all(dataset_train1_clean.Y == dataset_train1_noisy.Y) assert np.all(dataset_train2_clean.Y == dataset_train1_noisy.Y) assert np.all(dataset_train2_noisy.Y == dataset_train1_noisy.Y) assert np.all(dataset_train1_clean.T == dataset_train1_noisy.T) assert np.all(dataset_train2_clean.T == dataset_train1_noisy.T) assert np.all(dataset_train2_noisy.T == dataset_train1_noisy.T) criterion.update_p(0.4) dataloader_train1_clean = None dataloader_train1_noisy = DataLoader(dataset_train1_noisy, batch_size=args.batch_size, num_workers=args.workers, shuffle=False, pin_memory=True) dataloader_train2_clean = None dataloader_train2_noisy = DataLoader(dataset_train2_noisy, batch_size=args.batch_size, num_workers=args.workers, shuffle=False, pin_memory=True) dataloader_test = DataLoader(dataset_test, batch_size=args.batch_size, num_workers=args.workers, shuffle=False, pin_memory=True) consistency_criterion = losses.softmax_mse_loss if args.dataset == 'mnist': model1 = create_model() model2 = create_model() ema_model1 = create_model(ema = True) ema_model2 = create_model(ema = True) elif args.dataset == 'cifar': model1 = create_cifar_model() model2 = create_cifar_model() ema_model1 = create_cifar_model(ema = True) ema_model2 = create_cifar_model(ema = True) if args.gpu is not None: model1 = model1.cuda(args.gpu) model2 = model2.cuda(args.gpu) ema_model1 = ema_model1.cuda(args.gpu) ema_model2 = ema_model2.cuda(args.gpu) else: model1 = model1.cuda(args.gpu) model2 = model2.cuda(args.gpu) ema_model1 = ema_model1.cuda(args.gpu) ema_model2 = ema_model2.cuda(args.gpu) optimizer1 = torch.optim.Adam(model1.parameters(), lr=args.lr, weight_decay=args.weight_decay ) optimizer2 = torch.optim.Adam(model2.parameters(), lr=args.lr, weight_decay=args.weight_decay ) stats_ = stats(args.modeldir, 0) scheduler1 = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer1, args.epochs) scheduler2 = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer2, args.epochs) if args.evaluation: print("Evaluation mode!") best_acc1 = 0 best_acc2 = 0 best_acc3 = 0 best_acc4 = 0 best_acc = 0 best_model1 = copy.deepcopy(model1) best_model2 = copy.deepcopy(model2) for epoch in range(args.epochs): print("Self paced status: {}".format(check_self_paced(epoch))) print("Mean Teacher status: {}".format(check_mean_teacher(epoch))) if check_mean_teacher(epoch) and not check_mean_teacher(epoch - 1) and not switched: ema_model1.load_state_dict(best_model1.state_dict()) ema_model2.load_state_dict(best_model2.state_dict()) switched = True print("SWITCHED!") trainPacc, trainNacc, trainPNacc = train(dataloader_train1_clean, dataloader_train1_noisy, dataloader_train2_clean, dataloader_train2_noisy, model1, model2, ema_model1, ema_model2, criterion, consistency_criterion, optimizer1, scheduler1, optimizer2, scheduler2, epoch) valPacc, valNacc, valPNacc1, valPNacc2, valPNacc3, valPNacc4 = validate(dataloader_test, model1, model2, ema_model1, ema_model2, epoch) #print(valPacc, valNacc, valPNacc1, valPNacc2, valPNacc3) stats_._update(trainPacc, trainNacc, trainPNacc, valPacc, valNacc, valPNacc1) if valPNacc1 > best_acc1 and not check_mean_teacher(epoch): best_model1 = copy.deepcopy(model1) if valPNacc3 > best_acc3 and not check_mean_teacher(epoch): best_model2 = copy.deepcopy(model2) best_acc1 = max(valPNacc1, best_acc1) best_acc2 = max(valPNacc2, best_acc2) best_acc3 = max(valPNacc3, best_acc3) best_acc4 = max(valPNacc4, best_acc4) all_accuracy = [valPNacc1, valPNacc2, valPNacc3, valPNacc4] models = [model1, model2, ema_model1, ema_model2] if (check_self_paced(epoch)) and (epoch - args.self_paced_start) % args.self_paced_frequency == 0: dataloader_train1_clean, dataloader_train1_noisy, dataloader_train2_clean, dataloader_train2_noisy = update_dataset(model1, model2, ema_model1, ema_model2, dataset_train1_clean, dataset_train1_noisy, dataset_train2_clean, dataset_train2_noisy, epoch) plot_curve(stats_, args.modeldir, 'model', True) if (max(all_accuracy) > best_acc): torch.save({ 'epoch': epoch + 1, 'state_dict': models[all_accuracy.index(max(all_accuracy))].state_dict(), 'best_prec1': best_acc1, }, 'model_best.pth.tar') best_acc = max(all_accuracy) dataset_train1_noisy.shuffle() dataset_train2_noisy.shuffle() dataloader_train1_noisy = DataLoader(dataset_train1_noisy, batch_size=args.batch_size, num_workers=args.workers, shuffle=False, pin_memory=True) dataloader_train2_noisy = DataLoader(dataset_train2_noisy, batch_size=args.batch_size, num_workers=args.workers, shuffle=False, pin_memory=True) print(best_acc1) print(best_acc2) print(best_acc3) print(best_acc4)
def get_data_loader(name, train=True, split='train'): """Get data loader by name.""" if name == "svhn": return get_svhn(split) elif name == "mnist": return get_mnist(train)