def cotrain(configs, data, iter_step=1, train_ratio=0.2): """ cotrain model: params: model_names: model configs data: dataset include train and untrain data save_paths: paths for storing models iter_step: maximum iteration steps train_ratio: labeled data ratio """ assert iter_step >= 1 train_data, untrain_data = dp.split_dataset(data.trainval, train_ratio, args.seed) data_dir = data.images_dir new_train_data = train_data for step in range(iter_step): pred_probs = [] add_ids = [] for view in range(2): configs[view].set_training(True) model = mu.train(new_train_data, data_dir, configs[view]) save_checkpoint( { 'state_dict': model.state_dict(), 'epoch': step + 1, 'train_data': new_train_data }, False, fpath=os.path.join(configs[view].logs_dir, configs[view].model_name, 'cotrain.epoch%d' % step)) if len(untrain_data) == 0: continue pred_probs.append( mu.predict_prob(model, untrain_data, data_dir, configs[view])) add_ids.append(dp.sel_idx(pred_probs[view], train_data)) # calculate predict probility on all data p_b = mu.predict_prob(model, data.trainval, data_dir, configs[view]) p_y = np.argmax(p_b, axis=1) t_y = [c for (_, c, _, _) in data.trainval] print(np.mean(t_y == p_y)) if len(untrain_data) == 0: break # update training data pred_y = np.argmax(sum(pred_probs), axis=1) add_id = sum(add_ids) new_train_data, untrain_data = dp.update_train_untrain( add_id, new_train_data, untrain_data, pred_y)
def cotrain(model_names, data, save_paths, iter_step=1, train_ratio=0.2): """ cotrain model: params: model_names: model names such as ['resnet50','densenet121'] data: dataset include train and untrain data save_paths: paths for storing models iter_step: maximum iteration steps train_ratio: labeled data ratio """ assert iter_step >= 1 assert len(model_names) == 2 and len(save_paths) == 2 train_data, untrain_data = dp.split_dataset(data.trainval, train_ratio) data_dir = data.images_dir for step in range(iter_step): pred_probs = [] add_ids = [] for view in range(2): model = mu.train(model_names[view], train_data, data_dir, data.num_trainval_ids, epochs=50) data_params = mu.get_params_by_name(model_names[view]) pred_probs.append( mu.predict_prob(model, untrain_data, data_dir, data_params)) add_ids.append(dp.sel_idx(pred_probs[view], data.train)) torch.save(model.state_dict(), save_paths[view] + '.cotrain.epoch%d' % (step + 1)) mu.evaluate(model, data, params=data_params) pred_y = np.argmax(sum(pred_probs), axis=1) add_id = sum(add_ids) train_data, untrain_data = dp.update_train_untrain( add_id, train_data, untrain_data, pred_y)
num_classes=config.num_classes) model = torch.nn.DataParallel(model).cuda() save_pth = os.path.join(config.logs_dir, config.model_name, '%s' % (args.checkpoint)) if os.path.exists(save_pth) is not True: raise ValueError('wrong model pth') checkpoint = load_checkpoint(save_pth) state_dict = { k: v for k, v in checkpoint['state_dict'].items() if k in model.state_dict().keys() } model.load_state_dict(state_dict) else: model = mu.train(data.trainval, data.images_dir, config) save_checkpoint( { 'state_dict': model.state_dict(), 'epoch': 0, 'train_data': data.trainval }, False, fpath=os.path.join(config.logs_dir, config.model_name, 'full_supervised')) mu.evaluate(model, data, config) if args.evaluate is True: train_data = checkpoint['train_data'] weight = [w for (_, _, _, w) in train_data]
def spaco(configs, data, iter_step=1, gamma=0.3, train_ratio=0.2): """ self-paced co-training model implementation based on Pytroch params: model_names: model names for spaco, such as ['resnet50','densenet121'] data: dataset for spaco model save_pathts: save paths for two models iter_step: iteration round for spaco gamma: spaco hyperparameter train_ratio: initiate training dataset ratio """ num_view = len(configs) train_data, untrain_data = dp.split_dataset(data.trainval, train_ratio, args.seed) data_dir = data.images_dir ########### # initiate classifier to get preidctions ########### add_ratio = 0.5 pred_probs = [] add_ids = [] start_step = 0 for view in range(num_view): if configs[view].checkpoint is None: model = mu.train(train_data, data_dir, configs[view]) save_checkpoint( { 'state_dict': model.state_dict(), 'epoch': 0, 'train_data': train_data }, False, fpath=os.path.join(configs[view].logs_dir, configs[view].model_name, 'spaco.epoch0')) else: model = models.create(configs[view].model_name, num_features=configs[view].num_features, dropout=configs[view].dropout, num_classes=configs[view].num_classes) model = torch.nn.DataParallel(model).cuda() checkpoint = load_checkpoint(configs[view].checkpoint) model.load_state_dict(checkpoint['state_dict']) start_step = checkpoint['epoch'] configs[view].set_training(False) add_ratio += start_step * 0.5 # mu.evaluate(model, data, configs[view]) pred_probs.append( mu.predict_prob(model, untrain_data, data_dir, configs[view])) add_ids.append(dp.sel_idx(pred_probs[view], train_data, add_ratio)) pred_y = np.argmax(sum(pred_probs), axis=1) for step in range(start_step, iter_step): for view in range(num_view): # update v_view ov = add_ids[1 - view] pred_probs[view][ov, pred_y[ov]] += gamma add_id = dp.sel_idx(pred_probs[view], train_data, add_ratio) # update w_view new_train_data, _ = dp.update_train_untrain( add_id, train_data, untrain_data, pred_y) configs[view].set_training(True) model = mu.train(new_train_data, data_dir, configs[view]) # update y pred_probs[view] = mu.predict_prob(model, untrain_data, data_dir, configs[view]) pred_y = np.argmax(sum(pred_probs), axis=1) # udpate v_view for next view add_ratio += 0.5 pred_probs[view][ov, pred_y[ov]] += gamma add_ids[view] = dp.sel_idx(pred_probs[view], train_data, add_ratio) # calculate predict probility on all data p_b = mu.predict_prob(model, data.trainval, data_dir, configs[view]) p_y = np.argmax(p_b, axis=1) t_y = [c for (_, c, _, _) in data.trainval] print(np.mean(t_y == p_y)) # evaluation current model and save it # mu.evaluate(model,data,configs[view]) save_checkpoint( { 'state_dict': model.state_dict(), 'epoch': step + 1, 'train_data': new_train_data }, False, fpath=os.path.join(configs[view].logs_dir, configs[view].model_name, 'spaco.epoch%d' % (step + 1)))
def spaco(configs, data, iter_steps=1, gamma=0, train_ratio=0.2, regularizer='hard', device='cuda:0'): """ self-paced co-training model implementation based on Pytroch params: model_names: model names for spaco, such as ['resnet50','densenet121'] data: dataset for spaco model save_pathts: save paths for two models iter_step: iteration round for spaco gamma: spaco hyperparameter train_ratio: initiate training dataset ratio """ num_view = len(configs) train_data, untrain_data = dp.split_dataset(data.trainval, train_ratio, args.seed) data_dir = data.images_dir query_gallery = list(set(data.query) | set(data.gallery)) save_dir = os.path.join('logs', 'parallel_spaco', regularizer, 'seed_%d' % args.seed) ########### # initiate classifier to get preidctions ########### add_ratio = 0.5 pred_probs = [] sel_ids = [] weights = [] features = [] start_step = 0 for view in range(num_view): net = models.create(configs[view].model_name, num_features=configs[view].num_features, dropout=configs[view].dropout, num_classes=configs[view].num_classes).to(device) mu.train(net, train_data, data_dir, configs[view], device) pred_probs.append(mu.predict_prob(net, untrain_data, data_dir, configs[view], device)) predictions = mu.predict_prob(net, data.trainval, data_dir, configs[view], device) mAP = mu.evaluate(net, data, configs[view], device) save_checkpoint( { 'state_dict': net.state_dict(), 'epoch': 0, 'train_data': train_data, 'trainval': data.trainval, 'predictions': predictions, 'performance': mAP }, False, fpath=os.path.join(save_dir, '%s.epoch0' % (configs[view].model_name))) pred_y = np.argmax(sum(pred_probs), axis=1) # initiate weights for unlabled examples for view in range(num_view): sel_id, weight = dp.get_ids_weights(pred_probs[view], pred_y, train_data, add_ratio, gamma, regularizer, num_view) sel_ids.append(sel_id) weights.append(weight) # start iterative training for step in range(start_step, iter_steps): for view in range(num_view): # update v_view sel_ids[view], weights[view] = update_ids_weights(view, pred_probs, sel_ids, weights, pred_y, train_data, add_ratio, gamma, regularizer) # update w_view new_train_data, _ = dp.update_train_untrain(sel_ids[view], train_data, untrain_data, pred_y, weights[view]) configs[view].set_training(True) net = models.create(configs[view].model_name, num_features=configs[view].num_features, dropout=configs[view].dropout, num_classes=configs[view].num_classes).to(device) mu.train(net, new_train_data, data_dir, configs[view], device) # update y pred_probs[view] = mu.predict_prob(net, untrain_data, data_dir, configs[view], device) # calculate predict probility on all data test_acc(net, data.trainval, data_dir, configs[view], device) # evaluation current model and save it mAP = mu.evaluate(net, data, configs[view], device) predictions = mu.predict_prob(net, data.trainval, data_dir, configs[view], device) save_checkpoint( { 'state_dict': net.state_dict(), 'epoch': step + 1, 'train_data': new_train_data, 'trainval': data.trainval, 'predictions': predictions, 'performance': mAP }, False, fpath=os.path.join( save_dir, '%s.epoch%d' % (configs[view].model_name, step + 1))) if step + 1 == iter_steps: features += [ mu.get_feature(net, query_gallery, data.images_dir, configs[view], device) ] add_ratio += 1.2 # pred_y = np.argmax(sum(pred_probs), axis=1) acc = mu.combine_evaluate(features, data) print(acc)
def spaco(model_names, data, save_paths, iter_step=1, gamma=0.3, train_ratio=0.2): """ self-paced co-training model implementation based on Pytroch params: model_names: model names for spaco, such as ['resnet50','densenet121'] data: dataset for spaco model save_pathts: save paths for two models iter_step: iteration round for spaco gamma: spaco hyperparameter train_ratio: initiate training dataset ratio """ assert iter_step >= 1 assert len(model_names) == 2 and len(save_paths) == 2 num_view = len(model_names) train_data, untrain_data = dp.split_dataset(data.trainval, train_ratio) data_dir = data.images_dir num_classes = data.num_trainval_ids ########### # initiate classifier to get preidctions ########### add_ratio = 0.5 pred_probs = [] add_ids = [] for view in range(num_view): pred_probs.append( mu.train_predict(model_names[view], train_data, untrain_data, num_classes, data_dir)) add_ids.append(dp.sel_idx(pred_probs[view], train_data, add_ratio)) pred_y = np.argmax(sum(pred_probs), axis=1) for step in range(iter_step): for view in range(num_view): # update v_view ov = add_ids[1 - view] pred_probs[view][ov, pred_y[ov]] += gamma add_id = dp.sel_idx(pred_probs[view], train_data, add_ratio) # update w_view new_train_data, _ = dp.update_train_untrain( add_id, train_data, untrain_data, pred_y) model = mu.train(model_names[view], new_train_data, data_dir, num_classes) # update y data_params = mu.get_params_by_name(model_names[view]) pred_probs[view] = mu.predict_prob(model, untrain_data, data_dir, data_params) pred_y = np.argmax(sum(pred_probs), axis=1) # udpate v_view for next view add_ratio += 0.5 add_ids[view] = dp.sel_idx(pred_probs[view], train_data, add_ratio) # evaluation current model and save it mu.evaluate(model, data, data_params) torch.save(model.state_dict(), save_paths[view] + '.spaco.epoch%d' % (step + 1))
def cotrain(configs, data, iter_steps=1, train_ratio=0.2, device='cuda:0'): """ cotrain model: params: model_names: model configs data: dataset include train and untrain data save_paths: paths for storing models iter_steps: maximum iteration steps train_ratio: labeled data ratio """ add_ratio = 0.5 assert iter_steps >= 1 train_data, untrain_data = dp.split_dataset(data.trainval, train_ratio, args.seed) query_gallery = list(set(data.query) | set(data.gallery)) data_dir = data.images_dir new_train_data = deepcopy(train_data) features = [] for step in range(iter_steps): pred_probs = [] add_ids = [] for view in range(2): config = configs[view] config.set_training(True) net = models.create(config.model_name, num_features=config.num_features, dropout=config.dropout, num_classes=config.num_classes).to(device) mu.train(net, new_train_data, data_dir, configs[view], device) save_checkpoint( { 'state_dict': net.state_dict(), 'epoch': step + 1, 'train_data': new_train_data }, False, fpath=os.path.join('logs/cotrain/seed_%d/%s.epoch%d' % (args.seed, config.model_name, step))) if len(untrain_data) == 0: continue pred_probs.append( mu.predict_prob(net, untrain_data, data_dir, configs[view], device)) add_ids.append(dp.sel_idx(pred_probs[view], train_data, add_ratio)) # calculate predict probility on all data p_b = mu.predict_prob(net, data.trainval, data_dir, configs[view], device) p_y = np.argmax(p_b, axis=1) t_y = [c for (_, c, _, _) in data.trainval] print(np.mean(t_y == p_y)) ### final evaluation if step + 1 == iter_steps: features += [ mu.get_feature(net, query_gallery, data.images_dir, configs[view], device) ] # update training data pred_y = np.argmax(sum(pred_probs), axis=1) add_id = sum(add_ids) if args.tricks: add_ratio += 1.2 new_train_data, _ = dp.update_train_untrain( add_id, train_data, untrain_data, pred_y) else: if len(untrain_data) == 0: break new_train_data, untrain_data = dp.update_train_untrain( add_id, new_train_data, untrain_data, pred_y) acc = mu.combine_evaluate(features, data) print(acc)
def wrap_train(args): return mu.train(*args)