def predict(prediction_dir='./Test'): """The function is used to run predictions on the audio files in the directory `pred_directory`. Parameters ---------- net: The model that has been trained. prediction_dir: string, default ./Test The directory that contains the audio files on which predictions are to be made """ if not os.path.exists(prediction_dir): warnings.warn("The directory on which predictions are to be made is not found!") return if len(os.listdir(prediction_dir)) == 0: warnings.warn("The directory on which predictions are to be made is empty! Exiting...") return # Loading synsets if not os.path.exists('./synset.txt'): warnings.warn("The synset or labels for the dataset do not exist. Please run the training script first.") return with open("./synset.txt", "r") as f: synset = [l.rstrip() for l in f] net = get_net(len(synset)) print("Trying to load the model with the saved parameters...") if not os.path.exists("./net.params"): warnings.warn("The model does not have any saved parameters... Cannot proceed! Train the model first") return net.load_parameters("./net.params") file_names = os.listdir(prediction_dir) full_file_names = [os.path.join(prediction_dir, item) for item in file_names] from transforms import MFCC mfcc = MFCC() print("\nStarting predictions for audio files in ", prediction_dir, " ....\n") for filename in full_file_names: # Argument kaiser_fast to res_type is faster than 'kaiser_best'. To reduce the load time, passing kaiser_fast. X1, _ = librosa.load(filename, res_type='kaiser_fast') transformed_test_data = mfcc(mx.nd.array(X1)) output = net(transformed_test_data.reshape((1, -1))) prediction = nd.argmax(output, axis=1) print(filename, " -> ", synset[(int)(prediction.asscalar())])
interpolation=cv2.INTER_AREA) mask = np.expand_dims(mask, axis=-1) x_batch.append(image) y_batch.append(mask) yield np.array(x_batch), np.array(y_batch) if __name__ == '__main__': train_masks_csv = pd.read_csv('../input/train_masks.csv') image_list = list(train_masks_csv['img']) mask_list = list(train_masks_csv["rle_mask"]) ids_train, ids_valid = train_test_split(train_masks_csv) model = get_net(input_shape=(HEIGHT, WIDTH, 3)) callbacks = [ EarlyStopping(monitor='val_dice_coef', patience=10, verbose=1, min_delta=1e-4, mode='max'), ReduceLROnPlateau(monitor='val_dice_coef', factor=0.2, patience=5, verbose=1, epsilon=1e-4, mode='max'), ModelCheckpoint(monitor='val_dice_coef', filepath='logs/model_weights.hdf5',
import torch import torch.nn as nn from torch.autograd import Variable import model import utils import os if not os.path.exists('./model'): os.mkdir('model/') train_loader = utils.load_data_STL10() is_cuda = torch.cuda.is_available() cnn = model.get_net() criterion = nn.CrossEntropyLoss() if is_cuda: criterion = criterion.cuda() optimizer = torch.optim.Adam(cnn.parameters(), lr=0.0001) min_loss = 999 print("START TRAINIG!") for epoch in range(100): epoch_loss = 0 for i, (images, labels) in enumerate(train_loader): images = Variable(images) labels = Variable(labels)
def gen_soft_labels(c): c.setdefault(hebbian=False, distributed=False) net = get_net(c) opt = get_opt(c, net) net, opt, step = c.init_model(net, opt=opt, step='max', train=True) print('generating soft labels...') data_gen_tr = SequentialIteratorGenSoft(c, c.get('gen_soft_batch'), split='train') # data_gen_tr = iter(data_gen_tr) clear_gpu_memory() net.eval() with torch.no_grad(): i = 0 for batch in tqdm(data_gen_tr): x = to_torch(batch, c.device).t() # print(x.size()) # print(x[0:20]) inputs, labels = x[:-1], x[1:] probs, _ = net(inputs, labels) # loss_hard = -torch.log(probs.gather(1, labels).squeeze(1)).mean() values, indices = torch.topk(probs, c.get('topk'), dim=1) indices_ = indices.cpu().numpy() values_ = values.cpu().numpy() labels_ = labels.cpu().numpy() # print(indices_[0:5]) # print(labels_[0:5]) # exit(0) if probs.size(0) != inputs.size(0): indices_ = indices_[-inputs.size(0):, :] values_ = values_[-inputs.size(0):, :] # labels_ = labels_[-inputs.size(0):, :] if i == 0: all_soft_indices = indices_ all_soft_values = values_ else: all_soft_indices = np.concatenate((all_soft_indices, indices_), axis=0) all_soft_values = np.concatenate((all_soft_values, values_), axis=0) # print(all_soft_indices.shape) # print(all_soft_values.shape) i += 1 # if i > 100: # break all_soft_indices = np.concatenate( (all_soft_indices[0:1, :], all_soft_indices), axis=0) all_soft_values = np.concatenate( (all_soft_values[0:1, :], all_soft_values), axis=0) np.save( c.get('file_out_path') + 'all_soft_indices' + str(c.get('worker')) + '.npy', all_soft_indices) np.save( c.get('file_out_path') + 'all_soft_values' + str(c.get('worker')) + '.npy', all_soft_values) in_indices = np.load( c.get('file_out_path') + 'all_soft_indices' + str(c.get('worker')) + '.npy') cnt = 0. # print(in_indices.shape) # print(len(data.tokens)) for k in range(len(data_gen_tr.tokens)): # print(data.tokens[k]) # print(in_indices[k]) if data_gen_tr.tokens[k] in in_indices[k]: cnt += 1 print(cnt / len(data_gen_tr.tokens))
feas1 = feas1.as_in_context(ctx) feas2 = feas2.as_in_context(ctx) output = net(feas1, feas2) cross_entropy = softmax_cross_entropy(output, label) loss += nd.mean(cross_entropy).asscalar() return loss / len(data) def SaveTest(test_data, net, ctx, name, ids, synsets): outputs = [] for data1, data2, label in tqdm(test_data): data1 = data1.as_in_context(ctx) data2 = data2.as_in_context(ctx) output = nd.softmax(net(data1, data2)) outputs.extend(output.asnumpy()) with open(name, 'w') as f: f.write('id,' + ','.join(synsets) + '\n') for i, output in zip(ids, outputs): f.write( i.split('.')[0] + ',' + ','.join([str(num) for num in output]) + '\n') net = get_net(netparams, mx.gpu()) net.hybridize() softmax_cross_entropy = gluon.loss.SoftmaxCrossEntropyLoss() print(get_loss(valid_data, net, mx.gpu())) SaveTest(test_data, net, mx.gpu(), csvname, ids_synsets[0], ids_synsets[1])
def main(): # parameters SEED = 1 NUM_INIT_LB = 10000 NUM_QUERY = 1000 NUM_ROUND = 10 DATA_NAME = 'MNIST' # DATA_NAME = 'FashionMNIST' # DATA_NAME = 'SVHN' # DATA_NAME = 'CIFAR10' args_pool = { 'MNIST': { 'n_epoch': 10, 'transform': transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ]), 'loader_tr_args': { 'batch_size': 64, 'num_workers': 1 }, 'loader_te_args': { 'batch_size': 1000, 'num_workers': 1 }, 'optimizer_args': { 'lr': 0.01, 'momentum': 0.5 } }, 'FashionMNIST': { 'n_epoch': 10, 'transform': transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ]), 'loader_tr_args': { 'batch_size': 64, 'num_workers': 1 }, 'loader_te_args': { 'batch_size': 1000, 'num_workers': 1 }, 'optimizer_args': { 'lr': 0.01, 'momentum': 0.5 } }, 'SVHN': { 'n_epoch': 20, 'transform': transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4377, 0.4438, 0.4728), (0.1980, 0.2010, 0.1970)) ]), 'loader_tr_args': { 'batch_size': 64, 'num_workers': 1 }, 'loader_te_args': { 'batch_size': 1000, 'num_workers': 1 }, 'optimizer_args': { 'lr': 0.01, 'momentum': 0.5 } }, 'CIFAR10': { 'n_epoch': 20, 'transform': transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616)) ]), 'loader_tr_args': { 'batch_size': 64, 'num_workers': 1 }, 'loader_te_args': { 'batch_size': 1000, 'num_workers': 1 }, 'optimizer_args': { 'lr': 0.05, 'momentum': 0.3 } } } args = args_pool[DATA_NAME] # set seed np.random.seed(SEED) torch.manual_seed(SEED) torch.backends.cudnn.enabled = False # load dataset X_tr, Y_tr, X_te, Y_te = get_dataset(DATA_NAME) X_tr = X_tr[:40000] Y_tr = Y_tr[:40000] # start experiment n_pool = len(Y_tr) n_test = len(Y_te) print('number of labeled pool: {}'.format(NUM_INIT_LB)) print('number of unlabeled pool: {}'.format(n_pool - NUM_INIT_LB)) print('number of testing pool: {}'.format(n_test)) # generate initial labeled pool idxs_lb = np.zeros(n_pool, dtype=bool) idxs_tmp = np.arange(n_pool) np.random.shuffle(idxs_tmp) idxs_lb[idxs_tmp[:NUM_INIT_LB]] = True # load network net = get_net(DATA_NAME) handler = get_handler(DATA_NAME) strategy = RandomSampling(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = LeastConfidence(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = MarginSampling(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = EntropySampling(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = LeastConfidenceDropout(X_tr, Y_tr, idxs_lb, net, handler, args, n_drop=10) # strategy = MarginSamplingDropout(X_tr, Y_tr, idxs_lb, net, handler, args, n_drop=10) # strategy = EntropySamplingDropout(X_tr, Y_tr, idxs_lb, net, handler, args, n_drop=10) # strategy = KMeansSampling(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = KCenterGreedy(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = BALDDropout(X_tr, Y_tr, idxs_lb, net, handler, args, n_drop=10) # strategy = CoreSet(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = AdversarialBIM(X_tr, Y_tr, idxs_lb, net, handler, args, eps=0.05) # strategy = AdversarialDeepFool(X_tr, Y_tr, idxs_lb, net, handler, args, max_iter=50) # albl_list = [MarginSampling(X_tr, Y_tr, idxs_lb, net, handler, args), # KMeansSampling(X_tr, Y_tr, idxs_lb, net, handler, args)] # strategy = ActiveLearningByLearning(X_tr, Y_tr, idxs_lb, net, handler, args, strategy_list=albl_list, delta=0.1) # print info print(DATA_NAME) print('SEED {}'.format(SEED)) print(type(strategy).__name__) # round 0 accuracy strategy.train() P = strategy.predict(X_te, Y_te) acc = np.zeros(NUM_ROUND + 1) acc[0] = 1.0 * (Y_te == P).sum().item() / len(Y_te) print('Round 0\ntesting accuracy {}'.format(acc[0])) for rd in range(1, NUM_ROUND + 1): print('Round {}'.format(rd)) # query q_idxs = strategy.query(NUM_QUERY) idxs_lb[q_idxs] = True # update strategy.update(idxs_lb) strategy.train() # round accuracy P = strategy.predict(X_te, Y_te) acc[rd] = 1.0 * (Y_te == P).sum().item() / len(Y_te) print('testing accuracy {}'.format(acc[rd])) # print results print('SEED {}'.format(SEED)) print(type(strategy).__name__) print(acc)
# evaluate on test data_test = SequentialIterator(config, config.eval_batch, split="test") print("Final Evaluation") distiller.model_summary(net, "sparsity", 'wikitext-103') eval_output = evaluate(config.var(use_cache=True, n_cache=2000, cache_thetaa=best_theta, cache_lambda=best_lambda), data_test, net) config.log("VAL RESULT: ppl(%.3lf) theta(%.3lf) lambda(%.3lf)" % (best_ppl, best_theta, best_lambda)) config.log("TEST RESULT: %s" % eval_output) return eval_output if __name__ == '__main__': config = Config.from_args() print("config=", config) net = get_net(config) if config.get("summary"): opt = get_opt(config, net) net, opt, step = config.init_model(net, opt=opt, step='max', train=True) config.log("===> summary of model @ step %d" % step) distiller.model_summary(net, config.summary, 'wikitext-103') exit(0) if config.get("compress"): config.log("===> compress from: %s" % config.compress) compression_scheduler = distiller.config.file_config(net, None, config.compress) if config.get('eval_cache_search'): evaluate_cache_search(config, net)
# start experiment n_pool = len(Y_tr) n_test = len(Y_te) print('number of labeled pool: {}'.format(NUM_INIT_LB)) print('number of unlabeled pool: {}'.format(n_pool - NUM_INIT_LB)) print('number of testing pool: {}'.format(n_test)) # generate initial labeled pool idxs_lb = np.zeros(n_pool, dtype=bool) idxs_tmp = np.arange(n_pool) np.random.shuffle(idxs_tmp) idxs_lb[idxs_tmp[:NUM_INIT_LB]] = True # load network net = get_net(DATA_NAME) handler = get_handler(DATA_NAME) strategy = RandomSampling(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = LeastConfidence(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = MarginSampling(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = EntropySampling(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = LeastConfidenceDropout(X_tr, Y_tr, idxs_lb, net, handler, args, n_drop=10) # strategy = MarginSamplingDropout(X_tr, Y_tr, idxs_lb, net, handler, args, n_drop=10) # strategy = EntropySamplingDropout(X_tr, Y_tr, idxs_lb, net, handler, args, n_drop=10) # strategy = KMeansSampling(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = KCenterGreedy(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = BALDDropout(X_tr, Y_tr, idxs_lb, net, handler, args, n_drop=10) # strategy = CoreSet(X_tr, Y_tr, idxs_lb, net, handler, args) # strategy = AdversarialBIM(X_tr, Y_tr, idxs_lb, net, handler, args, eps=0.05) # strategy = AdversarialDeepFool(X_tr, Y_tr, idxs_lb, net, handler, args, max_iter=50)
import megengine as mge import cv2 import torch import megengine.functional as F import numpy as np import torchvision from model import get_net model = get_net() model.load_state_dict(mge.load('models/save.ae.40.mge')) model.eval() # dataset from megengine.data import RandomSampler, SequentialSampler, DataLoader from megengine.data.dataset import MNIST from megengine.data.transform import RandomResizedCrop, Normalize, ToMode, Pad, Compose root_dir = '/data/.cache/dataset/MNIST' mnist_train_dataset = MNIST(root=root_dir, train=True, download=False) mnist_test_dataset = MNIST(root=root_dir, train=False, download=False) random_sampler = RandomSampler(dataset=mnist_train_dataset, batch_size=256) sequential_sampler = SequentialSampler(dataset=mnist_test_dataset, batch_size=256) mnist_train_dataloader = DataLoader( dataset=mnist_train_dataset, sampler=random_sampler, transform=Compose([ RandomResizedCrop(output_size=28), # mean 和 std 分别是 MNIST 数据的均值和标准差,图片数值范围是 0~255
def train(train_dir=None, train_csv=None, epochs=30, batch_size=32): """Function responsible for running the training the model.""" if not train_dir or not os.path.exists(train_dir) or not train_csv: warnings.warn("No train directory could be found ") return # Make a dataset from the local folder containing Audio data print("\nMaking an Audio Dataset...\n") tick = time.time() aud_dataset = AudioFolderDataset(train_dir, train_csv=train_csv, file_format='.wav', skip_header=True) tock = time.time() print("Loading the dataset took ", (tock - tick), " seconds.") print("\n=======================================\n") print("Number of output classes = ", len(aud_dataset.synsets)) print("\nThe labels are : \n") print(aud_dataset.synsets) # Get the model to train net = model.get_net(len(aud_dataset.synsets)) print("\nNeural Network = \n") print(net) print("\nModel - Neural Network Generated!\n") print("=======================================\n") #Define the loss - Softmax CE Loss softmax_loss = gluon.loss.SoftmaxCELoss(from_logits=False, sparse_label=True) print("Loss function initialized!\n") print("=======================================\n") #Define the trainer with the optimizer trainer = gluon.Trainer(net.collect_params(), 'adadelta') print("Optimizer - Trainer function initialized!\n") print("=======================================\n") print("Loading the dataset to the Gluon's OOTB Dataloader...") #Getting the data loader out of the AudioDataset and passing the transform from transforms import MFCC aud_transform = MFCC() tick = time.time() audio_train_loader = gluon.data.DataLoader( aud_dataset.transform_first(aud_transform), batch_size=32, shuffle=True) tock = time.time() print("Time taken to load data and apply transform here is ", (tock - tick), " seconds.") print("=======================================\n") print("Starting the training....\n") # Training loop tick = time.time() batch_size = batch_size num_examples = len(aud_dataset) for epoch in range(epochs): cumulative_loss = 0 for data, label in audio_train_loader: with autograd.record(): output = net(data) loss = softmax_loss(output, label) loss.backward() trainer.step(batch_size) cumulative_loss += mx.nd.sum(loss).asscalar() if epoch % 5 == 0: train_accuracy = evaluate_accuracy(audio_train_loader, net) print("Epoch {}. Loss: {} Train accuracy : {} ".format( epoch, cumulative_loss / num_examples, train_accuracy)) print("\n------------------------------\n") train_accuracy = evaluate_accuracy(audio_train_loader, net) tock = time.time() print("\nFinal training accuracy: ", train_accuracy) print("Training the sound classification for ", epochs, " epochs, MLP model took ", (tock - tick), " seconds") print("====================== END ======================\n") print("Trying to save the model parameters here...") net.save_parameters("./net.params") print("Saved the model parameters in current directory.")
import os """ Set general arguements """ dataset_name = 'MNIST' data_transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, ))]) handler = get_handler(dataset_name) n_classes = 10 n_epoch = 10 """ Define model architecture """ net = get_net(dataset_name) """ Get dataset, set data handlers Use 10k training dataset from MNIST as the entire dataset Further split into Test/Train, then split train into labeled and unlabeled X (Training): 1000 datapoints X_NOLB (unlabeled datapool): 7000 X_TE (Testing): 2000 datapoints X_TOLB: Datapoints that require human labeling """ # FIX, do this in data object? _, _, X_INIT, Y_INIT = get_dataset(dataset_name) X_TR, X_TE, Y_TR, Y_TE = train_test_split(X_INIT, Y_INIT, test_size=0.2,
def train(c): c.setdefault(hebbian=False) net = get_net(c) emb_params = count_params(net.embed) + count_params(net.loss.projections) + count_params(net.loss.clusters) opt = get_opt(c, net) net, opt, step = c.init_model(net, opt=opt, step='max', train=True) if c.get('distillation_teacher') == 'file': data_tr_distill = DistillationSampleIterator(c, c.train_batch, split='train') iter_tr_distill = iter(data_tr_distill) step_lr = scheduler(c, opt, step) data_tr = SampleIterator(c, c.train_batch, split='valid' if c.debug else 'train') iter_tr = iter(data_tr) data_val = SequentialIterator(c, c.eval_batch, split='valid') s = Namespace(net=net, opt=opt, step=step) c.on_train_start(s) c.log('Embedding has %s parameters' % emb_params) if c.hebbian: counters = [torch.ones(end - start, dtype=torch.long, device=c.device) for start, end in zip([0] + c.cutoffs, c.cutoffs + [c.n_vocab])] temp_counters = [torch.zeros_like(x) for x in counters] best_val_loss = np.inf if s.results is not None and 'val_loss' in s.results.columns: best_val_loss = s.results['val_loss'].dropna().max() try: while step < s.step_max: step_lr(step) if c.get('distillation_teacher') == 'file': x_hard_labels, x_soft_labels, x_soft_probs = next(iter_tr_distill) x_hard_labels = to_torch(x_hard_labels, c.device).t() x_soft_labels = to_torch(x_soft_labels, c.device) x_soft_labels = x_soft_labels.permute(1, 0, 2) x_soft_probs = to_torch(x_soft_probs, c.device) x_soft_probs = x_soft_probs.permute(1, 0, 2) inputs, hard_labels = x_hard_labels[:-1], x_hard_labels[1:] soft_labels = x_soft_labels[1:] soft_probs = x_soft_probs[1:] t_s = time() preds = net(inputs=inputs, labels=hard_labels, soft_labels=soft_labels, soft_probs=soft_probs, is_distilling=True, current_step=step) loss = preds['loss'] total_loss = loss extras = {} else: x = to_torch(next(iter_tr), c.device).t() t_s = time() inputs, labels = x[:-1], x[1:] preds = net(inputs, labels) loss = preds['loss'] if c.model_class == 'UniversalTransformer': act_loss = preds['act_loss'] total_loss = act_loss + loss extras = dict(act_loss=from_torch(act_loss), n_updates=from_torch(preds['n_updates'].mean())) else: total_loss = loss extras = {} opt.zero_grad() if torch.isnan(total_loss): raise RuntimeError('Encountered nan loss during training') with amp.scale_loss(total_loss, opt) as scaled_loss: scaled_loss.backward() torch.nn.utils.clip_grad_norm_(net.parameters(), c.get('clip_grad', 0.5)) opt.step() if c.hebbian: hebbian_weight_update(c, net, preds['hiddens'], counters, temp_counters) time_model = np.round(time() - t_s, 5) loss = from_torch(loss) perplexity = np.nan if loss > 5 else np.e ** loss step_result = pd.Series(Dict( loss=loss, perplexity=perplexity, time=time_model, **extras )).add_prefix('train_') step_result['lr'] = next(iter(opt.param_groups))['lr'] step_result['theta'] = from_torch(preds['theta']) step_result['lambda'] = from_torch(preds['lambda']) s.step = step = step + 1 if step % c.step_eval == 0: step_result = step_result.append( pd.Series(evaluate(c, data_val, net)).add_prefix('val_') ) s.record_step = step_result['val_loss'] < best_val_loss clear_gpu_memory() s.step_result = step_result c.on_step_end(s) except Exception as e: import traceback err = traceback.format_exc() if c.main: c.log(err) else: print(err) finally: c.on_train_end(s)
import torch import os from query_strategies import RandomSampling, LeastConfidence, MarginSampling, EntropySampling, \ LeastConfidenceDropout, MarginSamplingDropout, EntropySamplingDropout, \ KMeansSampling, KCenterGreedy, BALDDropout, CoreSet, \ AdversarialBIM, AdversarialDeepFool, ActiveLearningByLearning # parameters SEED = 1 NUM_INIT_LB = 10000 NUM_QUERY = 1000 NUM_ROUND = 10 configuration = config.load_config() net = get_net(configuration.net)() if configuration.load_model: try: net.load_state_dict(torch.load(configuration.model_file)) except: print("No model file found at", configuration.model_file) # set seed np.random.seed(SEED) torch.manual_seed(SEED) # torch.backends.cudnn.enabled = False # load dataset dataset = datasets.ImageFolder( root=configuration.labeled_training_dir, transform=transforms.Compose([
batch_size=opt.batch_size, shuffle=True, num_workers=opt.nThreads, drop_last=True) validset = MyImageLoader(opt.root_dir, 'valid', opt.classes, opt.input_size) validloader = torch.utils.data.DataLoader(validset, batch_size=opt.batch_size, shuffle=False, num_workers=opt.nThreads, drop_last=True) if opt.checkpoint_path is not None: net = model.load_net(opt.classes, opt.checkpoint_path).cuda() else: net = model.get_net(opt.model_name, opt.classes, opt.pretrained).cuda() if len(GPU_ID) > 1: net = torch.nn.DataParallel(net, device_ids=GPU_ID) else: os.environ["CUDA_VISIBLE_DEVICES"] = str(GPU_ID[0]) # set loss function if opt.use_posweight: print('Input pos_weight into loss function...') pos_weight = calculate_pos_weight(opt.classes, trainset.image_classes) pos_weight = torch.from_numpy(pos_weight.astype(np.float32)).cuda() else: pos_weight = None if opt.focalloss_gamma > 0:
def train(train_dir=None, train_csv=None, epochs=30, batch_size=32): """Function responsible for running the training the model.""" if not train_dir or not os.path.exists(train_dir) or not train_csv: warnings.warn("No train directory could be found ") return # Make a dataset from the local folder containing Audio data print("\nMaking an Audio Dataset...\n") tick = time.time() aud_dataset = AudioFolderDataset(train_dir, train_csv=train_csv, file_format='.wav', skip_header=True) tock = time.time() print("Loading the dataset took ", (tock-tick), " seconds.") print("\n=======================================\n") print("Number of output classes = ", len(aud_dataset.synsets)) print("\nThe labels are : \n") print(aud_dataset.synsets) # Get the model to train net = model.get_net(len(aud_dataset.synsets)) print("\nNeural Network = \n") print(net) print("\nModel - Neural Network Generated!\n") print("=======================================\n") #Define the loss - Softmax CE Loss softmax_loss = gluon.loss.SoftmaxCELoss(from_logits=False, sparse_label=True) print("Loss function initialized!\n") print("=======================================\n") #Define the trainer with the optimizer trainer = gluon.Trainer(net.collect_params(), 'adadelta') print("Optimizer - Trainer function initialized!\n") print("=======================================\n") print("Loading the dataset to the Gluon's OOTB Dataloader...") #Getting the data loader out of the AudioDataset and passing the transform from transforms import MFCC aud_transform = MFCC() tick = time.time() audio_train_loader = gluon.data.DataLoader(aud_dataset.transform_first(aud_transform), batch_size=32, shuffle=True) tock = time.time() print("Time taken to load data and apply transform here is ", (tock-tick), " seconds.") print("=======================================\n") print("Starting the training....\n") # Training loop tick = time.time() batch_size = batch_size num_examples = len(aud_dataset) for epoch in range(epochs): cumulative_loss = 0 for data, label in audio_train_loader: with autograd.record(): output = net(data) loss = softmax_loss(output, label) loss.backward() trainer.step(batch_size) cumulative_loss += mx.nd.sum(loss).asscalar() if epoch%5 == 0: train_accuracy = evaluate_accuracy(audio_train_loader, net) print("Epoch {}. Loss: {} Train accuracy : {} ".format(epoch, cumulative_loss/num_examples, train_accuracy)) print("\n------------------------------\n") train_accuracy = evaluate_accuracy(audio_train_loader, net) tock = time.time() print("\nFinal training accuracy: ", train_accuracy) print("Training the sound classification for ", epochs, " epochs, MLP model took ", (tock-tick), " seconds") print("====================== END ======================\n") print("Trying to save the model parameters here...") net.save_parameters("./net.params") print("Saved the model parameters in current directory.")
# plot if valid_data is not None: plt.plot(plt_train_acc) plt.plot(plt_valid_acc) plt.legend(['train_acc', 'test_acc']) plt.savefig("Loss.png") ctx = utils.try_gpu() num_epochs = 200 learning_rate = 0.1 weight_decay = 5e-4 lr_period = 80 lr_decay = 0.1 net = model.get_net(ctx) net.hybridize() train(net, train_data, valid_data, num_epochs, learning_rate, weight_decay, ctx, lr_period, lr_decay) import numpy as np import pandas as pd net = model.get_net(ctx) net.hybridize() train(net, train_valid_data, None, num_epochs, learning_rate, weight_decay, ctx, lr_period, lr_decay) preds = [] for data, label in test_data: output = net(data.as_in_context(ctx))
RandomResizedCrop(output_size=28), # mean 和 std 分别是 MNIST 数据的均值和标准差,图片数值范围是 0~255 #Normalize(mean=0.1307*255, std=0.3081*255), #Pad(2), # 'CHW'表示把图片由 (height, width, channel) 格式转换成 (channel, height, width) 格式 #ToMode('CHW'), ])) mnist_test_dataloader = DataLoader( dataset=mnist_test_dataset, sampler=sequential_sampler, ) # model from model import get_net net = get_net() optimizer = optim.Adam( net.parameters(), lr=0.01, ) def get_kl_divergence(mean, var): return 1 / 2 * (mean**2 + var - F.log(var) - 1).sum(axis=1).mean() data = mge.tensor() label = mge.tensor(dtype="float32") code = mge.tensor(dtype="float32")
import os import torch import torch.nn as nn from torch.autograd import Variable import model import utils if not os.path.exists('./model'): os.mkdir('model/') train_loader = utils.load_data_stl10() is_cuda = torch.cuda.is_available() device = torch.device("cuda" if is_cuda else "cpu") cnn = model.get_net().to(device) criterion = nn.CrossEntropyLoss().to(device) optimizer = torch.optim.Adam(cnn.parameters(), lr=0.0001) min_loss = 999 print("START TRAINING") for epoch in range(100): epoch_loss = 0 for i, (images, labels) in enumerate(train_loader): images, labels = images.to(device), labels.to(device) optimizer.zero_grad() outputs, _ = cnn(images)
print('number of labeled pool: {}'.format(NUM_INIT_LB)) print('number of unlabeled pool: {}'.format(n_pool - NUM_INIT_LB)) print('number of testing pool: {}'.format(n_test)) # setting training parameters alpha = 2e-3 epoch = 80 # Generate the initial labeled pool idxs_lb = np.zeros(n_pool, dtype=bool) idxs_tmp = np.arange(n_pool) np.random.shuffle(idxs_tmp) idxs_lb[idxs_tmp[:NUM_INIT_LB]] = True # loading neural network net_fea, net_clf, net_dis = get_net(DATA_NAME) # here the training handlers and testing handlers are different train_handler = get_handler(DATA_NAME) test_handler = dataset.get_handler(DATA_NAME) strategy = WAAL(X_tr, Y_tr, idxs_lb, net_fea, net_clf, net_dis, train_handler, test_handler, args) # print information print(DATA_NAME) #print('SEED {}'.format(SEED)) print(type(strategy).__name__) # round 0 accuracy strategy.train(alpha=alpha, total_epoch=epoch)
torch.backends.cudnn.benchmark = False # load dataset X_tr, Y_tr, X_te, Y_te = get_dataset(DATA_NAME) # start experiment n_pool = len(Y_tr) n_test = len(Y_te) # generate initial labeled pool idxs_lb = np.zeros(n_pool, dtype=bool) idxs_lb[0:NUM_INIT_LB] = True # load network net = get_net(DATA_NAME, model=selected_model) handler = get_handler(DATA_NAME) print(net) #-- Strategy -- if AL_type == 'Random': strategy = RandomSampling(X_tr, Y_tr, idxs_lb, net, handler, args, al_apply=al_train_apply, cm_train_apply=cm_train_apply) elif AL_type == 'CutoutSampling': strategy = CutoutSampling(X_tr, Y_tr, idxs_lb, net, handler, args, al_apply=al_train_apply, alpha=alpha, cm_train_apply=cm_train_apply) # ALT elif AL_type == 'CutMixEntropy': strategy = CutMixEntropySampling(X_tr, Y_tr, idxs_lb, net, handler, args, al_apply=al_train_apply, cm_train_apply=cm_train_apply) # elif AL_type == 'MarginSampling': strategy = MarginSampling(X_tr, Y_tr, idxs_lb, net, handler, args, al_apply=al_train_apply, cm_train_apply=cm_train_apply) elif AL_type == 'EntropySampling': strategy = EntropySampling(X_tr, Y_tr, idxs_lb, net, handler, args, al_apply=al_train_apply, cm_train_apply=cm_train_apply)