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,
