def train(): # trainloader,testloader,classes = cifar10() net = saliency_model(num_classes=num_classes) net = net.cuda() criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters()) # black_box_func = resnet(pretrained=True) black_box_func = torch.load( '/media/david/datos/Violence DATA/HockeyFights/checkpoints/resnet18-frames-Finetuned:False-3di-tempMaxPool-OnPlateau.tar' ) black_box_func = black_box_func.cuda() loss_func = Loss(num_classes=num_classes) for epoch in range(num_epochs): # loop over the dataset multiple times running_loss = 0.0 running_corrects = 0.0 for i, data in tqdm(enumerate(dataloaders_dict['train'], 0)): # get the inputs inputs_r, labels = data #dataset load [bs,ndi,c,w,h] # print('dataset element: ',inputs_r.shape) inputs_r = inputs_r.permute(1, 0, 2, 3, 4) inputs = torch.squeeze(inputs_r, 0) #get one di [bs,c,w,h] # print('inputs shape:',inputs.shape) # wrap them in Variable inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda()) # zero the parameter gradients optimizer.zero_grad() mask, out = net(inputs, labels) # print('mask shape:', mask.shape) # print('inputs shape:',inputs.shape) # print('labels shape:',labels.shape) # inputs_r = Variable(inputs_r.cuda()) loss = loss_func.get(mask, inputs, labels, black_box_func) # running_loss += loss.data[0] running_loss += loss.item() if (i % 10 == 0): print('Epoch = %f , Loss = %f ' % (epoch + 1, running_loss / (batch_size * (i + 1)))) loss.backward() optimizer.step() save_checkpoint( net, '/media/david/datos/Violence DATA/HockeyFights/checkpoints/saliency_model.tar' )
def train(): num_epochs = 3 trainloader, testloader, classes = cifar10() net = saliency_model() net = net.cuda() criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters()) black_box_func = resnet() black_box_func = black_box_func.cuda() black_box_func = load_checkpoint(black_box_func, filename='./black_box_func.pth') #load the pretrained classfication model loss_func = Loss(num_classes=10) for epoch in range(num_epochs): # loop over the dataset multiple times running_loss = 0.0 running_corrects = 0.0 for i, data in tqdm(enumerate(trainloader, 0)): # get the inputs inputs, labels = data # wrap them in Variable inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda()) # zero the parameter gradients optimizer.zero_grad() mask, out = net(inputs, labels) loss = loss_func.get(mask, inputs, labels, black_box_func) running_loss += loss.data[0] if (i % 10 == 0): print('Epoch = %f , Loss = %f ' % (epoch + 1, running_loss / (4 * (i + 1)))) loss.backward() optimizer.step() save_checkpoint(net, 'saliency_model.pth')
def train(mask_model, criterion, optimizer, regularizers, classifier_model, num_epochs, dataloader, numDynamicImages, checkpoint_path, fold): loss_func = Loss(num_classes=2, regularizers=regularizers, num_dynamic_images=numDynamicImages) best_loss = 1000.0 for epoch in range(num_epochs): # loop over the dataset multiple times print("----- Epoch {}/{}".format(epoch + 1, num_epochs)) running_loss = 0.0 running_loss_train = 0.0 for data in tqdm(dataloader): inputs, labels, video_name, _, _ = data #dataset load [bs,ndi,c,w,h] # print('Inputs=', inputs.size()) # wrap them in Variable inputs, labels = Variable(inputs.to(DEVICE)), Variable( labels.to(DEVICE)) # zero the parameter gradients optimizer.zero_grad() mask, out = mask_model(inputs, labels) # print('MAsk passed=', mask.size()) loss = loss_func.get(mask, inputs, labels, classifier_model) # running_loss += loss.data[0] running_loss += loss.item() running_loss_train += loss.item() * inputs.size(0) loss.backward() optimizer.step() epoch_loss = running_loss / len(dataloader.dataset) epoch_loss_train = running_loss_train / len(dataloader.dataset) print("{} RawLoss: {:.4f} Loss: {:.4f}".format('train', epoch_loss, epoch_loss_train)) if checkpoint_path is not None and epoch_loss < best_loss: best_loss = epoch_loss # name = '{}_epoch={}.pth'.format(checkpoint_path) print('Saving model...', checkpoint_path) torch.save( { 'fold': fold, 'epoch': epoch, 'loss': epoch_loss, 'model_state_dict': mask_model.state_dict(), }, checkpoint_path)
def train(black_box_model, num_classes, num_epochs, regularizers, device, checkpoint_path, dataloaders_dict, black_box_file, numDynamicImages=0): # trainloader,testloader,classes = cifar10() net = saliencyModel.build_saliency_model(num_classes=num_classes) net = net.cuda() criterion = nn.CrossEntropyLoss() # params_to_update = net.parameters() # optimizer = optim.SGD(params_to_update, lr=0.001, momentum=0.9) optimizer = optim.Adam(net.parameters()) # scheduler_type = "OnPlateau" # if scheduler_type == "StepLR": # exp_lr_scheduler = lr_scheduler.StepLR( optimizer, step_size=7, gamma=0.1 ) # elif scheduler_type == "OnPlateau": # exp_lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=5, verbose=True) black_box_model = torch.load(black_box_file) black_box_model = black_box_model.cuda() loss_func = Loss(num_classes=num_classes, regularizers=regularizers) best_loss = 1000.0 for epoch in range(num_epochs): # loop over the dataset multiple times print("----- Epoch {}/{}".format(epoch + 1, num_epochs)) running_loss = 0.0 running_loss_train = 0.0 # running_corrects = 0.0 for i, data in tqdm(enumerate(dataloaders_dict['train'], 0)): # get the inputs inputs, labels, video_name = data #dataset load [bs,ndi,c,w,h] # print('dataset element: ',inputs_r.shape) #torch.Size([8, 1, 3, 224, 224]) if numDynamicImages > 1: inputs = inputs.permute(1, 0, 2, 3, 4) inputs = torch.squeeze(inputs, 0) #get one di [bs,c,w,h] # print('inputs shape:',inputs.shape) # wrap them in Variable inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda()) # zero the parameter gradients optimizer.zero_grad() mask, out = net(inputs, labels) # print('mask shape:', mask.shape) # print('inputs shape:',inputs.shape) # print('labels shape:', labels.shape) # print(labels) # inputs_r = Variable(inputs_r.cuda()) loss = loss_func.get(mask, inputs, labels, black_box_model) # running_loss += loss.data[0] running_loss += loss.item() running_loss_train += loss.item() * inputs.size(0) # if(i%10 == 0): # print('Epoch = %f , Loss = %f '%(epoch+1 , running_loss/(batch_size*(i+1))) ) loss.backward() optimizer.step() # exp_lr_scheduler.step(running_loss) epoch_loss = running_loss / len(dataloaders_dict["train"].dataset) epoch_loss_train = running_loss_train / len( dataloaders_dict["train"].dataset) print("{} RawLoss: {:.4f} Loss: {:.4f}".format('train', epoch_loss, epoch_loss_train)) if epoch_loss < best_loss: best_loss = epoch_loss # self.best_model_wts = copy.deepcopy(self.model.state_dict()) print('Saving entire saliency model...') save_checkpoint(net, checkpoint_path) # def __anomaly_main__(): # parser = argparse.ArgumentParser() # parser.add_argument("--batchSize", type=int, default=8) # parser.add_argument("--numEpochs", type=int, default=10) # parser.add_argument("--numWorkers", type=int, default=4) # parser.add_argument("--areaL", type=float, default=None) # parser.add_argument("--smoothL", type=float, default=None) # parser.add_argument("--preserverL", type=float, default=None) # parser.add_argument("--areaPowerL", type=float, default=None) # parser.add_argument("--saliencyModelFolder",type=str, default=constants.ANOMALY_PATH_SALIENCY_MODELS) # parser.add_argument("--blackBoxFile", type=str) #areaL-9.0_smoothL-0.3_epochs-20 # parser.add_argument("--videoSegmentLength", type=int, default=0) # parser.add_argument("--positionSegment", type=str, default='random') # parser.add_argument("--maxNumFramesOnVideo", type=int, default=0) # parser.add_argument("--shuffle", type=lambda x: (str(x).lower() == 'true'), default=False) # # parser.add_argument("--areaL", type=float, default=8) # # parser.add_argument("--smoothL", type=float, default=0.5) # # parser.add_argument("--preserverL", type=float, default=0.3) # # parser.add_argument("--areaPowerL", type=float, default=0.3) # # parser.add_argument("--checkpointInfo",type=str) # args = parser.parse_args() # device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # avgmaxDuration = 0 # numDiPerVideos = 1 # input_size = 224 # data_transforms = transforms_anomaly.createTransforms(input_size) # dataset_source = 'frames' # batch_size = args.batchSize # num_workers = args.numWorkers # num_epochs = args.numEpochs # black_box_file = args.blackBoxFile # saliency_model_folder = args.saliencyModelFolder # num_classes = 7 # videoSegmentLength = args.videoSegmentLength # positionSegment = args.positionSegment # maxNumFramesOnVideo = args.maxNumFramesOnVideo # shuffle = args.shuffle # # regularizers = {'area_loss_coef': args.areaL, 'smoothness_loss_coef': args.smoothL, 'preserver_loss_coef': args.preserverL, 'area_loss_power': args.areaPowerL} # # checkpoint_info = args.checkpointInfo # checkpoint_info = '' # areaL, smoothL, preserverL, areaPowerL = None,None,None,None # if args.areaL == None: # areaL = 8 # else: # areaL = args.areaL # checkpoint_info += '_areaL-'+str(args.areaL) # if args.smoothL == None: # smoothL = 0.5 # else: # smoothL = args.smoothL # checkpoint_info += '_smoothL-' + str(args.smoothL) # if args.preserverL == None: # preserverL = 0.3 # else: # preserverL = args.preserverL # checkpoint_info += '_preserverL-' + str(args.preserverL) # if args.areaPowerL == None: # areaPowerL = 0.3 # else: # areaPowerL = args.areaPowerL # checkpoint_info += '_areaPowerL-' + str(args.areaPowerL) # print('areaL, smoothL, preserverL, _areaPowerL=',areaL, smoothL, preserverL, areaPowerL) # regularizers = {'area_loss_coef': areaL, 'smoothness_loss_coef': smoothL, 'preserver_loss_coef': preserverL, 'area_loss_power': areaPowerL} # checkpoint_path = os.path.join(saliency_model_folder, 'saliency_model' + checkpoint_info + '_epochs-' + str(num_epochs) + '.tar') # image_datasets, dataloaders_dict = init_anomaly(batch_size, num_workers, maxNumFramesOnVideo, data_transforms, numDiPerVideos, avgmaxDuration, dataset_source, shuffle, videoSegmentLength, positionSegment) # # image_datasets, dataloaders_dict = init(batch_size, num_workers, interval_duration, data_transforms, dataset_source, debugg_mode, numDiPerVideos, avgmaxDuration) # train(num_classes, num_epochs, regularizers, device, checkpoint_path, dataloaders_dict, black_box_file, numDiPerVideos) # __anomaly_main__()
class BrainsphereModel: def __init__(self, functional_connectivity, patient_data, **kwargs): self.types = [ 'ConcentrationLinear', 'Constant', 'ConcentrationSigmoid', 'WeightedDegreeLinear', 'WeightedDegreeSigmoid' ] self.producer = Producer(self.types) self.params = self.producer.params for key, value in kwargs.items(): if key == "nodeCoordinates": self.nodeCoordinates = value elif key == "optimizer": self.optimizer = value elif key == "loss": self.loss = value elif key == "euclideanAdjacency": self.euclideanAdjacency = value elif key == "producer": self.producer = value elif key == "diffuser": self.diffuser = value elif key == "params": self.params.update(value) else: raise TypeError("Illegal Keyword '" + str(key) + "'") self.functionalConnectivity = functional_connectivity self.patientData = patient_data self.numNodes, _ = np.shape(functional_connectivity) self.loss = Loss("mse", self.patientData) self.lastloss = 0 self.reset() def reset(self): self.initializer = Initializer("braak1", self.numNodes, self.params) self.concentration = self.initializer.get() self.concentrationHistory = np.copy(self.concentration) self.producer = Producer(self.types) self.diffusor = Diffusor("euclidean", self.params, EuclideanAdjacency=self.euclideanAdjacency) def run(self): stop_concentration = 1100 timesteps = 2500 self.reset() deltaT = 0.0001 self.concentration += deltaT * ( self.producer.produce(params=self.params, concentration=self.concentration, connectivity=self.functionalConnectivity) + self.diffusor.diffuse(self.concentration)) self.concentrationHistory = np.append(self.concentrationHistory, self.concentration, axis=0) deltaConc = np.sum(self.concentrationHistory[1, :]) - np.sum( self.concentrationHistory[0, :]) if deltaConc <= 0.0: return 9999999 else: deltaT *= stop_concentration / timesteps / deltaConc while (np.sum(self.concentration) < stop_concentration) and (np.sum(deltaConc) > 0): deltaConc = deltaT * (self.producer.produce( params=self.params, concentration=self.concentration, connectivity=self.functionalConnectivity) + self.diffusor.diffuse(self.concentration)) self.concentration += deltaConc self.concentrationHistory = np.append(self.concentrationHistory, self.concentration, axis=0) # print(self.loss.get(self.concentrationHistory)) self.lastloss = self.loss.get(self.concentrationHistory) return self.lastloss def gradient(self, loss=None): if loss is None: loss = self.run() params_new = {} params_old = self.params.copy() deltaX = {} for key, value in params_old.items(): deltaX[key] = np.sign(np.random.randn()) * 0.01 params_new[key] = value + deltaX[key] self.params = params_new new_loss = self.run() grad = {} self.params = params_old for key, value in params_old.items(): grad[key] = (new_loss - loss) / (deltaX[key]) return grad def gradient4(self): loss = self.run() gradients = Parallel(n_jobs=4)(delayed(self.gradient)(loss) for i in range(4)) grad = {} for key in self.params: gradsum = 0 count = 0 for g in gradients: gradsum += g.get(key) count += 1.0 grad[key] = gradsum / count return grad
def train(batch_size, num_workers, regularizers, device, checkpoint_file): num_epochs = 3 trainloader, testloader, classes = cifar10(batch_size, num_workers) net = saliency_model() net = net.to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters()) # black_box_func = resnet(pretrained=True) # black_box_func = black_box_func.cuda() model_name = 'alexnet' # defaults.device = 'cpu' black_box_func = BlackBoxModel(model_name=model_name, pretrained=True, num_classes=10) black_box_func.load('data/checkpoints/black_box_model_alexnet.tar', device='gpu') black_box_func.toDevice(device) black_box_func = black_box_func.getModel() loss_func = Loss(num_classes=10, regularizers=regularizers) for epoch in range(num_epochs): # loop over the dataset multiple times print("----- Epoch {}/{}".format(epoch, num_epochs)) running_loss = 0.0 running_corrects = 0.0 running_loss_train = 0.0 for i, data in tqdm(enumerate(trainloader, 0)): # get the inputs inputs, labels = data # wrap them in Variable inputs, labels = Variable(inputs.to(device)), Variable( labels.to(device)) # zero the parameter gradients optimizer.zero_grad() mask, out = net(inputs, labels) # print('-----mask shape:',mask.shape) # print('-----inputs shape:',inputs.shape) # print('-----labels shape:', labels.shape) # print(labels) loss = loss_func.get(mask, inputs, labels, black_box_func) # running_loss += loss.data[0] running_loss += loss.item() running_loss_train += loss.item() * inputs.size(0) # if(i%10 == 0): # print('Epoch = %f , Loss = %f '%(epoch+1 , running_loss/(batch_size*(i+1))) ) loss.backward() optimizer.step() epoch_loss = running_loss / len(trainloader.dataset) epoch_loss_train = running_loss_train / len(trainloader.dataset) print("{} RawLoss: {:.4f} Loss: {:.4f}".format("train", epoch_loss, epoch_loss_train)) save_checkpoint(net, checkpoint_file)