def train_wavenet(): # Build model. wavenet = get_fullmodel() # Load dataset. signal_train, signal_val = load_dataset(FRAME_SIZE, FRAME_SHIFT) sr = 256 # Start training via 'frame_generator' online one-hot & quantizing function data_gen_train = frame_generator(signal_train, sr, FRAME_SIZE, FRAME_SHIFT) data_gen_val = frame_generator(signal_val, sr, FRAME_SIZE, FRAME_SHIFT) # Add relevant training helpers ('callbacks' in Keras parlance.) csv_cb = CSVLogger('./logs/trainlog.csv') modelsave_cb = ModelCheckpoint( './models/weights.{epoch:02d}-{val_loss:.2f}.hdf5', verbose=1) tensorboard_cb = TensorBoard(log_dir='./logs', histogram_freq=5) # Train statement # For now : no callbacks ; check nb_val_samples. wavenet.fit_generator(data_gen_train, samples_per_epoch=S_EPOCHS, nb_epoch=N_EPOCHS, validation_data=data_gen_val, nb_val_samples=FRAME_SIZE, verbose=1, callbacks=[modelsave_cb, csv_cb, tensorboard_cb]) str_timestamp = str(int(time.time())) wavenet.save('models/model_' + str_timestamp + '_' + str(N_EPOCHS) + '.hdf5') return
def initialize_vanillaSeq2Seq(dataset_name): logger.debug("Initializing Datasets...") (train_iterator, valid_iterator, test_iterator), SRC, TRG = load_dataset( dataset_name, source_vocab=VANILLA_SEQ2SEQ["INPUT_DIM"], target_vocab=VANILLA_SEQ2SEQ["OUTPUT_DIM"], batch_size=VANILLA_SEQ2SEQ["BATCHSIZE"], ) INPUT_DIM = len(SRC.vocab) OUTPUT_DIM = len(TRG.vocab) logger.debug("Initializing Models on {}".format(device)) enc = Encoder( INPUT_DIM, VANILLA_SEQ2SEQ["ENC_EMB_DIM"], VANILLA_SEQ2SEQ["HID_DIM"], VANILLA_SEQ2SEQ["DROPOUT"], ) attn = Attention(VANILLA_SEQ2SEQ["HID_DIM"]) dec = Decoder( OUTPUT_DIM, VANILLA_SEQ2SEQ["DEC_EMB_DIM"], VANILLA_SEQ2SEQ["HID_DIM"], VANILLA_SEQ2SEQ["DROPOUT"], attn, ) model = VanillaSeq2Seq(enc, dec, device).to(device) return model, SRC, TRG, train_iterator, valid_iterator, test_iterator
def build_model(self): self.x = load_dataset(data_path=self.data_path, batch_size=self.batch_size, scale_size=self.img_dim, split=self.split) img_chs = self.x.get_shape().as_list()[-1] x = self.x / 127.5 - 1. # Normalization print("Successfully loaded {} with size: {}".format( self.dataset, self.x.get_shape())) # initialize z within ball(1, z_dim, 2) self.z = tf.Variable(tf.random_normal([self.batch_size, self.z_dim], stddev=np.sqrt(1.0 / self.z_dim)), name='noise') fake_data, g_vars = generator(self.g_net, self.z, self.conv_hidden_num, self.img_dim, img_chs, self.normalize_g, reuse=False, n_hidden_layers=self.n_hidden_layers) self.fake_data = tf.clip_by_value((fake_data + 1) * 127.5, 0, 255) # Denormalization x_flat = tf.reshape(self.x, [self.batch_size, -1]) fake_data_flat = tf.reshape(self.fake_data, [self.batch_size, -1]) if self.loss_type == 'l2': self.loss = tf.norm(x_flat - fake_data_flat, axis=1) self.loss_mean = tf.reduce_mean(self.loss) if self.optimizer == 'adam': optim_op = tf.train.AdamOptimizer elif self.optimizer == 'rmsprop': optim_op = tf.train.RMSPropOptimizer else: raise Exception( "[!] Caution! Other optimizers do not apply right now!") self.z_optim = optim_op(self.z_lr, self.beta1, self.beta2).minimize(self.loss, var_list=self.z) self.g_optim = optim_op(self.g_lr, self.beta1, self.beta2).minimize( self.loss_mean, global_step=self.global_step, var_list=g_vars) # project z after each update to the representation space Z z_proj = tf.divide( self.z, tf.maximum(tf.norm(self.z, axis=1, keep_dims=True), 1)) self.proj_op = tf.assign(self.z, z_proj) self.summary_op = tf.summary.merge([ tf.summary.scalar("loss/d_loss", self.loss_mean), ])
def main(**args): if args['mode'] == 'train': torch.cuda.set_device(args['local_rank']) torch.distributed.init_process_group(backend='nccl', init_method='env://') train_iter, agent = load_dataset(args), load_model(args) sum_writer = SummaryWriter( log_dir=f'rest/{args["dataset"]}/{args["model"]}') for i in tqdm(range(args['epoch'])): train_loss = agent.train_model( train_iter, mode='train', recoder=sum_writer, idx_=i, ) if args['local_rank'] == 0: agent.save_model( f'ckpt/{args["dataset"]}/{args["model"]}/best.pt') sum_writer.close() elif args['mode'] == 'test': test_iter, agent = load_dataset(args), load_model(args) agent.load_model(f'ckpt/{args["dataset"]}/{args["model"]}/best.pt') agent.test_model(test_iter) elif args['mode'] == 'inference': torch.cuda.set_device(args['local_rank']) torch.distributed.init_process_group(backend='nccl', init_method='env://') iter_, agent = load_dataset(args), load_model(args) agent.load_model(f'ckpt/{args["dataset"]}/{args["model"]}/best.pt') path = f'rest/{args["dataset"]}/{args["model"]}/rest_{args["local_rank"]}.pt' agent.inference(iter_, path) else: raise Exception(f'[!] cannot find the mode: {args["mode"]}')
def main(args): dataset = dataloader.load_dataset(args.data_dir) model, all_data = dataset['model'][0], dataset['data'] K_opt, k_opt, extrinsics_opt = zhang_calibration(model, all_data) print(' Focal Length: [ {:.5f} {:.5f} ]'.format(K_opt[0, 0], K_opt[1, 1])) print('Principal Point: [ {:.5f} {:.5f} ]'.format(K_opt[0, 2], K_opt[1, 2])) print(' Skew: [ {:.7f} ]'.format(K_opt[0, 1])) print(' Distortion: [ {:.6f} {:.6f} ]'.format(k_opt[0], k_opt[1])) visualize.visualize_camera_frame(model, extrinsics_opt) visualize.visualize_world_frame(model, extrinsics_opt)
], n_classes=C.usable_bits).cuda() network.load_state_dict(torch.load("weights/2020-11-23.pth")) seen_classes = [ "aim", "icq", "facebook_chat-vpn", "facebook_audio-vpn", "hangouts_chat-vpn", "vimeo", "voipbuster" ] test_classes = { # "Seen": ["aim", "icq", "vimeo", "voipbuster"], # "Seen/Unseen": ["aim", "vimeo", "hangouts_audio", "twitter"], # "Generic": ["audio", "chat", "file", "email"], # "Application": ["facebook_audio-video", "spotify", "hangouts_audio", "skype-video", "google", "twitter"], "Connection": ["vpn", "tor"] } for name, classes in test_classes.items(): datasets = [D.load_dataset(c) for c in classes] print( "____________________________________________________________________") print("NAME: ", name) print("CLASSES: ", classes) print("SHOTS, ACCURACY:") with torch.no_grad(): for shot in [1, 5, 10, 20, 100]: acc = F.accuracy(*datasets, features_fn=network, n_support=shot, n_query=5000) print(shot, ", ", acc)
from dataloader import load_embeddings, load_dataset import sys sys.path.append("..") from Tools.EmbdTFRecordMaker import read_embd_tfrecords #param embed_tfrecord = sys.argv[1] tfrecordfile = sys.argv[2] vocal_size = 1551856 embd_size = 50 units = 50 #load data embd_table = read_embd_tfrecords(embed_tfrecord, [vocal_size, embd_size]) train_dataset = load_dataset(tfrecordfile) #train param num_epochs = 5 batch_size = 32 learning_rate = 0.001 is_mask = True input_len = 10 strategy = tf.distribute.MirroredStrategy() print('Number of devices: %d' % strategy.num_replicas_in_sync) #batch_size = batch_size * strategy.num_replicas_in_sync train_dataset = train_dataset.shuffle(buffer_size=1000) train_dataset = train_dataset.batch(batch_size)
# getting model if args.model == "inception": model = inception_model() else: model = vgg_model() # extracting features from model for all training images and saving it train_features = extract_features(model, 'Flickr_8k.trainImages.txt', args.model) pickle.dump(train_features, open('train_final_features.pkl', 'wb')) # getting captions for training images train_dataset = load_dataset("Flickr_8k.trainImages.txt") max_len, train_captions_dect = load_selected_captions(train_dataset, entire_dataset) # creating tokenizer and saving it for later use tokenizer = create_tokenizer(train_captions_dect) vocab_size = len(tokenizer.word_index) + 1 dump(tokenizer, open('flickr_tokenizer.pkl', 'wb')) # load trained captions train_features = pickle.load(open("train_final_features.pkl", 'rb')) # getting rnn_cnn_model
transforms.RandomCrop(32, padding=4), transforms.Resize(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) test_trans = transforms.Compose([ transforms.Resize(224), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261)) ]) train_loader, test_loader = dataloader.load_dataset(dataset='cifar10', datapath='cifar10/data', batch_size=128, \ threads=2, raw_data=False, data_split=1, split_idx=0, \ trainloader_path="", testloader_path="", eval_count=None, ts=[train_trans, test_trans]) net = models.mobilenet_v2(num_classes=10, width_mult=1.0) if use_cuda: net.cuda() optimizer = torch.optim.Adam(net.parameters(), lr=0.02) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, threshold=0.0001, threshold_mode='abs') criterion = nn.CrossEntropyLoss().cuda()
proj.nplist_to_tensor(d[1])) print('cosine similarity between x-axis and y-axis: %f' % similarity) #-------------------------------------------------------------------------- # Setup dataloader #-------------------------------------------------------------------------- # download CIFAR10 if it does not exit if rank == 0 and args.dataset == 'cifar10': torchvision.datasets.CIFAR10(root=args.dataset + '/data', train=True, download=True) mpi.barrier(comm) trainloader, testloader = dataloader.load_dataset( args.dataset, args.datapath, args.batch_size, args.threads, args.raw_data, args.data_split, args.split_idx, args.trainloader, args.testloader) #-------------------------------------------------------------------------- # Start the computation #-------------------------------------------------------------------------- crunch(surf_file, net, w, s, d, trainloader, 'train_loss', 'train_acc', comm, rank, args) # crunch(surf_file, net, w, s, d, testloader, 'test_loss', 'test_acc', comm, rank, args) #-------------------------------------------------------------------------- # Plot figures #-------------------------------------------------------------------------- if args.plot and rank == 0: if args.y and args.proj_file: plot_2D.plot_contour_trajectory(surf_file, dir_file,
from tensorflow.keras.callbacks import EarlyStopping, CSVLogger, ModelCheckpoint from tensorflow.keras.optimizers import * import os os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2" os.environ["CUDA_VISIBLE_DEVICES"] = "2" from dataloader import encode, decode, load_dataset, de_one_hot, preprocess import time from model import MyModel from tqdm import tqdm from matplotlib import pyplot as plt # model = MyModel() # model.load_weights("model/") # test img_paths, labels = load_dataset(TEST_DIR) db_test = tf.data.Dataset.from_tensor_slices((img_paths, labels)) db_test = db_test.map(preprocess).shuffle(1000).batch(32) # sample = next(iter(db_test)) x, y = sample[0], sample[1] index = 2 plt.imshow(x[index]) plt.axis('off') plt.show() true_label = de_one_hot(y[index]) print("True Label", true_label) # for x, y in db_test: # y(32, 4, 36) # logits = model(x) # (4, 32, 36) # out = tf.transpose(logits, perm=[1, 0, 2]) # (32, 4, 36) # size = x.shape[0]
import numpy as np from keras.models import Sequential from keras.layers import Activation, Dense, Dropout, Flatten from keras.layers.convolutional import Conv2D, MaxPooling2D from dataloader import load_dataset from keras import optimizers bike_folder = 'bike/' not_bike_folder = 'none/' train_x, train_y, test_x, test_y = load_dataset(bike_folder, not_bike_folder) class Net(): @staticmethod def build(): #image dimensions input_dim = (300, 300, 3) model = Sequential() # layer1 CONV -> POOL -> ACTIVATION model.add( Conv2D(20, kernel_size=5, padding='same', input_shape=input_dim)) model.add(MaxPooling2D(pool_size=(2, 2), strides=2)) model.add(Activation('relu')) #layer2 CONV -> POOL -> FLATTEN model.add(Conv2D(40, kernel_size=5, padding='same')) model.add(MaxPooling2D(pool_size=(2, 2), strides=2)) model.add(Flatten()) #FULLY CONNECTED LAYERS
energy = sum_energy(z_collection) count += 1 if (energy < THRESHOLD or count >= MAX_GEO_ITER): break return z_collection if (__name__ == '__main__'): # model definition BATCH_SIZE = 1 dataset = load_dataset() loader = cycle( DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True, drop_last=True)) encoder = Encoder() encoder.apply(weights_init) decoder = Decoder() decoder.apply(weights_init) encoder.load_state_dict( torch.load(os.path.join('checkpoints', ENCODER_SAVE))) decoder.load_state_dict(
layer=None, num_epochs=100, lr=1e-3, steps_epochs=[50, 80, 100], batch_size=128, num_workers=0, pin_memory=True) args = parser.parse_args() # check if GPU available device = get_device() # load data if args.detection: if args.mode == 'mtcnn': trainset, testset = load_dataset('cropped') print("Load cropped image dataset") else: trainset, testset = load_dataset('detection') print("Load object detection dataset") else: trainset, testset = load_dataset('single_person') print("Load single person dataset") # dataloader if args.mode == 'faster_rcnn': trainloader = data.DataLoader(trainset, args.batch_size, True, num_workers=args.num_workers, pin_memory=args.pin_memory,
type=float, default=0.0004, help= 'Initial learning rate, useful only when warm up epoch > 0 (default: 0.0002)' ) parser.add_argument('--decay_factor', type=float, default=0.95, help='Factor for lr exponential decay (default: 0.95)') args = parser.parse_args() device = torch.device( 'cuda:{}'.format(args.gpu_id) if torch.cuda.is_available() else 'cpu') print('Preparing data.') train_loader, val_img_loader, _, val_caption_loader, _, vocab_table = load_dataset( args) print('Constructing model.') model = Net(args, vocab_table.vocab) # if torch.cuda.device_count() > 1: # print('use {} GPUs for training...'.format(torch.cuda.device_count())) # model = torch.nn.DataParallel(model) model = model.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) #optimizer = NovoGrad(model.parameters(), lr=args.lr) print('===== TRAIN =====') data_loader = [train_loader, val_caption_loader] text_trainer = Trainer(data_loader, model, optimizer, args, mode='text') model = text_trainer.train() mix_trainer = Trainer(data_loader, model, optimizer, args, mode='mix')
perturbation['L1'] /= cnt perturbation['L2'] /= cnt perturbation['L_inf'] /= cnt return attack_success_rate, perturbation, query_cnt if __name__ == '__main__': from models import load_model from dataloader import load_dataset, load_dataloader from NSGA2 import run_NSGA2 model_names = ['vgg16'] dataset_names = ['cifar10', 'imagenet'] # skip mnist attack_methods = ['POBA', 'NSGA2'] for attack_method in attack_methods: for dataset_name in dataset_names: for model_name in model_names: model = load_model(model_name, dataset_name) dataset = load_dataset(dataset_name) dataloader = load_dataloader(dataset) result = evaluate(model=model, dataloader=dataloader, poba=(attack_method == 'POBA')) attack_success_rate, perturbation, query_cnt = result print("dataset: {} model_name: {} attack_method: {}".format( dataset_name, model_name, attack_method)) print(attack_success_rate) print(perturbation) print()
# calculate the consine similarity of the two directions if len(d) == 2 and rank == 0: similarity = proj.cal_angle(proj.nplist_to_tensor(d[0]), proj.nplist_to_tensor(d[1])) print('cosine similarity between x-axis and y-axis: %f' % similarity) #-------------------------------------------------------------------------- # Setup dataloader #-------------------------------------------------------------------------- # download CIFAR10 if it does not exit if rank == 0 and args.dataset == 'cifar10': torchvision.datasets.CIFAR10(root=args.dataset + '/data', train=True, download=True) mpi4pytorch.barrier(comm) trainloader, testloader = dataloader.load_dataset(args.dataset, args.datapath, args.batch_size, args.threads, args.raw_data, args.data_split, args.split_idx, args.trainloader, args.testloader) #-------------------------------------------------------------------------- # Start the computation #-------------------------------------------------------------------------- crunch(surf_file, net, w, s, d, trainloader, 'train_loss', 'train_acc', comm, rank, args) # crunch(surf_file, net, w, s, d, testloader, 'test_loss', 'test_acc', comm, rank, args) #-------------------------------------------------------------------------- # Plot figures #-------------------------------------------------------------------------- if args.plot and rank == 0: if args.y and args.proj_file: plot_2D.plot_contour_trajectory(surf_file, dir_file, args.proj_file, 'train_loss', args.show) elif args.y:
ckpt_name = sys.argv[2] #Dataset parameters num_workers = 8 batch_size = 16 n_classes = 20 img_size = 224 test_split = 'val' # Logging options rows, cols = 5, 2 #Show 10 images in the dataset along with target and predicted masks device = torch.device("cuda")# if torch.cuda.is_available() else "cpu") num_gpu = list(range(torch.cuda.device_count())) testloader, test_dst = load_dataset(batch_size, num_workers, split=test_split) # Creating an instance of the model #model = Segnet(n_classes) #Fully Convolutional Networks #model = U_Net(img_ch=3,output_ch=n_classes) #U Network #model = R2U_Net(img_ch=3,output_ch=n_classes,t=2) #Residual Recurrent U Network, R2Unet (t=2) #model = R2U_Net(img_ch=3,output_ch=n_classes,t=3) #Residual Recurrent U Network, R2Unet (t=3) #model = RecU_Net(img_ch=3,output_ch=n_classes,t=2) #Recurrent U Network, RecUnet (t=2) #model = ResU_Net(img_ch=3,output_ch=n_classes) #Residual U Network, ResUnet #model = DeepLabV3(n_classes, 'vgg') #DeepLabV3 VGG backbone model = DeepLabV3(n_classes, 'resnet') #DeepLabV3 Resnet backbone print('Evaluation logs for model: {}'.format(model.__class__.__name__)) model = nn.DataParallel(model, device_ids=num_gpu).to(device) model_params = torch.load(os.path.join(expt_logdir, "{}".format(ckpt_name)))
# 模型训练 if __name__ == '__main__': # 读入参数 yaml_file = './electra.base.yaml' with open(yaml_file, 'rt') as f: args = AttrDict(yaml.safe_load(f)) paddle.set_device(args.device) # 使用gpu,相应地,安装paddlepaddle-gpu train_data_loader, valid_data_loader = create_train_dataloader(args) # 加载dataset # Create dataset, tokenizer and dataloader. train_ds, test_ds = load_dataset('TEDTalk', splits=('train', 'test'), lazy=False) label_list = train_ds.label_list label_num = len(label_list) # 加载预训练模型 # Define the model netword and its loss model = ElectraForTokenClassification.from_pretrained( args.model_name_or_path, num_classes=label_num) # 设置AdamW优化器 num_training_steps = args.max_steps if args.max_steps > 0 else len( train_data_loader) * args.num_train_epochs lr_scheduler = LinearDecayWithWarmup(float(args.learning_rate), num_training_steps, args.warmup_steps)
best_model_file = os.path.join(load_folder, 'encoder.pt') log_file = os.path.join(load_folder, 'log_new.txt') log = open(log_file, 'w') pickle.dump({'args': args}, open(meta_file, "wb")) if args.restore: save_folder = load_folder else: load_folder = save_folder print("Load_folder: {}".format(load_folder)) # ======================= Load Data ========================== # train_loader, val_loader, test_loader = load_dataset( dataset=args.dataset, subsample=args.subsample, batch_size=args.batch_size, shuffle=args.shuffle, N_actors=args.N_actors, N_moving_actors=args.N_moving_actors) # ======================= Build Model ========================== # if args.encoder == 'base': model = CNNEncoder(prev_steps=args.prev_steps, pred_steps=args.pred_steps, n_hid=args.n_hid) elif args.encoder == 'alex': model = AlexEncoder(prev_steps=args.prev_steps, pred_steps=args.pred_steps, n_hid=args.n_hid) elif args.encoder == 'nmp': model = NMPEncoder(use_nmp=args.use_nmp,
from openrec import ModelTrainer from openrec.utils import Dataset from BPR import BPR from openrec.utils.evaluators import AUC from openrec.utils.samplers import RandomPairwiseSampler from openrec.utils.samplers import EvaluationSampler import dataloader #raw_data = dataloader.load_citeulike() raw_data = dataloader.load_dataset() dim_embed = CHANGE_DIM_HERE total_iter = raw_data["max_iteration"] batch_size = 1000 eval_iter = total_iter save_iter = eval_iter train_dataset = Dataset(raw_data['train_data'], raw_data['total_users'], raw_data['total_items'], name='Train') val_dataset = Dataset(raw_data['val_data'], raw_data['total_users'], raw_data['total_items'], name='Val', num_negatives=500) test_dataset = Dataset(raw_data['test_data'], raw_data['total_users'], raw_data['total_items'], name='Test', num_negatives=500)
def fine_tune_model(model, class_names=5): num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, class_names) model_ft = model.to("cpu") return model_ft if __name__ == "__main__": data_dir = "/content/gdrive/MyDrive/Intern DL/dataset" dataloaders, image_datasets, class_names = load_dataset(data_dir) train_loader, validation_loader, dataset_sizes = split_into_trainvals( dataloaders, image_datasets) model = models.resnet18(pretrained=True) model_ft = fine_tune_model(model) criterion = nn.CrossEntropyLoss() optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9) # Decay LR by a factor of 0.1 every 7 epochs exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1) model_trained = train_model(model_ft, criterion, optimizer_ft, exp_lr_scheduler, train_loader,