def exitProgram(self, ctx:LittleExprParser.ProgramContext): #print("\n".join(self.printSymbolTable)) #print(self.allCode) AST.functReturns = self.functReturns globalVars = ([var for var in self.symbolTable[-1].keys() if self.symbolTable[-1][var][0] != "STRING"]) CFGList = [] self.tinyGenerator = TinyGenerator(self.allCode, stringInit=1) tinyCode = "" for var in globalVars: tinyCode += "var {0}\n".format(var) tinyCode += self.tinyGenerator.generate() # tinyCode += "push\npush r0\npush r1\npush r2\npush r3\njsr main\nsys halt\n" tinyCode += "push\njsr main\nsys halt\n" # tinyCode += "push\njsr main\nsys halt\n" for functNode in self.functNodeList: AST.tempRegNum = 1 functCode = functNode.generateCode() functOptimizer = Optimizer(functCode) functCode = functOptimizer.optimize() functTinyGen = TinyGenerator(functCode, globalVariables=globalVars, functName=functNode.functName) self.allCode += functCode tinyCode += functTinyGen.generate() self.symbolTable.pop() self.tinyCode = tinyCode # self.tinyGenerator = TinyGenerator(self.allCode) # self.tinyGenerator.generate() self.printTinyIR() pass
def _main(mainfile): pname = mainfile.rpartition('.')[0] cppfile = pname + '.cpp' program = AstTranslator.translateFile(mainfile) Optimizer.correct(program) if '-O' in command_line_flags: Optimizer.optimize(program) if '-n' in command_line_flags: return if '-i' in command_line_flags: program.pprint() return IRtoC.translateProgram(program, open(cppfile, 'w')) if '-ng' not in command_line_flags: CppCompiler.build(cppfile, pname, '-gcc' in command_line_flags, '-W' in command_line_flags, '-g' in command_line_flags )
def main(args, folder): overwrite_data = False run_description = 'Simulated aberrations and images for Deep Learning Training \n\ Lab 118. \n\ 112x112 image dimensions. \n\ Zernike Polynomials 1-35. \n\ Fully randomized aberration generation. \n\ Zernike optimization using corrected scaling. \n\ zbasis = True. \n\ Exposure value at -6.' os.makedirs(folder, exist_ok=True) shutil.copy(sys.argv[0], folder + '/mainscript.py') shutil.copystat(sys.argv[0], folder + '/mainscript.py') file = open(folder + '/log.txt', 'w+') print('Run Description: ', run_description) file.write('Description: ' + run_description + '\n\n') file.close() interface = Interface.Interface(args) args.num_initial_metrics = 10 args0 = copy.copy(args) optimize_zernike = True zopt_mask = 0 if optimize_zernike: args = copy.copy(args0) ## args.save_path = folder+'/zopt' args.save_path = folder[:folder.rfind('DL_data') + len('DL_data')] zmodes = np.arange(3, 49) zopt = Optimizer.Optimizer(args, interface) if os.path.isfile(args.save_path + '/optimized_zmodes.txt'): print('Loading zmodes from file...') opt_zmodes = np.loadtxt(args.save_path + '/optimized_zmodes.txt') print(opt_zmodes) zopt_mask = zopt.parent_masks.create_zernike_mask(opt_zmodes) print(zopt_mask.shape) else: args.save_path = folder + '/zopt' zopt.run_zernike(zmodes, [-600, 600]) zopt_mask = zopt.parent_masks.get_slm_masks()[-1] coeff_range = [-128, 128] DLmodes = np.arange(1, 36) num_data = 1000000 batch_size = 1000 args = copy.copy(args0) args.save_path = folder + '/DLdata' DLopt = Optimizer.Optimizer(args, interface, base_mask=zopt_mask) DLopt.record_DLdata(DLmodes, coeff_range, num_data, batch_size, overwrite=overwrite_data) print('\n\nDONE with zernike optimization............\n\n')
def testLogisticRegression(): epsilon = 0.000001 testData = np.mat(np.loadtxt("data/horseColicTest.txt")) trainingData = np.mat(np.loadtxt("data/horseColicTraining.txt")) __testCore(trainingData, testData, Optimizer.GradientDescent(epsilon)) __testCore(trainingData, testData, Optimizer.NewtonMethod(epsilon))
def main(argv): Tb_no=int(argv[1]) File_names=[] for i in range(0,Tb_no): File_names.append(argv[2+i]) try: Entities,Signals,Process_Set=P.Parser(File_names) except Exception as e: print("\n\nFrom Main Failed : "+str(e)+"\n\n") try: kernel = OP.Optimizer(Entities,Signals,Process_Set) except Exception as e: print("\n\nFrom Main Failed : "+str(e)+"\n\n") Max_Time=int(argv[2+Tb_no]) try: Sim.Simulation(kernel,Max_Time) except Exception as e: print("\n\nFrom Main Failed : "+str(e)+"\n\n")
def __init__(self, id): self.state2status = ("ready", "running", "suspend", "success", "failed", "stoped") db = MySQLdb.connect(host, user, password, database) cursor = db.cursor() sql = "select * from t_task_info where id = " + str(id) cursor.execute(sql) data = cursor.fetchone() self.id = id self.modelName = data[1] self.dataSource = data[2] self.preParameter = data[3] self.taskName = data[4] self.state = State(data[7]) self.process = data[8] self.lossFunction = data[9] self.learnRateUpdate = data[10] self.learnRate = data[11] self.batchSize = data[12] self.iterNum = data[13] self.metric = data[15] self.Optimizer = self.parseOptimizer(Optimizer(self.learnRateUpdate)) self.LossFunc = self.parseLossFunc(self.lossFunction) self.Metric = self.parseMetric(self.metric) self.dataSource_dir = self.parseDataSourceBase(self.dataSource) self.line = self.parseModel() self.learnRateData = [] self.trainLoss = [] self.testLoss = [] self.trainAcc = [] self.testAcc = [] self.con = threading.Condition() self.pos = 0
def train_comparison(args, theta, dataset): hyper_params = {k: args[k] for k in ['b_size']} hyper_params['to_fix'] = [ ] # a selection of parameters can be fixed, e.g. the word embeddings # initialize optimizer with learning rate (other hyperparams: default values) opt = args['optimizer'] if opt == 'adagrad': optimizer = Optimizer.Adagrad(theta, lr=args['learningrate'], lambda_l2=args['lambda']) elif opt == 'adam': optimizer = Optimizer.Adam(theta, lr=args['learningrate'], lambda_l2=args['lambda']) elif opt == 'sgd': optimizer = Optimizer.SGD(theta, lr=args['learningrate'], lambda_l2=args['lambda']) else: raise RuntimeError("No valid optimizer chosen") # train model evals = plain_train(optimizer, dataset, hyper_params, n_epochs=args['n_epochs'], outdir=args['out_dir']) # store learned model store_theta( theta, os.path.join(args['out_dir'], 'comparisonFinalModel.theta.pik')) # run final evaluation for name, tb in dataset.iteritems(): print('Evaluation on ' + name + ' data (' + str(len(tb.examples)) + ' examples)') tb.evaluate(optimizer.theta, verbose=1) # create convergence plot for name, eval in evals.items(): toplot = [e[key] for e in eval for key in e if 'loss' in key] plt.plot(xrange(len(toplot)), toplot, label=name) plt.legend() plt.title([key for key in eval[0].keys() if 'loss' in key][0]) plt.savefig(os.path.join(args['out_dir'], 'comparisonConvergence.png'))
def nn(nfeature, nclass, nunits, lamb, seed, learning_rate, beta1, beta2, epsilon): np.random.seed(seed) model = NeuralNetwork.NeuralNetwork(nfeature) model.add_layer(nunits, "relu", lamb) model.add_layer(nclass, "softmax", lamb) optimizer = Optimizer.Adam(learning_rate, beta1, beta2, epsilon) model.compile("crossentropy", optimizer) return model
def do_all(EMPLID, ACAD_PLAN, ENROLL_YEAR): # EMPLID = 1203975040 # ACAD_PLAN = 'BAMKTBS' # ENROLL_YEAR = 2011 matcher = mm.MatchMachine(st.Student(EMPLID), mj.Major(ACAD_PLAN, ENROLL_YEAR)) opt = oz.Optimizer(matcher) result = [opt.out, opt.missed_courses, opt.missed_requirments] return result
def loso_with_best_models(features_dic): """! \brief This is the function you should call if you have a dictionary with keys as the speakers and each one has a corresponding 2D matrix and a 1d label vector for each one. Namely: converted_dic[spkr]['x'] = X_2D converted_dic[spkr]['y'] = y_list""" best_models = {} svm_opt_obj = Optimizer.ModelOptimizer( 'svm', generate_speaker_dependent_folds(features_dic), { 'C': [1, 3, 5, 7, 8, 10], 'kernel': ['rbf'] }, ['w_acc', 'uw_acc']) best_models["SVM Dependent"] = svm_opt_obj.optimize_model() svm_opt_obj = Optimizer.ModelOptimizer( 'svm', generate_speaker_independent_folds(features_dic), { 'C': [1, 3, 5, 7, 8, 10], 'kernel': ['rbf'] }, ['w_acc', 'uw_acc']) best_models["SVM Independent"] = svm_opt_obj.optimize_model() lr_opt_obj = Optimizer.ModelOptimizer( 'lr', generate_speaker_dependent_folds(features_dic), { 'C': [0.01, 0.05, 0.1, 0.3, 0.5, 1], 'penalty': ['l2'] }, ['w_acc', 'uw_acc']) best_models["LR Dependent"] = lr_opt_obj.optimize_model() lr_opt_obj = Optimizer.ModelOptimizer( 'lr', generate_speaker_independent_folds(features_dic), { 'C': [0.01, 0.05, 0.1, 0.3, 0.5, 1], 'penalty': ['l2'] }, ['w_acc', 'uw_acc']) best_models["LR Independent"] = lr_opt_obj.optimize_model() return best_models
def compare(folder, start_time, run_time, interface): runid = '_compareall' run_description = 'Comparing performance of all masks in folder.' ### PARAMS #### numframes = 1 zeromask = True zopt = Optimizer.Optimizer(args, interface) # update zernike bestmask.txt for all zopt folders in dir. for root, dirs, files in os.walk(folder): zdirs = [ os.path.join(root, d) for d in dirs if 'compare' not in d and any([zz in d for zz in ['zopt', 'zspace']]) ] for zd in zdirs: zd += '/optimized_zmodes.txt' if os.path.isfile(zd): zopt.save_zernike_mask(zd) print('UPDATED bestmask.txt: ', zd) # create or open compare_list.txt if not os.path.isfile(folder + '/compare_list.txt'): maskfiles = Optimizer.get_mask_compare_list(folder) else: f = open(folder + '/compare_list.txt') maskfiles = [x.strip() for x in f] f.close() for x in maskfiles: print(x) zopt.run_compare_masks(start_time, run_time, numframes, folder, maskfiles, runid, run_description, zeromask, cmasks=None, mask_labels=None)
def train(self,train,test,validate): if self.n_dimensions==0: self.labels=np.unique(train[1]); n_classes = len(self.labels) n_dimensions=np.shape(x)[1]; self.initialize_parameters(n_dimensions,n_classes); opti=Optimizer.Optimizer(1000,"SGD",1,2000,0.13,2000*0.99); opti.set_datasets(train,test,validate); opti.set_functions(self.negative_log_likelihood,self.set_training_data,self.classify,self.callback,self.learn,None,None); opti.run();
def nn(nfeature, seed, learning_rate, beta): np.random.seed(seed) model = NeuralNetwork.NeuralNetwork(nfeature) model.add_layer(15, "tanh") model.add_layer(11, "tanh") model.add_layer(8, "tanh") model.add_layer(4, "tanh") model.add_layer(1, "sigmoid") optimizer = Optimizer.Momentum(learning_rate, beta) model.compile("binarycrossentropy", optimizer) return model
def nn(nfeature, nclass, seed, learning_rate, beta): np.random.seed(seed) model = NeuralNetwork.NeuralNetwork(nfeature) model.add_layer(11, "tanh") model.add_layer(9, "tanh") model.add_layer(6, "tanh") model.add_layer(3, "tanh") model.add_layer(nclass, "softmax") optimizer = Optimizer.Momentum(learning_rate, beta) model.compile("crossentropy", optimizer) return model
def train(self,train,test,validate): """ the main training function,that initialzes the optimizer and starts the training process """ self.labels=np.unique(train[1]); #initialize the optimizer opti=Optimizer.Optimizer(1000,"SGD",1,200,0.13,200*0.001); #set the training,testing and validation datasets opti.set_datasets(train,test,validate); #set the cinoytat opti.set_functions(self.logRegressionLayer.negative_log_likelihood,self.set_training_data,self.classify,self.callback,self.learn,None,None); opti.run();
def train(self,train,test,validate): if self.n_dimensions==0: self.labels=np.unique(train[1]); n_classes = len(self.labels) n_dimensions=np.shape(x)[1]; self.initialize_parameters(n_dimensions,n_classes); opti=Optimizer.Optimizer(200,"SGD",1,1,0.013); #(self,maxiter=1000,method="SGD",validation_iter=1,batch_size=600,learning_rate=0.13): opti.set_datasets(train,test,validate); opti.set_functions(self.negative_log_likelihood,self.set_training_data,self.classify,self.gradients,self.get_params,self.callback); opti.run();
def optimize(self): """ Runs the schedule optimizer First: verifies that we have all the necessary data Seoncd: Checks the save location print("Put your function here") """ still_needed = [] # Verify the required information if self.preference_input is None: still_needed.append("Preferences") if self.LP_input is None: still_needed.append("LP_input") if self.teacher_file is None: still_needed.append("Teacher File (secondary)") s = "" if len(still_needed) > 0: s = str(still_needed) messagebox.showerror("Error", "You are missing the following\n\n" + s) return GAP = self.slider.get() print(GAP) print("All good") # optimize_schedule(self.preference_input, self.LP_input, None, # self.teacher_file, GAP, self.requirements, self.save_location) # The none is for Grades, as I just hard coded that in the opt code for now # Create optimization instance O = Optimizer(self.preference_input, self.LP_input, None, self.teacher_file, GAP, self.requirements, self.save_location) O.optimize()
def do_all(EMPLID, ACAD_PLAN, ENROLL_YEAR): start_time = time.time() matcher = mm.MatchMachine(st.Student(EMPLID), mj.Major(ACAD_PLAN, ENROLL_YEAR)) print("--- %s seconds ---" % (time.time() - start_time)) start_time = time.time() opt = oz.Optimizer(matcher) print("--- %s seconds ---" % (time.time() - start_time)) start_time = time.time() result = opt.out, opt.missed_courses, opt.missed_requirments print("--- %s seconds ---" % (time.time() - start_time)) return result
def doIt(self, ArchitectureType): ReturnedTuple = self.transformObjectsIntoCode(self.Root, 0, 0, []) if ReturnedTuple[0]: print("Compilation successfull") else: print("Compilation Error") print(ReturnedTuple[1]) print("\n\n") print(self.ImmediateCodeObj.debugImmediateCode(self.ImmediateCodeObj.ImmCodeData)) self.ImmediateCode = self.ImmediateCodeObj.ImmCodeData OptimizerObj = Optimizer() OptimizerObj.ImmediateInstructions = self.ImmediateCode OptimizerObj.Variables = self.ImmediateCodeObj.Variables OptimizeAddSubToIncDec = True if ArchitectureType == Generator.EnumArchitetureType.PARALLEL: OptimizeAddSubToIncDec = False OptimizerObj.doOptimization(OptimizeAddSubToIncDec) self.ImmediateCodeOptimized = OptimizerObj.ImmediateInstructions self.Variables = OptimizerObj.Variables print("\n\n") print(self.ImmediateCodeObj.debugImmediateCode(self.ImmediateCodeOptimized)) if ArchitectureType == Generator.EnumArchitetureType.PARALLEL: self.ArchOutput.ImmediateCodeOptimized = self.ImmediateCodeOptimized self.ArchOutput.VariablesOptimized = self.Variables (CalleeSuccess, CalleeMessage) = self.ArchOutput.generateParallelDesign() if not CalleeSuccess: print("Error: " + CalleeMessage) elif ArchitectureType == Generator.EnumArchitetureType.SERIAL: pass else: print("Internal error") return False
def main(argv): Tb_no = int(argv[1]) File_names = [] for i in range(0, Tb_no): File_names.append(argv[2 + i]) # Parses the vhdl files Signals, Process_Set = P.Parser(File_names) # Gets the optimized lightweight Kernel kernel = OP.Optimizer(Signals, Process_Set) Max_Time = int(argv[2 + Tb_no]) #Simulates the files Sim.Simulation(kernel, Max_Time)
import time # (1) Set up data ntrain = 6000 nvalid = 1000 nclass = 10 Xtrain,Ytrain,Xvalid,Yvalid = load_mnist.load_mnist(ntrain,nvalid) # (2) Define model nfeature = Xtrain.shape[0] np.random.seed(10) lamb = 0.0 model = NeuralNetwork.NeuralNetwork(nfeature) model.add_layer(128,"relu",lamb) model.add_layer(nclass,"softmax",lamb) # (3) Compile model optimizer = Optimizer.Adam(0.02,0.9,0.999,1e-7) model.compile("crossentropy",optimizer) model.summary() # (4) Train model epochs = 40 time_start = time.time() history = model.fit(Xtrain,Ytrain,epochs,batch_size=ntrain,validation_data=(Xvalid,Yvalid)) time_end = time.time() print("Train time: {}".format(time_end - time_start)) # (5) Predictions and plotting # confusion matrix print("Metrics for Validation Dataset") Yvalid_pred = model.predict(Xvalid) metrics.confusion_matrix(Yvalid,Yvalid_pred,nclass) # plot loss, accuracy, and animation of results plot_results.plot_results_history(history,["loss","valid_loss"])
import Dicretizer import Optimizer print('unsupervised discretization on weatherLong.csv') discretizer = Dicretizer.Unsupervised() result = discretizer.discretize("weatherLong.csv", '$temp') print(result[1]) print('unsupervised discretization on auto.csv') discretizer = Dicretizer.Unsupervised() result = discretizer.discretize("auto.csv", '$horsepower') print(result[1]) optimizer1 = Optimizer.Dom() print("domination score of weatherLong.csv") result = optimizer1.getScore("weatherLong.csv") print(result[1]) print("domination score of auto.csv") result = optimizer1.getScore("auto.csv") print(result[1])
''' train_dataset, test_dataset = Data_Reader.Mnist.Mnist_dataset().get_dataset() loader_train = Data_Reader.get_dataloader(dataset=train_dataset, batch_size=param['batch_size']) loader_test = Data_Reader.get_dataloader(dataset=test_dataset, batch_size=param['test_batch_size']) ''' 搭建模型 模型在model.py里面搭建好了,这里直接调用 ''' modelpath = './train3_AdvT.pkl' net = Models.Lenet5.Lenet5() # 加载模型 net = Models.load_state_dict(net, modelpath) base.enable_cuda(net) # 使用cuda num_correct, num_samples, acc = Optimizer.test(net, loader_test) # 测试一下最初的效果 print('[Start] right predict:(%d/%d) ,pre test_acc=%.4f%%' % (num_correct, num_samples, acc)) ''' 训练模型 ''' net.train() # 训练模式 criterion = nn.CrossEntropyLoss() # 损失函数 optimizer = torch.optim.RMSprop(net.parameters(), lr=param['learning_rate'], weight_decay=param['weight_decay']) # 优化器,具体怎么优化,学习率、正则化等等 '''对抗样本攻击''' #adversary = Adversary.FGSM.FGSM(net, param['epsilon']) # 攻击方法 adversary = Adversary.LinfPGD.LinfPGDAttack(net, param['epsilon']) for epoch in range(param['num_epochs']):
def opti_mom(model): return Optimizer.SGD(model.param(), lr = lr, momentum = True, mu = mu)
def opti(model): return Optimizer.SGD(model.param(),lr = lr)
def initialDictionary(self): # if there is not a single negative value in the basic coefficients, then it is not necessary to # run the initialization phase if all(i >= 0 for i in self.b): return self else: if DEBUG: print("Original Dictionary") print(self) # get the dictionary with the objective function changed newObjDict = self.newObjectiveForInitializationPhase() if DEBUG: print("Dictionary with New Objective Function") print(newObjDict) # get the dual of the new dictionary dualDict = newObjDict.dual() if DEBUG: print("Dual Dictionary with Objective Changed") print(dualDict) # optimize the dual of the new dictionary opt = Optimizer() steps, dualOptmized, status = opt.solveLinearProgrammingRelaxation( dualDict) # if the optimization phase results in an Unbounded dictionary, # then the original dictionary is Infeasible if status == Dictionary.UNBOUNDED: self.statuscode = Dictionary.INFEASIBLECODE self.status = Dictionary.INFEASIBLE return self else: # mount the primal dictionary from the optmized dual if DEBUG: print("Dual After Initialization Phase") print(dualOptmized) # first, get the raw primal primalDictionary = dualOptmized.dual() if DEBUG: print("Primal Dictionary After Initialization") print(primalDictionary) # second, change the objective function to the original objective A_aux = primalDictionary._getAuxMatrix() C_aux = map(lambda x: mp.mpf(str(x)), np.zeros(len(self.c) + 1)) # compute the new value of the C vector according to the original objective function (original c vector) for i in range(len(self.nonBasicIdx)): idx_aux = np.nonzero( primalDictionary.basicIdx == self.nonBasicIdx[i])[0] # if the variable is one of the basic variables of the primal, # then add the associated row times the coefficient in the original dictionary if len(idx_aux) > 0: idx_aux = idx_aux[0] C_aux += self.c[i] * A_aux[idx_aux, :] else: # if the variable is one of the non basic variables of the primal, # then add the coefficient in the original dictionary to the related column in the primal idx_aux = np.nonzero(primalDictionary.nonBasicIdx == self.nonBasicIdx[i])[0] if len(idx_aux) > 0: idx_aux = idx_aux[0] C_aux[idx_aux + 1] += self.c[ i] # index shifted by +1 because of the Z value primalDictionary.z = C_aux[0] primalDictionary.c = C_aux[1:primalDictionary.n + 1] primalDictionary.status = Dictionary.STANDARD if DEBUG: print( "Primal Dictionary After Initialization with Original Objective" ) print(primalDictionary) return primalDictionary
def preProcess(self): optimizer1 = Optimizer.Dom() self.filteredData = optimizer1.getScore(self.csvFile)[0] self.table = Rows.TableLoader(self.csvFile) self.table.loadTableWithGenerator()
y_test = one_hot[50000:60000] x_test = x_train[50000:60000] x_train = x_train[:50000] # initialize parameters num_classes = y_train.shape[1] hidden = 50 x_train = x_train.reshape(x_train.shape[0], 1, 28, 28) x_test = x_test.reshape(x_test.shape[0], 1, 28, 28) print(x_train.shape) model = Model() model.addlayer(ConvLayer(32, (3, 3)), name='conv1') model.addlayer(Layers.ReLU(), name='relu1') model.addlayer(Layers.Dropout(), name='dropout1') model.addlayer(Layers.Flatten(), name='flatten') model.addlayer(Layers.MulLayer(10), name="w1") model.addlayer(Layers.AddLayer(10), name='b1') model.addlayer(Layers.ReLU(), name='relu3') model.addlayer(Layers.Dropout(0.5), name='dropout3') model.addlayer(Layers.SoftmaxLayer(), name='softmax') optimizer = Optimizer.Adam(batch_size=32) model.train(x_train, y_train, optimizer, 10000, 0.01) model.save() print("--TRAIN EVAL--") model.eval(x_train, y_train) print("--TEST EVAL--") model.eval(x_test, y_test)
def main(argv): separator = ' ' # read m(# of constraints) and n(# of variables) m, n = toInt(readLine(sys.stdin, separator)) if DEBUG: sys.stderr.write(str(m)+"\n") sys.stderr.write(str(n)+"\n") # read the list of basic indices basicIdx = toInt(readLine(sys.stdin, separator)) if DEBUG: sys.stderr.write(str(basicIdx)+"\n") # read the list of non-basic indices nonBasicIdx = toInt(readLine(sys.stdin, separator)) if DEBUG: sys.stderr.write(str(nonBasicIdx)+"\n") # read the list of values for the basic indices (at the same order they are declared) # remember: Ax <= b, b is the list being read basicValues = toFloat(readLine(sys.stdin, separator)) if DEBUG: sys.stderr.write(str(basicValues)+"\n") # read the matrix A (from problem Ax <= b) coeffMatrix = [] for i in range(m): row = toFloat(readLine(sys.stdin, separator)) coeffMatrix.append(row) coeffMatrix = np.array(coeffMatrix) if DEBUG: sys.stderr.write(str(coeffMatrix)+"\n") # read the current objective value and the current objective row coefficients coeffObjs = toFloat(readLine(sys.stdin, separator)) z = coeffObjs[0] coeffObj = coeffObjs[1:] dictionary = Dictionary(m, n, basicIdx, nonBasicIdx, basicValues, coeffMatrix, coeffObj, z, mp.power(10,-100)) if DEBUG: sys.stderr.write("Original Dictionary\n") sys.stderr.write(str(dictionary)+"\n") # Initialization Phase newDictionary = dictionary.initialDictionary() if DEBUG: sys.stderr.write("Dictionary After Initialization Phase\n") sys.stderr.write(newDictionary+"\n") sys.stdout.flush() if newDictionary.statuscode == Dictionary.INFEASIBLECODE: sys.stdout.write(newDictionary.status) return opt = Optimizer() cuts, optmizedDict, status = opt.solveLinearProgrammingRelaxation(newDictionary) if DEBUG: sys.stderr.write("Ootimized Dictionary\n") sys.stderr.write(str(optmizedDict)+"\n") if optmizedDict.statuscode < 0: sys.stdout.write(status) else: print "%.6f" % optmizedDict.z
learning_rate = 0.01 L1_reg = 0.00 L2_reg = 0.0001 n_epochs = 2 dataset = 'mnist.pkl.gz' batch_size = 20 n_hidden = 500 n_out = 10 (xtrain,ytrain), (xvalid,yvalid), (xtest, ytest) = Pickle.load(open('mnist.pkl')) print '... building the model' classifier = MLP( n_in=28 * 28, n_out=10, layers = [LayerData(n_out=n_hidden, activation=T.tanh)], L1_reg = L1_reg, L2_reg = L2_reg) print '... training' start = time.clock() opt.gradient_descent(NN = classifier, x_train = xtrain, y_train = ytrain, learning_rate = learning_rate, n_epochs = n_epochs, batch_size = batch_size, x_valid = xvalid, y_valid = yvalid)
low=-np.sqrt(6. / (784 + 500)), high=np.sqrt(6. / (784 + 500)), size=(784, 500)) W_init = th.shared(np.asarray(random_arr, dtype=th.config.floatX), 'W', borrow = True) # Autoencoder - NO NOISE AE = AutoEncoder(n_in = 784, layers = [NN.LayerData(n_out = 500, W = W_init)], rng = rng) print '... Training Autoencoder' opt.gradient_descent(AE, x_train = xtrain, y_train = xtrain, learning_rate = 0.1, batch_size = 20, n_epochs = 20, x_valid = xvalid, y_valid = xvalid) # Autoencoder - 30% NOISE DAE = DenoisingAutoEncoder(n_in = 784, layers = [NN.LayerData(n_out = 500, W = W_init)], corruption_level = 0.3, rng = rng) print '... Training Autoencoder' opt.gradient_descent(DAE, x_train = xtrain, y_train = xtrain,
def initialDictionary(self): # if there is not a single negative value in the basic coefficients, then it is not necessary to # run the initialization phase if all(i >= 0 for i in self.b): return self else: if DEBUG: print("Original Dictionary") print(self) # get the dictionary with the objective function changed newObjDict = self.newObjectiveForInitializationPhase() if DEBUG: print("Dictionary with New Objective Function") print(newObjDict) # get the dual of the new dictionary dualDict = newObjDict.dual() if DEBUG: print("Dual Dictionary with Objective Changed") print(dualDict) # optimize the dual of the new dictionary opt = Optimizer() steps, dualOptmized, status = opt.solveLinearProgrammingRelaxation(dualDict) # if the optimization phase results in an Unbounded dictionary, # then the original dictionary is Infeasible if status == Dictionary.UNBOUNDED: self.statuscode = Dictionary.INFEASIBLECODE self.status = Dictionary.INFEASIBLE return self else: # mount the primal dictionary from the optmized dual if DEBUG: print("Dual After Initialization Phase") print(dualOptmized) # first, get the raw primal primalDictionary = dualOptmized.dual() if DEBUG: print("Primal Dictionary After Initialization") print(primalDictionary) # second, change the objective function to the original objective A_aux = primalDictionary._getAuxMatrix() C_aux = map(lambda x: mp.mpf(str(x)), np.zeros(len(self.c)+1)) # compute the new value of the C vector according to the original objective function (original c vector) for i in range(len(self.nonBasicIdx)): idx_aux = np.nonzero(primalDictionary.basicIdx == self.nonBasicIdx[i])[0] # if the variable is one of the basic variables of the primal, # then add the associated row times the coefficient in the original dictionary if len(idx_aux) > 0: idx_aux = idx_aux[0] C_aux += self.c[i]*A_aux[idx_aux, :] else: # if the variable is one of the non basic variables of the primal, # then add the coefficient in the original dictionary to the related column in the primal idx_aux = np.nonzero(primalDictionary.nonBasicIdx == self.nonBasicIdx[i])[0] if len(idx_aux) > 0: idx_aux = idx_aux[0] C_aux[idx_aux+1] += self.c[i] # index shifted by +1 because of the Z value primalDictionary.z = C_aux[0] primalDictionary.c = C_aux[1:primalDictionary.n+1] primalDictionary.status = Dictionary.STANDARD if DEBUG: print("Primal Dictionary After Initialization with Original Objective") print(primalDictionary) return primalDictionary
print('Match file:', opt_file) matches = pickle.load(open(opt_file, "rb")) elif os.path.isfile(source_file): print('Match file:', source_file) matches = pickle.load(open(source_file, "rb")) else: print("Cannot find a matches file to load... aborting") quit() print('Match features:', len(matches)) # load the group connections within the image set groups = Groups.load(args.project) print('Main group size:', len(groups[0])) opt = Optimizer.Optimizer(args.project) opt.setup(proj, groups[0], matches, optimized=args.refine) cameras, features, cam_index_map, feat_index_map, fx_opt, fy_opt, cu_opt, cv_opt, distCoeffs_opt = opt.run( ) # mark all the optimized poses as invalid for image in proj.image_list: opt_cam_node = image.node.getChild('camera_pose_opt', True) opt_cam_node.setBool('valid', False) for i, cam in enumerate(cameras): image_index = cam_index_map[i] image = proj.image_list[image_index] ned_orig, ypr_orig, quat_orig = image.get_camera_pose() print('optimized cam:', cam) rvec = cam[0:3]
# driver_logisticregression.py import LRegression import example_classification import matplotlib.pyplot as plt import numpy as np import Optimizer import plot_results # (1) Set up data nfeature = 2 m = 1000 case = "linear" nclass = 2 X, Y = example_classification.example(nfeature, m, case, nclass) # (2) Define model lamb = 0.01 model = LRegression.LRegression(nfeature, "sigmoid", lamb) # (3) Compile model optimizer = Optimizer.GradientDescent(0.5) model.compile("binarycrossentropy", optimizer) # (4) Train model epochs = 100 history = model.fit(X, Y, epochs) # (5) Results # plot loss and accuracy plot_results.plot_results_history(history, ["loss"]) plot_results.plot_results_history(history, ["accuracy"]) # plot heatmap in x0-x1 plane plot_results.plot_results_classification((X, Y), model, nclass) plt.show()
# Change random seed to get different random numbers: seed (integer) # Change number of training data samples: ntrain up to 60000 # Change number of validation data samples: nvalid up to 10000 # Change learning rate for optimization: learning_rate >0 # Change number of iterations: niterations seed = 10 ntrain = 6000 nvalid = 1000 learning_rate = 0.02 niteration = 40 # (1) Set up data nclass = 10 Xtrain, Ytrain, Xvalid, Yvalid = load_mnist.load_mnist(ntrain, nvalid) # (2) Define model nfeature = Xtrain.shape[0] np.random.seed(seed) model = NeuralNetwork.NeuralNetwork(nfeature) model.add_layer(128, "relu") model.add_layer(nclass, "softmax") # (3) Compile model optimizer = Optimizer.Adam(learning_rate, 0.9, 0.999, 1e-7) model.compile("crossentropy", optimizer) model.summary() # (4) Train model history = model.fit(Xtrain, Ytrain, niteration) # (5) Predictions and plotting # plot data, loss, and animation of results Yvalid_pred = model.predict(Xvalid) plot_results.plot_data_mnist(Xtrain, Ytrain) plot_results.plot_results_history(history, ["loss"]) plot_results.plot_results_mnist_animation(Xvalid, Yvalid, Yvalid_pred, 25)
def main(argv): separator = ' ' # read m(# of constraints) and n(# of variables) m, n = toInt(readLine(sys.stdin, separator)) if DEBUG: sys.stderr.write(str(m)+"\n") sys.stderr.write(str(n)+"\n") # read the list of basic indices basicIdx = toInt(readLine(sys.stdin, separator)) if DEBUG: sys.stderr.write(str(basicIdx)+"\n") # read the list of non-basic indices nonBasicIdx = toInt(readLine(sys.stdin, separator)) if DEBUG: sys.stderr.write(str(nonBasicIdx)+"\n") # read the list of values for the basic indices (at the same order they are declared) # remember: Ax <= b, b is the list being read basicValues = toFloat(readLine(sys.stdin, separator)) if DEBUG: sys.stderr.write(str(basicValues)+"\n") # read the matrix A (from problem Ax <= b) coeffMatrix = [] for i in range(m): row = toFloat(readLine(sys.stdin, separator)) coeffMatrix.append(row) coeffMatrix = np.array(coeffMatrix) if DEBUG: sys.stderr.write(str(coeffMatrix)+"\n") # read the current objective value and the current objective row coefficients coeffObjs = toFloat(readLine(sys.stdin, separator)) z = coeffObjs[0] coeffObj = coeffObjs[1:] dictionary = Dictionary(m, n, basicIdx, nonBasicIdx, basicValues, coeffMatrix, coeffObj, z) if DEBUG: sys.stderr.write("Original Dictionary\n") sys.stderr.write(str(dictionary)+"\n") opt = Optimizer() cuts, optmizedDict, status = opt.solveIntegerLinearProgrammingWithCuttingPlane(dictionary) if DEBUG: sys.stderr.write("Ootimized Dictionary\n") sys.stderr.write(str(dictionary)+"\n") #sys.stdout.flush() if status == Dictionary.INFEASIBLE: print(status) elif status == Dictionary.UNBOUNDED: print(status) else: print "%.6f" % optmizedDict.z
'/home/philipp/alzheimers/neurodegeneration-forecast/Network_Data/Control/Average/adj_threshold_6') from openpyxl import load_workbook wb = load_workbook( '/home/philipp/alzheimers/neurodegeneration-forecast/Neurodeg_Data_SUVR/SUVRs_New_Atlas_Modeling.xlsx') ws = wb['SUVRs_New_Atlas'] concentrations = np.array([[i.value for i in j] for j in ws['B2':'UZ21']]) concentrations = concentrations[np.argsort(np.sum(concentrations, axis=1))] # params = {"lowerInit": 0.3, # "upperInit": 0.6} # 2149.3 # params = {'ConcentrationLinear': 2.6920626035910398, 'ProductionConstant': 0.7433074157266951, 'ConcentrationSigmoidA': 3.166102288632473, 'ConcentrationSigmoidB': 0.6100809472161937, 'ConcentrationSigmoidC': 7.449624824119648, 'WD-LinearA': 0.35120110860618303, 'WD-SigmoidA': 4.39411213859124, 'WD-SigmoidB': 7.652702177481957, 'WD-SigmoidC': 1.5091546379416079, 'lowerInit': 1.005106421821866, 'upperInit': 1.2086002841534664} #2052.006795851523 #params = {'lowerInit': 0.8, 'upperInit': 1.0} params = {'ConcentrationLinear': 0.07, 'ProductionConstant': 0.01, 'ConcentrationSigmoidA': 1.0, 'ConcentrationSigmoidB': 1.0, 'ConcentrationSigmoidC': 2, 'WD-LinearA': 0.05, 'WD-SigmoidA': 0.1, 'WD-SigmoidB': 0.8194874373805783, 'WD-SigmoidC': 5, 'lowerInit': 0.9, 'upperInit': 1.20} bsm = BrainsphereModel.BrainsphereModel(connectivity, concentrations, params=params, euclideanAdjacency=adjacency) import Optimizer o = Optimizer.Optimizer(bsm) o.optimize() # import timeit # print(timeit.timeit('bsm.gradient()',number=10,globals=globals())) # 96.5 # print(timeit.timeit('bsm.gradient4()',number=10,globals=globals())) # 99.0 # print(bsm.gradient4())
output_file = args['--output'] ast = None try: with open(input_file, 'r') as f: Parser.build("Program") source = f.read() ast = Parser.parse(source) except IOError: print 'Error opening file %s. Please check the file or ' \ 'the directory.' % input_file sys.exit(1) if ast is None: error_list = list(Parser.error_list.keys()) error_list.sort() for key in error_list: sys.stdout.write(Parser.error_list[key]) sys.stdout.flush() sys.exit(-1) if args['-O']: ast = Optimizer.optimize(ast) try: with open(output_file, 'w') as f: f.write(Generator.generate(ast)) except IOError: print 'Error writing to file %s. Please check the file or ' \ 'the directory.' % output_file sys.exit(1)