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)
