def evaluate_model(NNInput): datasets, datasetsTry, G_MEAN, G_SD, RDataOrig, yDataOrig, yDataDiatOrig = load_data(NNInput) if (NNInput.Model=='ModPIP') or (NNInput.Model=='PIP'): NNInput.NLayers = NNInput.NHid NNInput.NLayers.insert(0,NNInput.NIn) NNInput.NLayers.append(NNInput.NOut) InputVar = T.dmatrix('Inputs') Layers = create_nn(NNInput, InputVar, 1, G_MEAN, G_SD) if (NNInput.TryNNFlg > 0): i=-1 for Ang in NNInput.AngVector: i=i+1 RSetTry, GSetTry, ySetTry, ySetTryDiat, ySetTryTriat = datasetsTry[i] if (NNInput.Model == 'ModPIP') or (NNInput.Model == 'ModPIPPol'): xSetTry = RSetTry elif (NNInput.Model == 'PIP'): xSetTry = GSetTry NTry = xSetTry.get_value(borrow=True).shape[0] NBatchTry = NTry // NNInput.NMiniBatch yPredTry = lasagne.layers.get_output(Layers[-1], inputs=xSetTry) PathToTryLabels = NNInput.PathToOutputFldr + '/REBestDet.csv.' + str(Ang) yPredTry = T.cast(yPredTry, 'float64') yPredTry = yPredTry.eval() yPredTry = InverseTransformation(NNInput, yPredTry, ySetTryDiat.get_value()) ySetTry = T.cast(ySetTry, 'float64') ySetTry = ySetTry.eval() ySetTry = InverseTransformation(NNInput, ySetTry, ySetTryDiat.get_value()) save_to_plot(PathToTryLabels, 'Evaluated', numpy.concatenate((RSetTry.get_value(), ySetTry, yPredTry), axis=1)) for iLayer in range(len(NNInput.NLayers)-1): PathToFldr = NNInput.PathToOutputFldr + Layers[iLayer].name + '/' if not os.path.exists(PathToFldr): os.makedirs(PathToFldr) if (NNInput.Model == 'ModPIP'): if (iLayer == 0) and (NNInput.BondOrderStr != 'DiatPotFun'): save_parameters_PIP(PathToFldr, Layers[iLayer].Lambda.get_value(), Layers[iLayer].re.get_value()) elif (iLayer > 1): if (NNInput.BiasesFlg): save_parameters(PathToFldr, Layers[iLayer].W.get_value(), Layers[iLayer].b.get_value()) else: save_parameters_NoBiases(PathToFldr, Layers[iLayer].W.get_value()) elif (NNInput.Model == 'ModPIPPol'): if (iLayer == 0) and (NNInput.BondOrderStr != 'DiatPotFun'): save_parameters_PIP(PathToFldr, Layers[iLayer].Lambda.get_value(), Layers[iLayer].re.get_value()) elif (iLayer==1): save_parameters_NoBiases(PathToFldr, Layers[iLayer].W.get_value()) elif (NNInput.Model == 'PIP'): if (NNInput.BiasesFlg): save_parameters(PathToFldr, Layers[iLayer].W.get_value(), Layers[iLayer].b.get_value()) else: save_parameters_NoBiases(PathToFldr, Layers[iLayer].W.get_value()) compute_cuts(NNInput, NNInput.AnglesCuts, NNInput.RCuts, Layers, G_MEAN, G_SD)
def evaluation(model, supervisor, num_label): teX, teY, num_te_batch = load_data(cfg.dataset, cfg.batch_size, is_training=False) fd_test_acc = save_to() with supervisor.managed_session(config=tf.ConfigProto( allow_soft_placement=True)) as sess: supervisor.saver.restore(sess, tf.train.latest_checkpoint(cfg.logdir)) tf.logging.info('Model restored!') test_acc = 0 prob = np.zeros((num_te_batch * cfg.batch_size, num_label)) for i in tqdm(range(num_te_batch), total=num_te_batch, ncols=70, leave=False, unit='b'): start = i * cfg.batch_size end = start + cfg.batch_size acc, prob[start:end, :] = sess.run( [model.accuracy, model.activation], { model.X: teX[start:end], model.labels: teY[start:end] }) test_acc += acc test_acc = test_acc / (cfg.batch_size * num_te_batch) np.savetxt(cfg.results + '/prob_test.txt', prob, fmt='%1.2f') print( 'Classification probability for each category has been saved to ' + cfg.results + '/prob_test.txt') fd_test_acc.write(str(test_acc)) fd_test_acc.close() print('Test accuracy has been saved to ' + cfg.results + '/test_accuracy.txt')
def load(q, y_type): main = load_data( lag_year=5, sql_version=False) # main = entire dataset before standardization/qcut col = main.columns[2:-2] # dfs = sample_from_main(main, y_type=y_type, part=1, q=q) # part=1: i.e. test over entire 150k records # x, y = dfs[0] x, X_test, y, Y_test = sample_from_datacqtr(main, y_type=y_type, testing_period=dt.datetime( 2008, 3, 31), q=q) return x, y
from keras.models import Model, load_model import numpy as np from LoadData import load_data import gc import random from keras.applications.mobilenet import relu6,DepthwiseConv2D import datetime from keras.preprocessing import image gc.collect() import numpy as np from skimage import io, transform, img_as_ubyte import os lst = ['鸟','荷','竹','马','菊','兰','柳','梅','山'] starttime = datetime.datetime.now() X_test, Y_test = load_data('E:\\Qianrushi\\test') image_size=(224, 224) X_test = X_test.astype('float32') X_test /= 255. X_test -= 0.5 X_test *= 2. model = load_model('mobilenet1.hdf5',custom_objects={ 'relu6': relu6, 'DepthwiseConv2D': DepthwiseConv2D}) # model = load_model('finalvgg16.hdf5')
def sgd_optimization(NNInput): """ Demonstrate stochastic gradient descent optimization of a log-linear model :type LearningRate: float :param LearningRate: learning rate used (factor for the stochastic gradient) :type NEpoch: int :param NEpoch: maximal number of epochs to run the optimizer :type PathToData: string :param PathToData: the path of the dataset file """ def normalized_squared_error(a, b, expon): """Computes the element-wise squared normalized difference between two tensors. .. math:: L = ( (p - t) / t )^2 Parameters ---------- a, b : Theano tensor The tensors to compute the squared difference between. Returns ------- Theano tensor An expression for the item-wise squared difference. """ a, b = align_targets(a, b) return T.square((a - b) / T.abs_(b)**expon) # / T.abs_(TargetVar)**(0.0) / T.abs_(b)**expon def weighted_squared_error(a, b, Shift, Power): """Computes the element-wise squared normalized difference between two tensors. .. math:: L = ( (p - t) / t )^2 Parameters ---------- a, b : Theano tensor The tensors to compute the squared difference between. Returns ------- Theano tensor An expression for the item-wise squared difference. """ a, b = align_targets(a, b) Vi = T.maximum(b, Shift) w = T.power(Shift/b, Power) return w * T.square(a - b) # / T.abs_(TargetVar)**(0.0) / T.abs_(b)**expon def align_targets(predictions, targets): """Helper function turning a target 1D vector into a column if needed. This way, combining a network of a single output unit with a target vector works as expected by most users, not broadcasting outputs against targets. Parameters ---------- predictions : Theano tensor Expression for the predictions of a neural network. targets : Theano tensor Expression or variable for corresponding targets. Returns ------- predictions : Theano tensor The predictions unchanged. targets : Theano tensor If `predictions` is a column vector and `targets` is a 1D vector, returns `targets` turned into a column vector. Otherwise, returns `targets` unchanged. """ if (getattr(predictions, 'broadcastable', None) == (False, True) and getattr(targets, 'ndim', None) == 1): targets = as_theano_expression(targets).dimshuffle(0, 'x') return predictions, targets ################################################################################################################################## ### LOADING DATA ################################################################################################################################## print('\nLoading Data ... \n') if (NNInput.TryNNFlg > 0): datasets, datasetsTry, G_MEAN, G_SD, RDataOrig, yDataOrig, yDataDiatOrig = load_data(NNInput) else: datasets, G_MEAN, G_SD, RDataOrig, yDataOrig, yDataDiatOrig = load_data(NNInput) RSetTrain, GSetTrain, ySetTrain, ySetTrainDiat, ySetTrainTriat = datasets[0] RSetValid, GSetValid, ySetValid, ySetValidDiat, ySetValidTriat = datasets[1] #RSetTest, GSetTest, ySetTest, ySetTestDiat, ySetTestTriat = datasets[2] #plot_set(NNInput, RSetTrain.get_value(), ySetTrainDiat.get_value(), RSetValid.get_value(), ySetValidDiat.get_value(), RSetTest.get_value(), ySetTestDiat.get_value()) NNInput.NIn = RSetTrain.get_value(borrow=True).shape[1] NNInput.NOut = ySetTrain.get_value(borrow=True).shape[1] print((' Nb of Input: %i') % NNInput.NIn) print((' Nb of Output: %i \n') % NNInput.NOut) if (NNInput.Model=='ModPIP') or (NNInput.Model=='PIP'): NNInput.NLayers = NNInput.NHid NNInput.NLayers.insert(0,NNInput.NIn) NNInput.NLayers.append(NNInput.NOut) NTrain = RSetTrain.get_value(borrow=True).shape[0] NBatchTrain = NTrain // NNInput.NMiniBatch NValid = RSetValid.get_value(borrow=True).shape[0] #NTest = RSetTest.get_value(borrow=True).shape[0] print((' Nb of Training Examples: %i') % NTrain) print((' Nb of Training Batches: %i') % NBatchTrain) print((' Nb of Validation Examples: %i') % NValid) #print((' Nb of Test Examples: %i \n') % NTest) ###################### # BUILD ACTUAL MODEL # ###################### InputVar = T.dmatrix('Inputs') #InputVar.tag.test_value = numpy.random.randint(100,size=(100,3)) InputVar.tag.test_value = numpy.array([[1.0,2.0,7.0],[3.0,5.0,11.0]]) * 0.529177 TargetVar = T.dmatrix('Targets') #TargetVar.tag.test_value = numpy.random.randint(100,size=(100,1)) Layers = create_nn(NNInput, InputVar, TargetVar) TrainPrediction = lasagne.layers.get_output(Layers[-1]) if (NNInput.LossFunction == 'squared_error'): TrainError = T.sqr(TrainPrediction - TargetVar) TrainLoss = lasagne.objectives.squared_error(TrainPrediction, TargetVar) elif (NNInput.LossFunction == 'normalized_squared_error'): TrainError = T.abs_( (TrainPrediction - TargetVar) / T.abs_(TargetVar)**NNInput.OutputExpon) TrainLoss = normalized_squared_error(TrainPrediction, TargetVar, NNInput.OutputExpon) elif (NNInput.LossFunction == 'huber_loss'): TrainError = T.abs_( (TrainPrediction - TargetVar) ) TrainLoss = lasagne.objectives.huber_loss(TrainPrediction, TargetVar, delta=5) elif (NNInput.LossFunction == 'weighted_squared_error'): TrainError = T.abs_( (TrainPrediction - TargetVar) ) TrainLoss = weighted_squared_error(TrainPrediction, TargetVar, NNInput.Shift, NNInput.Power) if (NNInput.Model == 'ModPIP'): LayersK = {Layers[2]: 1.0, Layers[3]: 1.0} elif (NNInput.Model=='ModPIPPol'): LayersK = {Layers[1]: 1.0} elif (NNInput.Model=='PIP'): LayersK = {Layers[0]: 1.0, Layers[1]: 1} L2Penalty = regularize_layer_params_weighted(LayersK, l2) L1Penalty = regularize_layer_params_weighted(LayersK, l1) #TrainLoss = TrainLoss TrainLoss = TrainLoss.mean() + NNInput.kWeightDecay[0] * L1Penalty + NNInput.kWeightDecay[1] * L2Penalty params = lasagne.layers.get_all_params(Layers[-1], trainable=True) if (NNInput.Method == 'nesterov'): updates = lasagne.updates.nesterov_momentum(TrainLoss, params, learning_rate=NNInput.LearningRate, momentum=NNInput.kMomentum) elif (NNInput.Method == 'rmsprop'): updates = lasagne.updates.rmsprop(TrainLoss, params, learning_rate=NNInput.LearningRate, rho=NNInput.RMSProp[0], epsilon=1e-06) elif (NNInput.Method == 'adamax'): updates = lasagne.updates.adamax(TrainLoss, params, learning_rate=NNInput.LearningRate, beta1=0.9, beta2=0.999, epsilon=1e-08) elif (NNInput.Method == 'amsgrad'): updates = lasagne.updates.amsgrad(TrainLoss, params, learning_rate=NNInput.LearningRate, beta1=0.9, beta2=0.999, epsilon=1e-08) elif (NNInput.Method == 'adam'): updates = lasagne.updates.adam(TrainLoss, params, learning_rate=NNInput.LearningRate, beta1=0.9, beta2=0.999, epsilon=1e-08) elif (NNInput.Method == 'adadelta'): updates = lasagne.updates.adadelta(TrainLoss, params, learning_rate=NNInput.LearningRate, rho=0.95, epsilon=1e-08) TrainFn = theano.function(inputs=[InputVar, TargetVar], outputs=[TrainError, TrainLoss], updates=updates) ValidPrediction = lasagne.layers.get_output(Layers[-1], deterministic=True) if (NNInput.LossFunction == 'squared_error'): ValidError = T.sqr(ValidPrediction - TargetVar) elif (NNInput.LossFunction == 'normalized_squared_error'): ValidError = T.sqr((ValidPrediction - TargetVar) / TargetVar) ValidError = T.sqrt(ValidError.mean()) elif (NNInput.LossFunction == 'huber_loss'): ValidError = T.sqr(ValidPrediction - TargetVar) ValidError = T.sqrt(ValidError.mean()) elif (NNInput.LossFunction == 'weighted_squared_error'): Vi = T.maximum(ValidPrediction, NNInput.Shift) w = T.power(NNInput.Shift/TargetVar, NNInput.Power) ValidError = w * T.sqr(ValidPrediction - TargetVar) ValidError = T.sqrt(ValidError.mean()) ValFn = theano.function(inputs=[InputVar, TargetVar], outputs=ValidError) ############### # TRAIN MODEL # ############### print('\n\nTRAINING ... ') if (NNInput.fvalid < 0): fValid = NBatchTrain * numpy.absolute(NNInput.fvalid) else: fValid = NNInput.fvalid BestValidError = numpy.inf BestIter = 0 TestScore = 0. tStart = timeit.default_timer() iEpoch = 0 LoopingFlg = True iIterTot = 0 Train = [] TrainEpochVec = [] Valid = [] ValidEpochVec = [] iTry = 0 if (NNInput.Model=='ModPIP') or (NNInput.Model == 'ModPIPPol'): xSetTrain = RSetTrain xSetValid = RSetValid #xSetTest = RSetTest xDataOrig = RDataOrig elif (NNInput.Model == 'PIP'): xSetTrain = GSetTrain xSetValid = GSetValid #xSetTest = GSetTest #xDataOrig = GDataOrig # print(xSetTrain) # print(xSetValid) # print(xSetTest) # print(xDataOrig) # print(ySetTrain.get_value()) # print(ySetValid.get_value()) # print(ySetTest.get_value()) # print(yDataOrig) # time.sleep(5) ThisTrainError = 0.0 while (iEpoch < NNInput.NEpoch) and (LoopingFlg): iEpoch += 1 iMiniBatch = 0 TrainErrorVec = [] for TrainBatch in iterate_minibatches(xSetTrain, ySetTrain, NNInput.NMiniBatch, shuffle=True): iMiniBatch += 1 iIterTot = (iEpoch - 1) * NBatchTrain + iMiniBatch TrainInputs, TrainTargets = TrainBatch [TrainErrorTemp, MiniBatchAvgCost] = TrainFn(TrainInputs, TrainTargets) TrainErrorVec = numpy.append(TrainErrorVec, TrainErrorTemp) if (iIterTot + 1) % fValid == 0: ValidErorrVec = [] for ValidBatch in iterate_minibatches(xSetValid, ySetValid, NValid, shuffle=False): ValidInputs, ValidTargets = ValidBatch ValidErorrVec = numpy.append(ValidErorrVec, ValFn(ValidInputs, ValidTargets)) ThisValidError = numpy.sqrt( numpy.mean(ValidErorrVec) ) ValidEpochVec = numpy.append(ValidEpochVec, iEpoch) Valid = numpy.append(Valid, ThisValidError) # fig = plt.figure() # plt.plot(ValidErorrVec, color='lightblue', linewidth=3) # #ax.set_xlim(,) # plt.show() print( '\n iEpoch %i, minibatch %i/%i, training error %f, validation error %f' % (iEpoch, iMiniBatch + 1, NBatchTrain, ThisTrainError, ThisValidError) ) # if we got the best validation score until now if ThisValidError < BestValidError: #improve patience if loss improvement is good enough #if (ThisValidError < BestValidError * NNInput.ImpThold): # NNInput.NPatience = max(NNInput.NPatience, iIterTot * NNInput.NDeltaPatience) BestValidError = ThisValidError BestIter = iIterTot # # test it on the test set # TestErrorVec = [] # for TestBatch in iterate_minibatches(xSetTest, ySetTest, NTest, shuffle=False): # TestInputs, TestTargets = TestBatch # TestErrorVec = numpy.append(TestErrorVec, ValFn(TestInputs, TestTargets)) # TestScore = numpy.mean(TestErrorVec) # print((' iEpoch %i, minibatch %i/%i, test error of best model %f') % (iEpoch, iMiniBatch + 1, NBatchTrain, TestScore)) print(' iEpoch %i, minibatch %i/%i, Best so far') if (NNInput.WriteFinalFlg > 0): for iLayer in range(len(NNInput.NLayers)-1): PathToFldr = NNInput.PathToOutputFldr + Layers[iLayer].name + '/' if not os.path.exists(PathToFldr): os.makedirs(PathToFldr) PathToFile = PathToFldr + 'Weights.npz' numpy.savez(PathToFile, *lasagne.layers.get_all_param_values(Layers[iLayer])) if (NNInput.WriteFinalFlg > 1): if (NNInput.Model == 'ModPIP'): if (iLayer == 0) and (NNInput.BondOrderStr != 'DiatPotFun'): save_parameters_PIP(PathToFldr, Layers[iLayer].Lambda.get_value(), Layers[iLayer].re.get_value()) elif (iLayer > 1): if (NNInput.BiasesFlg): save_parameters(PathToFldr, Layers[iLayer].W.get_value(), Layers[iLayer].b.get_value()) else: save_parameters_NoBiases(PathToFldr, Layers[iLayer].W.get_value()) elif (NNInput.Model == 'ModPIPPol'): if (iLayer == 0) and (NNInput.BondOrderStr != 'DiatPotFun'): save_parameters_PIP(PathToFldr, Layers[iLayer].Lambda.get_value(), Layers[iLayer].re.get_value()) elif (iLayer==1): save_parameters_NoBiases(PathToFldr, Layers[iLayer].W.get_value()) elif (NNInput.Model == 'PIP'): if (NNInput.BiasesFlg): save_parameters(PathToFldr, Layers[iLayer].W.get_value(), Layers[iLayer].b.get_value()) else: save_parameters_NoBiases(PathToFldr, Layers[iLayer].W.get_value()) if (NNInput.TryNNFlg > 1): i=-1 for Ang in NNInput.AngVector: i=i+1 iTry=iTry+1 RSetTry, GSetTry, ySetTry, ySetTryDiat, ySetTryTriat = datasetsTry[i] if (NNInput.Model == 'ModPIP') or (NNInput.Model == 'ModPIPPol'): xSetTry = RSetTry elif (NNInput.Model == 'PIP'): xSetTry = GSetTry NTry = xSetTry.get_value(borrow=True).shape[0] NBatchTry = NTry // NNInput.NMiniBatch yPredTry = lasagne.layers.get_output(Layers[-1], inputs=xSetTry) if (NNInput.TryNNFlg > 2): PathToTryLabels = NNInput.PathToOutputFldr + '/REBestDet.csv.' + str(iTry) else: PathToTryLabels = NNInput.PathToOutputFldr + '/REBestDet.csv.' + str(Ang) yPredTry = T.cast(yPredTry, 'float64') yPredTry = yPredTry.eval() yPredTry = InverseTransformation(NNInput, yPredTry, ySetTryDiat.get_value()) ySetTry = T.cast(ySetTry, 'float64') ySetTry = ySetTry.eval() ySetTry = InverseTransformation(NNInput, ySetTry, ySetTryDiat.get_value()) save_to_plot(PathToTryLabels, 'Evaluated', numpy.concatenate((RSetTry.get_value(), ySetTry, yPredTry), axis=1)) TrainEpochVec = numpy.append(TrainEpochVec, iEpoch) ThisTrainError = numpy.sqrt( numpy.mean(TrainErrorVec) ) Train = numpy.append(Train, ThisTrainError) ############################################################################################################# ### LOADING THE OPTIMAL PARAMETERS for iLayer in range(len(NNInput.NLayers)-1): PathToFldr = NNInput.PathToWeightFldr + Layers[iLayer].name + '/' print(' Loading Parameters for Layer ', iLayer, ' from File ', PathToFldr) if (NNInput.Model == 'ModPIP'): if (iLayer == 0) and (NNInput.BondOrderStr != 'DiatPotFun'): save_parameters_PIP(PathToFldr, Layers[iLayer].Lambda.get_value(), Layers[iLayer].re.get_value()) elif (iLayer > 1): if (NNInput.BiasesFlg): save_parameters(PathToFldr, Layers[iLayer].W.get_value(), Layers[iLayer].b.get_value()) else: save_parameters_NoBiases(PathToFldr, Layers[iLayer].W.get_value()) elif (NNInput.Model == 'ModPIPPol'): if (iLayer == 0) and (NNInput.BondOrderStr != 'DiatPotFun'): save_parameters_PIP(PathToFldr, Layers[iLayer].Lambda.get_value(), Layers[iLayer].re.get_value()) elif (iLayer==1): save_parameters_NoBiases(PathToFldr, Layers[iLayer].W.get_value()) elif (NNInput.Model == 'PIP'): save_parameters(PathToFldr, Layers[iLayer].W.get_value(), Layers[iLayer].b.get_value()) ############################################################################################################# ### Evaluating Model for a Particular Data-Set if (NNInput.TryNNFlg > 0): i=-1 for Ang in NNInput.AngVector: i=i+1 RSetTry, GSetTry, ySetTry, ySetTryDiat, ySetTryTriat = datasetsTry[i] if (NNInput.Model == 'ModPIP') or (NNInput.Model == 'ModPIPPol'): xSetTry = RSetTry elif (NNInput.Model == 'PIP'): xSetTry = GSetTry NTry = xSetTry.get_value(borrow=True).shape[0] NBatchTry = NTry // NNInput.NMiniBatch yPredTry = lasagne.layers.get_output(Layers[-1], inputs=xSetTry) PathToTryLabels = NNInput.PathToOutputFldr + '/REBestDet.csv.' + str(Ang) yPredTry = T.cast(yPredTry, 'float64') yPredTry = yPredTry.eval() yPredTry = InverseTransformation(NNInput, yPredTry, ySetTryDiat.get_value()) ySetTry = T.cast(ySetTry, 'float64') ySetTry = ySetTry.eval() ySetTry = InverseTransformation(NNInput, ySetTry, ySetTryDiat.get_value()) save_to_plot(PathToTryLabels, 'Evaluated', numpy.concatenate((RSetTry.get_value(), ySetTry, yPredTry), axis=1)) ############################################################################################################# ### COMPUTING ERRORS ySetTrain = InverseTransformation(NNInput, ySetTrain.get_value(), ySetTrainDiat.get_value()) ySetValid = InverseTransformation(NNInput, ySetValid.get_value(), ySetValidDiat.get_value()) #ySetTest = InverseTransformation(NNInput, ySetTest.get_value(), ySetTestDiat.get_value()) yPredTrain = lasagne.layers.get_output(Layers[-1], inputs=xSetTrain) yPredTrain = T.cast(yPredTrain, 'float64') yPredTrain = yPredTrain.eval() yPredTrain = InverseTransformation(NNInput, yPredTrain, ySetTrainDiat.get_value()) error_Train = ySetTrain - yPredTrain plot_error(NNInput, error_Train, 'Train') yPredValid = lasagne.layers.get_output(Layers[-1], inputs=xSetValid) yPredValid = T.cast(yPredValid, 'float64') yPredValid = yPredValid.eval() yPredValid = InverseTransformation(NNInput, yPredValid, ySetValidDiat.get_value()) error_Valid = ySetValid - yPredValid plot_error(NNInput, error_Valid, 'Valid') # yPredTest = lasagne.layers.get_output(Layers[-1], inputs=xSetTest) # yPredTest = T.cast(yPredTest, 'float64') # yPredTest = yPredTest.eval() # yPredTest = InverseTransformation(NNInput, yPredTest, ySetTestDiat.get_value()) # error_Test = ySetTest - yPredTest # plot_error(NNInput, error_Test, 'Test') # plot_set(NNInput, RSetTrain.get_value(), ySetTrain, RSetValid.get_value(), ySetValid, RSetTest.get_value(), ySetTest) yPredOrig = lasagne.layers.get_output(Layers[-1], inputs=xDataOrig) yPredOrig = T.cast(yPredOrig, 'float64') yPredOrig = yPredOrig.eval() yPredOrig = InverseTransformation(NNInput, yPredOrig, yDataDiatOrig) plot_scatter(NNInput, yPredOrig, yDataOrig) #plot_overall_error(NNInput, yPredOrig, yDataOrig) plot_history(NNInput, TrainEpochVec, Train, ValidEpochVec, Valid) tEnd = timeit.default_timer() print(('\nOptimization complete. Best validation score of %f obtained at iteration %i, with test performance %f') % (BestValidError, BestIter + 1, TestScore)) print(('\nThe code for file ' + os.path.split(__file__)[1] + ' ran for %.2fm' % ((tEnd - tStart) / 60.)), file=sys.stderr)
from jmodel.util import * from jmodel.Optimizers.BiascOptimizer import * from jmodel.Models.Rnnlm import * from jmodel.Trainers.RnnTrainer import * # 設定超參數 batch_size = 32 wordvec_size = 100 hidden_size = 100 # RNN隱藏狀態向量的元素數 time_size = 35 # 展開RNN的大小 lr = 20.0 max_epoch = 4 max_grad = 0.25 # 載入學習資料 corpus, word_to_id, id_to_word = load_data("ptb.train.txt") # corpus = corpus[] vocab_size = len(word_to_id) xs = corpus[:-1] ts = corpus[1:] # 產生模型 model = Rnnlm(vocab_size, wordvec_size, hidden_size) optimizer = SGD(lr) trainer = RnnlmTrainer(model, optimizer) # 套用梯度裁減並學習 trainer.fit(xs, ts, max_epoch, batch_size,
from LoadData import load_data from Pca import pca import numpy as np import matplotlib.pyplot as plt import matplotlib.lines as mlines if __name__ == '__main__': Path = 'iris.data' X, Y = load_data(Path) K = 2 #将数据降维为2维 finaldata = pca(X, K) #分别存储不同类别的鸢尾花降维后的数据 red_x = [] red_y = [] blue_x = [] blue_y = [] green_x = [] green_y = [] finaldata = np.array(finaldata) #将矩阵转化为数组,便于索引 for i in range(0,finaldata.shape[0]): #按行遍历 if Y[i] == 0: red_x.append(finaldata[i][0]) red_y.append(finaldata[i][1])
def train(model, supervisor, num_label): trX, trY, num_tr_batch, valX, valY, num_val_batch = load_data( cfg.dataset, cfg.batch_size, is_training=True) Y = valY[:num_val_batch * cfg.batch_size].reshape((-1, 1)) fd_train_acc, fd_loss, fd_val_acc = save_to() config = tf.ConfigProto() config.gpu_options.allow_growth = True with supervisor.managed_session(config=config) as sess: print("\nNote: all of results will be saved to directory: " + cfg.results) for epoch in range(cfg.epoch): sys.stdout.write('Training for epoch ' + str(epoch) + '/' + str(cfg.epoch) + ':') sys.stdout.flush() if supervisor.should_stop(): print('supervisor stoped!') break for step in tqdm(range(num_tr_batch), total=num_tr_batch, ncols=70, leave=False, unit='b'): start = step * cfg.batch_size end = start + cfg.batch_size global_step = epoch * num_tr_batch + step if global_step % cfg.train_sum_freq == 0: _, loss, train_acc, summary_str = sess.run([ model.train_op, model.loss, model.accuracy, model.train_summary ]) supervisor.summary_writer.add_summary( summary_str, global_step) fd_loss.write(str(global_step) + ',' + str(loss) + "\n") fd_loss.flush() fd_train_acc.write( str(global_step) + ',' + str(train_acc / cfg.batch_size) + "\n") fd_train_acc.flush() else: sess.run(model.train_op) if cfg.val_sum_freq != 0 and global_step % cfg.val_sum_freq == 0: val_acc = 0 prob = np.zeros( (num_val_batch * cfg.batch_size, num_label)) for i in range(num_val_batch): start = i * cfg.batch_size end = start + cfg.batch_size acc, prob[start:end, :] = sess.run( [model.accuracy, model.activation], { model.X: valX[start:end], model.labels: valY[start:end] }) val_acc += acc val_acc = val_acc / (cfg.batch_size * num_val_batch) np.savetxt(cfg.results + '/activations_step_' + str(global_step) + '.txt', np.hstack((prob, Y)), fmt='%1.2f') fd_val_acc.write( str(global_step) + ',' + str(val_acc) + '\n') fd_val_acc.flush() if (epoch + 1) % cfg.save_freq == 0: supervisor.saver.save( sess, cfg.logdir + '/model_epoch_%04d_step_%02d' % (epoch, global_step)) fd_val_acc.close() fd_train_acc.close() fd_loss.close()
def sgd_optimization(NNInput): RandomSeed = 42 set_tt_rng(MRG_RandomStreams(RandomSeed)) NSigmaSamples = 1000 SigmaIntCoeff = 2 ################################################################################################################################## ### LOADING DATA ################################################################################################################################## print('\nLoading Data ... \n') if (NNInput.TryNNFlg): datasets, datasetsPlot, RDataOrig, yDataOrig, yDataDiatOrig = load_data( NNInput) else: datasets, RDataOrig, yDataOrig, yDataDiatOrig = load_data(NNInput) RSetTrain, ySetTrain, ySetTrainDiat, ySetTrainTriat = datasets[0] RSetPlot, ySetPlot, ySetPlotDiat, ySetPlotTriat = datasetsPlot[0] RSetPlotTemp = RSetPlot #NNInput.NIn = xSetTrain.get_value(borrow=True).shape[1] NNInput.NOut = ySetTrain.get_value(borrow=True).shape[1] print((' Nb of Input: %i') % NNInput.NIn) print((' Nb of Output: %i \n') % NNInput.NOut) NNInput.NLayers = NNInput.NHid NNInput.NLayers.insert(0, NNInput.NIn) NNInput.NLayers.append(NNInput.NOut) NNInput.NTrain = RSetTrain.get_value(borrow=True).shape[0] print((' Nb of Training Examples: %i') % NNInput.NTrain) # compute number of minibatches for training, validation and testing if (NNInput.NMiniBatch != 0): NNInput.NBatchTrain = NNInput.NTrain // NNInput.NMiniBatch print((' Nb of Training Batches: %i') % NNInput.NBatchTrain) else: print(' No-BATCH Version') ############################################################################################## ### TESTING REAL PARAMETERS ################################################################## if (NNInput.ReadIniParamsFlg): if (NNInput.Model == 'PIP'): LambdaVec = NNInput.LambdaVec reVec = NNInput.reVec WIni = [ load_parameters(NNInput.PathToWeightFldr + NNInput.LayersName[iLayer] + '/')[0] for iLayer in range(1, len(NNInput.LayersName)) ] bIni = [ load_parameters(NNInput.PathToWeightFldr + NNInput.LayersName[iLayer] + '/')[1] for iLayer in range(1, len(NNInput.LayersName)) ] if (NNInput.Model == 'ModPIP'): LambdaIni = load_parameters_PIP(NNInput.PathToWeightFldr + NNInput.LayersName[1] + '/')[0] reIni = load_parameters_PIP(NNInput.PathToWeightFldr + NNInput.LayersName[1] + '/')[1] LambdaVec = numpy.array([1.0, 1.0, 1.0]) * LambdaIni reVec = numpy.array([1.0, 1.0, 1.0]) * reIni #print('Lambda = ', LambdaVec) #print('re = ', reVec) WIni = [ load_parameters(NNInput.PathToWeightFldr + NNInput.LayersName[iLayer] + '/')[0] for iLayer in range(3, len(NNInput.LayersName)) ] bIni = [ load_parameters(NNInput.PathToWeightFldr + NNInput.LayersName[iLayer] + '/')[1] for iLayer in range(3, len(NNInput.LayersName)) ] elif (NNInput.Model == 'LEPS'): DeVec = NNInput.DeVec betaVec = NNInput.betaVec reVec = NNInput.reVec k = NNInput.k i = -1 for Ang in NNInput.AngVector: i = i + 1 RSetPlot, ySetPlot, ySetPlotDiat, ySetPlotTriat = datasetsPlot[i] if (NNInput.Model == 'PIP') or (NNInput.Model == 'ModPIP'): yPredInitial = try_model_PIP(NNInput, RSetPlot.get_value(borrow=True), LambdaVec, reVec, WIni, bIni) elif (NNInput.Model == 'LEPS'): yPredInitial = try_model_LEPS(NNInput, RSetPlot.get_value(borrow=True), DeiVec, betaiVec, reiVec, ki) yPredInitial = InverseTransformation(NNInput, yPredInitial, ySetPlotDiat.get_value()) PathToPlotLabels = NNInput.PathToOutputFldr + '/REInitial.csv.' + str( int(numpy.floor(Ang))) ySetPlot = T.cast(ySetPlot, 'float64') ySetPlot = ySetPlot.eval() ySetPlot = InverseTransformation(NNInput, ySetPlot, ySetPlotDiat.get_value()) save_to_plot( PathToPlotLabels, 'Initial', numpy.column_stack( [RSetPlot.get_value(), ySetPlot, yPredInitial])) print(' Initial Evaluation Saved in File: ', PathToPlotLabels, '\n') RSetPlotTemp = RSetPlot ############################################################################################## ################################################################################################################################## # BUILD ACTUAL MODEL # ################################################################################################################################## ### COMPUTING / UPDATING INFERENCE ###################################################################### # print(RSetTrain.get_value()) # print(ySetTrain.get_value()) # time.sleep(5) if (NNInput.TrainFlg): if (NNInput.NMiniBatch > 0): RSetTrainTemp = pymc3.Minibatch(RSetTrain.get_value(), batch_size=NNInput.NMiniBatch, dtype='float64') ySetTrainTemp = pymc3.Minibatch(ySetTrain.get_value(), batch_size=NNInput.NMiniBatch, dtype='float64') else: RSetTrainTemp = RSetTrain ySetTrainTemp = ySetTrain NNInput.NMiniBatch = NNInput.NTrain #ADVIApprox, ADVIInference, ADVITracker, SVGDApprox, NUTSTrace, model, yPred, Sigma, Layers = construct_model(NNInput, RSetTrainTemp, ySetTrainTemp, GaussWeightsW, GaussWeightsb) ADVIApprox, ADVIInference, SVGDApprox, NUTSTrace, Params, yPred = construct_model( NNInput, RSetTrain, ySetTrain, RSetTrainTemp, ySetTrainTemp, GaussWeightsW, GaussWeightsb) # plot_ADVI_ELBO(NNInput, ADVIInference) # if (NNInput.SaveInference): PathToModTrace = NNInput.PathToOutputFldr + '/Approx&Preds.pkl' with open(PathToModTrace, 'wb') as buff: #pickle.dump({'model': model, 'trace': ADVITrace, 'tracker': ADVITracker, 'inference': ADVIInference, 'approx': ADVIApprox, 'yLike': yLike}, buff) pickle.dump( { 'ADVIApprox': ADVIApprox, 'Params': Params, 'yPred': yPred }, buff) # else: PathToWeightFldr = NNInput.PathToOutputFldr + '/Model&Trace.pkl' with open(PathToWeightFldr, 'rb') as buff: data = pickle.load(buff) #model, ADVITrace, ADVITracker, ADVIInference, ADVIApprox, yPred = data['model'], data['trace'], data['tracker'], data['inference'], data['approx'], data['yPred'] ADVIApprox, Params, yPred = data['ADVIApprox'], data['Params'], data[ 'yPred'] RSetPlot, ySetPlot, ySetPlotDiat, ySetPlotTriat = datasetsPlot[0] RSetPlotTemp = RSetPlot if (NNInput.NTraceADVI > 0): ADVITrace = ADVIApprox.sample(draws=NNInput.NTraceADVI) plot_ADVI_trace(NNInput, ADVITrace) else: ADVITrace = 1 ############################################################################################## ### SAMPLING PARAMETERS POSTERIOR ####################################################################### PathToADVI = NNInput.PathToOutputFldr + '/ParamsPosts/' if not os.path.exists(PathToADVI): os.makedirs(PathToADVI) if (NNInput.Model == 'PIP') or (NNInput.Model == 'ModPIP'): save_ADVI_reconstruction_PIP(NNInput, PathToADVI, ADVIApprox, Params) save_ADVI_sample_PIP(NNInput, PathToADVI, ADVIApprox, Params) elif (NNInput.Model == 'LEPS'): save_ADVI_reconstruction_LEPS(PathToADVI, ADVIApprox, Params) ############################################################################################## ### RECONSTRUCTING MOMENTS ################################################################### #means = ADVIApprox.bij.rmap(ADVIApprox.mean.eval()) #sds = ADVIApprox.bij.rmap(ADVIApprox.std.eval()) #plot_ADVI_reconstruction(NNInput, means, sds) # PathToADVI = NNInput.PathToOutputFldr + '/ParamsPosts/' # if not os.path.exists(PathToADVI): # os.makedirs(PathToADVI) # save_ADVI_reconstruction(PathToADVI, ADVITrace, model, 0.0, 0.0) ############################################################################################## ### RUNNING NUTS ############################################################################# # xSetTrainTemp = xSetTrain # ySetTrainTemp = ySetTrain # fig = plt.figure() # pymc3.traceplot(NUTSTrace); # plt.show() # FigPath = NNInput.PathToOutputFldr + '/NUTSTrace.png' # fig.savefig(FigPath) # #plt.close() # varnames = means.keys() # fig, axs = plt.subplots(nrows=len(varnames), figsize=(12, 18)) # for var, ax in zip(varnames, axs): # mu_arr = means[var] # sigma_arr = sds[var] # ax.set_title(var) # for i, (mu, sigma) in enumerate(zip(mu_arr.flatten(), sigma_arr.flatten())): # sd3 = (-4*sigma + mu, 4*sigma + mu) # x = numpy.linspace(sd3[0], sd3[1], 300) # y = stats.norm(mu, sigma).pdf(x) # ax.plot(x, y) # if hierarchical_trace[var].ndim > 1: # t = NUTSTrace[var][i] # else: # t = NUTSTrace[var] # sns.distplot(t, kde=False, norm_hist=True, ax=ax) # fig.tight_layout() # plt.show() # FigPath = NNInput.PathToOutputFldr + '/ADVIDistributionsReconstruction.png' # fig.savefig(FigPath) # #plt.close() ############################################################################################## # ## COMPUTING MAX POSTERIOR ################################################################## # map_estimate = pymc3.find_MAP(model=model) # if (NNInput.Model == 'ModPIP'): # LambdaVec = map_estimate.get('Lambda') # reVec = map_estimate.get('re') # WNames = ['W1', 'W2', 'W3'] # WIni = [ map_estimate.get(WNames[iLayer]) for iLayer in range(len(NNInput.LayersName))] # bNames = ['b1', 'b2', 'b3'] # bIni = [ map_estimate.get(bNames[iLayer]) for iLayer in range(len(NNInput.LayersName))] # elif (NNInput.Model == 'PIP'): # LambdaVec = NNInput.reVec # reVec = NNInput.reVec # WNames = ['W1', 'W2', 'W3'] # WIni = [ map_estimate.get(WNames[iLayer]) for iLayer in range(len(NNInput.LayersName))] # bNames = ['b1', 'b2', 'b3'] # bIni = [ map_estimate.get(bNames[iLayer]) for iLayer in range(len(NNInput.LayersName))] # elif (NNInput.Model == 'LEPS'): # DeVec = map_estimate.get('De') # betaVec = map_estimate.get('beta') # reVec = map_estimate.get('re') # k = map_estimate.get('k') # i=-1 # for Ang in NNInput.AngVector: # i=i+1 # xSetTry, ySetTry = datasetsTry[i] # PathToAbscissaToPlot = NNInput.PathToDataFldr + '/R.csv.' + str(Ang) # xPlot = abscissa_to_plot(PathToAbscissaToPlot) # if (NNInput.Model == 'PIP') or (NNInput.Model == 'ModPIP'): # yPredMaxPosterior = try_model_PIP(NNInput, xSetTry.get_value(borrow=True), LambdaVec, reVec, WIni, bIni, IniMean, IniStD) # elif (NNInput.Model == 'LEPS'): # yPredMaxPosterior = try_model_LEPS(NNInput, xSetTry.get_value(borrow=True), DeVec, betaVec, reVec, k) # #print(WIni, bIni) # PathToTryLabels = NNInput.PathToOutputFldr + '/REMaxPosterior.' + str(Ang) + '.csv' # save_to_plot(PathToTryLabels, 'Evaluated', numpy.column_stack([xPlot, yPredMaxPosterior])) # ############################################################################################# ### SAMPLING OUTPUT POSTERIOR ####################################################################### PathToADVI = NNInput.PathToOutputFldr + '/OutputPosts/' if not os.path.exists(PathToADVI): os.makedirs(PathToADVI) x = T.dmatrix('X') n = T.iscalar('n') x.tag.test_value = numpy.empty_like(RSetPlotTemp) x.tag.test_value = numpy.random.randint(100, size=(100, 3)) n.tag.test_value = 100 _sample_proba_yPred = ADVIApprox.sample_node( yPred, size=n, more_replacements={RSetTrainTemp: x}) sample_proba_yPred = theano.function([x, n], _sample_proba_yPred) m = T.iscalar('m') _sample_proba_SigmaPred = ADVIApprox.sample_node(Params.get('Sigma'), size=n * m) sample_proba_SigmaPred = theano.function([n, m], _sample_proba_SigmaPred) SigmaPred = sample_proba_SigmaPred(NNInput.NOutPostSamples, NSigmaSamples) SigmaPred = numpy.reshape(SigmaPred, (NNInput.NOutPostSamples, NSigmaSamples)) i = -1 for Ang in NNInput.AngVector: numpy.random.seed(RandomSeed) pymc3.set_tt_rng(RandomSeed) i = i + 1 RSetPlot, ySetPlot, ySetPlotDiat, ySetPlotTriat = datasetsPlot[i] ySetPlot = T.cast(ySetPlot, 'float64') ySetPlot = ySetPlot.eval() #ySetPlot = InverseTransformation(NNInput, ySetPlot, ySetPlotDiat.get_value()) yPredPlot = sample_proba_yPred(RSetPlot.get_value(borrow=True), NNInput.NOutPostSamples) yPredSum = ySetPlot * 0.0 yPredSumSqr = ySetPlot * 0.0 for j in range(NNInput.NOutPostSamples): yPredTemp = numpy.array(yPredPlot[j, :]) yPredTemp = InverseTransformation(NNInput, yPredTemp, ySetPlotDiat.get_value()) yPredSum = yPredSum + yPredTemp yPredSumSqr = yPredSumSqr + numpy.square(yPredTemp) # yMean = yPredSum / NNInput.NOutPostSamples yStD = numpy.sqrt(yPredSumSqr / NNInput.NOutPostSamples - numpy.square(yMean)) yPlus = yMean + SigmaIntCoeff * yStD yMinus = yMean - SigmaIntCoeff * yStD PathToPlotLabels = NNInput.PathToOutputFldr + '/OutputPosts/yPred' + str( int(numpy.floor(Ang))) + '.csv' save_moments( PathToPlotLabels, 'yPred', numpy.column_stack( [RSetPlot.get_value(), ySetPlot, yMean, yStD, yMinus, yPlus])) print(' Wrote Sampled yPred for Angle ', Ang, '\n') if (NNInput.AddNoiseToPredsFlg): i = -1 for Ang in NNInput.AngVector: numpy.random.seed(RandomSeed) pymc3.set_tt_rng(RandomSeed) i = i + 1 RSetPlot, ySetPlot, ySetPlotDiat, ySetPlotTriat = datasetsPlot[i] ySetPlot = T.cast(ySetPlot, 'float64') ySetPlot = ySetPlot.eval() #ySetPlot = InverseTransformation(NNInput, ySetPlot, ySetPlotDiat.get_value()) yPredPlot = sample_proba_yPred(RSetPlot.get_value(borrow=True), NNInput.NOutPostSamples) yPostSum = ySetPlot * 0.0 yPostSumSqr = ySetPlot * 0.0 for j in range(NNInput.NOutPostSamples): yPredTemp = numpy.array(yPredPlot[j, :]) if (NNInput.AddNoiseToPredsFlg): for k in range(NSigmaSamples): yPostTemp = InverseTransformation( NNInput, yPostTemp, ySetPlotDiat.get_value()) SigmaTemp = SigmaPred[j, k] RandNum = numpy.random.normal(loc=0.0, scale=SigmaTemp) yPostTemp = yPredTemp * RandNum yPostSum = yPostSum + yPostTemp yPostSumSqr = yPostSumSqr + numpy.square(yPostTemp) # yMean = yPostSum / NNInput.NOutPostSamples yStD = numpy.sqrt(yPostSumSqr / NNInput.NOutPostSamples - numpy.square(yMean)) yPlus = yMean + SigmaIntCoeff * yStD yMinus = yMean - SigmaIntCoeff * yStD PathToPlotLabels = NNInput.PathToOutputFldr + '/OutputPosts/yPost' + str( int(numpy.floor(Ang))) + '.csv' save_moments( PathToPlotLabels, 'yPost', numpy.column_stack([ RSetPlot.get_value(), ySetPlot, yMean, yStD, yMinus, yPlus ])) print(' Wrote Sampled yPost for Angle ', Ang, '\n')
from DataFrame import DataFrame from PlotGeneration import PlotGeneration from LoadData import load_data from StatisticalTest import StatisticalTest if __name__ == "__main__": print("Loading data frames. . .") load_data() # load data print("Loading statistics. . .") DataFrame.FemaleIncidenceRate() # generate female incidence rates DataFrame.FemaleMortalityRate() # generate female mortality rates DataFrame.MaleIncidenceRate() # generate male incidence rates DataFrame.MaleMortalityRate() # generate male morality rates print("Generating CSV file. . .") PlotGeneration.create_csv() # generate the CSV file to create the map print("Generating map. . .") PlotGeneration.generate_choropleth() # map creation PlotGeneration.generate_sankey() # sankey plot generation PlotGeneration.generate_boxplot() print("Calculating statistics. . .\n" ) # T-Test generation, calculating averages StatisticalTest() StatisticalTest.box_plot_statistics( PlotGeneration.map_data['total_incidence'], PlotGeneration.map_data['state_name'], 'incidence_rate') print("")
from sklearn.metrics import accuracy_score from sklearn.metrics import classification_report from LoadData import load_data from sklearn.neural_network import MLPClassifier from BuildModel import get_Model from livelossplot.keras import PlotLossesCallback from sklearn.svm import SVC x_train, x_test, x_valid, y_train, y_test, y_valid = load_data(test_size = 0.25, valid_size = 0.25) print('Shape of training data', x_train.shape) print('Shape of training labels', len(y_train)) print('Shape of test data', x_test.shape) print('Shape of test labels', len(y_test)) print('Shape of validation data', x_valid.shape) print('Shape of validation labels', len(y_valid)) print(f'\nFeatures extracted:', x_train.shape[1]) #MLP classifier model = MLPClassifier(alpha = 0.01, batch_size = 256, epsilon = 1e-08, hidden_layer_sizes=(300,), learning_rate = 'adaptive', max_iter = 500) model.fit(x_train, y_train) y_prediction = model.predict(x_test) accuracy = accuracy_score(y_true = y_test, y_pred = y_prediction) print("\nAccuracy: {:.2f}%".format(accuracy * 100)) print("\n") print(classification_report(y_test, y_prediction)) """#Deep Neural Network model = get_Model(x_train.shape[1]) model.fit(x_train, y_train, batch_size = 10000, epochs = 100,
def sgd_optimization(NNInput): ################################################################################################################################## ### LOADING DATA ################################################################################################################################## print('\nLoading Data ... \n') if (NNInput.TryNNFlg > 0): datasets, datasetsTry = load_data(NNInput) else: datasets = load_data(NNInput) # RSetTrainValid, ySetTrainValid, ySetTrainValidDiat, ySetTrainValidTriat = datasets[0] # RSetTest, ySetTest, ySetTestDiat, ySetTestTriat = datasets[1] # RDataOrig, yDataOrig, yDataDiatOrig, yDataTriatOrig = datasets[2] # NNInput.NIn = RSetTrainValid.shape[1] # NNInput.NOut = ySetTrainValid.shape[1] # print((' Nb of Input: %i') % NNInput.NIn) # print((' Nb of Output: %i \n') % NNInput.NOut) # NNInput.NLayers = NNInput.NHid # NNInput.NLayers.insert(0,NNInput.NIn) # NNInput.NLayers.append(NNInput.NOut) # print(' Network Shape: ', NNInput.NLayers, '\n') # NTrainValid = RSetTrainValid.shape[0] # NTest = RSetTest.shape[0] # print((' Nb of Training + Validation Examples: %i') % NTrainValid) # print((' Nb of Test Examples: %i \n') % NTest) # NBatchTrainValid = NTrainValid // NNInput.NMiniBatch # print((' Nb of Training + Validation Batches: %i') % NBatchTrainValid) RSetTrain, ySetTrain, ySetTrainDiat, ySetTrainTriat = datasets[0] RSetValid, ySetValid, ySetValidDiat, ySetValidTriat = datasets[1] RDataOrig, yDataOrig, yDataDiatOrig, yDataTriatOrig = datasets[2] NNInput.NIn = RSetTrain.shape[1] #NNInput.NOut = ySetTrain.shape[1] print((' Nb of Input: %i') % NNInput.NIn) print((' Nb of Output: %i \n') % 1) NNInput.NLayers = NNInput.NHid NNInput.NLayers.insert(0, NNInput.NIn) NNInput.NLayers.append(NNInput.NOut) print(' Network Shape: ', NNInput.NLayers, '\n') NTrain = RSetTrain.shape[0] NValid = RSetValid.shape[0] print(' Nb of Training + Validation Examples: ', NTrain + NValid, '; of which: ', NTrain, ' for Training and ', NValid, ' for Validation') #NTest = RSetTest.shape[0] #print((' Nb of Test Examples: %i \n') % NTest) ###################### # BUILD ACTUAL MODEL # ###################### print('\nBuilding the Model ... \n') model = build_MLP_model(NNInput) #model.summary() ############### # TRAIN MODEL # ############### early_stop = tf.keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=NNInput.ImpThold, patience=NNInput.NPatience, restore_best_weights=True, verbose=1) WeightsPath = NNInput.CheckpointFldr + '/weights.csv' mc_callback = tf.keras.callbacks.ModelCheckpoint( filepath=NNInput.CheckpointFilePath, monitor='val_loss', save_best_only=True, save_weights_only=True, verbose=1) lr_callback = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.7, patience=500, mode='auto', min_delta=1.e-6, cooldown=0, min_lr=1.e-8, verbose=1) tb_callback = tf.keras.callbacks.TensorBoard( log_dir=NNInput.CheckpointFilePath, histogram_freq=100, batch_size=NNInput.NMiniBatch, write_graph=True, write_grads=True, write_images=True, embeddings_freq=0, embeddings_layer_names=None, embeddings_metadata=None, embeddings_data=None) callbacksVec = [mc_callback, early_stop, tb_callback] ### Training the NN print('\nTraining the Model ... \n') # history = model.fit(RSetTrainValid, ySetTrainValid, shuffle=True, batch_size=NNInput.NMiniBatch, epochs=NNInput.NEpoch, validation_split=NNInput.PercValid, verbose=1, callbacks=callbacksVec) xTrain = RSetTrain #tf.convert_to_tensor(RSetTrain, tf.float32) yTrain = ySetTrain #tf.convert_to_tensor(ySetTrain, tf.float32) xValid = RSetValid #tf.convert_to_tensor(RSetValid, tf.float32) yValid = ySetValid #tf.convert_to_tensor(ySetValid, tf.float32) history = model.fit(xTrain, yTrain, shuffle=True, batch_size=NNInput.NMiniBatch, epochs=NNInput.NEpoch, validation_data=(xValid, yValid), verbose=1, callbacks=callbacksVec) ### Plotting History #plot_history(NNInput, history) #ErrorTest = model.evaluate(RSetTest, ySetTest, verbose=1) #print("TensorBoard LogDir: ", NNInput.CheckpointFldr) model.load_weights(NNInput.CheckpointFilePath) jLayer = -1 for iLayer in [1, 3, 4, 5]: jLayer = jLayer + 1 Params = model.get_layer(index=jLayer).get_weights() PathToFldr = NNInput.PathToOutputFldr + NNInput.LayersName[iLayer] + '/' if not os.path.exists(PathToFldr): os.makedirs(PathToFldr) PathToFile = PathToFldr + 'Weights.npz' numpy.savez(PathToFile, Params[0], Params[1]) if (NNInput.WriteFinalFlg > 0): if (jLayer == 0): save_parameters_PIP(PathToFldr, Params[0], Params[1]) else: save_parameters(PathToFldr, Params[0], Params[1]) yPredOrig = model.predict(RDataOrig) yPredOrig = InverseTransformation(NNInput, yPredOrig, yDataDiatOrig) plot_scatter(NNInput, yPredOrig, yDataOrig) ### Evaluating Model for a Particular Data-Set if (NNInput.TryNNFlg > 0): i = -1 for Ang in NNInput.AngVector: i = i + 1 xSetTry, ySetTry, ySetTryDiat, ySetTryTriat = datasetsTry[i] yPredTry = model.predict(xSetTry) yPredTry = InverseTransformation(NNInput, yPredTry, ySetTryDiat) ### Saving Predicted Output #PathToTryLabels = NNInput.PathToOutputFldr + '/yEvaluated.csv' #save_labels(PathToTryLabels, 'Generated', yPredTry) PathToAbscissaToPlot = NNInput.PathToDataFldr + '/R.csv.' + str( Ang) xPlot = abscissa_to_plot(PathToAbscissaToPlot) #PathToTryLabels = NNInput.PathToOutputFldr + '/REBestDet.csv.' + str(Ang) PathToTryLabels = NNInput.PathToOutputFldr + '/REBestAll.csv.' + str( Ang) # ErrorAbs = ySetTry - yPredTry # ErrorRel = (ySetTry - yPredTry) / ySetTry # AbsErrorAbs = abs( ySetTry - yPredTry ) # AbsErrorRel = abs( (ySetTry - yPredTry) / ySetTry ) save_to_plot(PathToTryLabels, 'Evaluated', numpy.concatenate((xPlot, ySetTry, yPredTry), axis=1)) #save_to_plot_all(PathToTryLabels, 'Evaluated', numpy.concatenate((xPlot, ySetTry, yPredTry, ErrorAbs, ErrorRel, AbsErrorAbs, AbsErrorRel), axis=1)) # ### Plotting Results # plot_try_set(NNInput, ySetTry, yPredTry) error = ySetTry - yPredTry plot_error(NNInput, error)
def evaluate_model(NNInput): ################################################################################################################################## ### LOADING DATA ################################################################################################################################## print('\nLoading Data ... \n') if (NNInput.TryNNFlg > 0): datasets, datasetsTry = load_data(NNInput) else: datasets = load_data(NNInput) RSetTrainValid, ySetTrainValid, ySetTrainValidDiat, ySetTrainValidTriat = datasets[ 0] RSetTest, ySetTest, ySetTestDiat, ySetTestTriat = datasets[1] RDataOrig, yDataOrig, yDataDiatOrig, yDataTriatOrig = datasets[2] NNInput.NIn = RSetTrainValid.shape[1] NNInput.NOut = ySetTrainValid.shape[1] print((' Nb of Input: %i') % NNInput.NIn) print((' Nb of Output: %i \n') % NNInput.NOut) NNInput.NLayers = NNInput.NHid NNInput.NLayers.insert(0, NNInput.NIn) NNInput.NLayers.append(NNInput.NOut) print(' Network Shape: ', NNInput.NLayers, '\n') NTrainValid = RSetTrainValid.shape[0] NTest = RSetTest.shape[0] print((' Nb of Training + Validation Examples: %i') % NTrainValid) print((' Nb of Test Examples: %i \n') % NTest) NBatchTrainValid = NTrainValid // NNInput.NMiniBatch print((' Nb of Training + Validation Batches: %i') % NBatchTrainValid) ###################### # BUILD ACTUAL MODEL # ###################### print('\nBuilding the Model ... \n') model = build_MLP_model(NNInput) #model.summary() ############### # TRAIN MODEL # ############### model.load_weights(NNInput.CheckpointFilePath) jLayer = -1 for iLayer in [1, 3, 4, 5]: jLayer = jLayer + 1 Params = model.get_layer(index=jLayer).get_weights() PathToFldr = NNInput.PathToOutputFldr + NNInput.LayersName[iLayer] + '/' if not os.path.exists(PathToFldr): os.makedirs(PathToFldr) PathToFile = PathToFldr + 'Weights.npz' numpy.savez(PathToFile, Params[0], Params[1]) if (NNInput.WriteFinalFlg > 0): if (jLayer == 0): save_parameters_PIP(PathToFldr, Params[0], Params[1]) else: save_parameters(PathToFldr, Params[0], Params[1]) yPredOrig = model.predict(RDataOrig) yPredOrig = InverseTransformation(NNInput, yPredOrig, yDataDiatOrig) plot_scatter(NNInput, yPredOrig, yDataOrig) ### Evaluating Model for a Particular Data-Set if (NNInput.TryNNFlg > 0): i = -1 for Ang in NNInput.AngVector: i = i + 1 xSetTry, ySetTry, ySetTryDiat, ySetTryTriat = datasetsTry[i] yPredTry = model.predict(xSetTry) yPredTry = InverseTransformation(NNInput, yPredTry, ySetTryDiat) ### Saving Predicted Output #PathToTryLabels = NNInput.PathToOutputFldr + '/yEvaluated.csv' #save_labels(PathToTryLabels, 'Generated', yPredTry) PathToAbscissaToPlot = NNInput.PathToDataFldr + '/R.csv.' + str( Ang) xPlot = abscissa_to_plot(PathToAbscissaToPlot) #PathToTryLabels = NNInput.PathToOutputFldr + '/REBestDet.csv.' + str(Ang) PathToTryLabels = NNInput.PathToOutputFldr + '/REBestAll.csv.' + str( Ang) # ErrorAbs = ySetTry - yPredTry # ErrorRel = (ySetTry - yPredTry) / ySetTry # AbsErrorAbs = abs( ySetTry - yPredTry ) # AbsErrorRel = abs( (ySetTry - yPredTry) / ySetTry ) save_to_plot(PathToTryLabels, 'Evaluated', numpy.concatenate((xPlot, ySetTry, yPredTry), axis=1)) #save_to_plot_all(PathToTryLabels, 'Evaluated', numpy.concatenate((xPlot, ySetTry, yPredTry, ErrorAbs, ErrorRel, AbsErrorAbs, AbsErrorRel), axis=1)) # ### Plotting Results # plot_try_set(NNInput, ySetTry, yPredTry) error = ySetTry - yPredTry plot_error(NNInput, error)
'finish_timing': TIMESTAMP() } # parser qcut_q = int(args.bins) qcut_q = 9 # CHANGE FOR REMOTE PC y_type = args.y_type # 'yoyr','qoq','yoy' y_type = 'qoq' resume = args.resume sample_no = args.sample_no sample_no = 1 # CHANGE FOR HKPC # load data for entire period main = load_data(lag_year=args.lag, sql_version=args.sql_version) # CHANGE FOR DEBUG label_df = main.iloc[:, :2] space['num_class'] = qcut_q space['is_unbalance'] = True sql_result = {'qcut': qcut_q} # sql_result['name'] = 'try add ibes as X' # sql_result['trial'] = db_last['trial'] + 1 # roll over each round period_1 = dt.datetime(2017, 12, 31) # CHANGE FOR DEBUG for i in tqdm(range(sample_no)): # divide sets and return testing_period = period_1 + i * relativedelta( months=3) # set sets in chronological order
def main(argv=None): new_train_set, new_train_mask = load_data() print('Loading data finished!') train(new_train_set, new_train_mask)
def train(self, model): #training parameters batch_size = 8 maxepoches = 25 learning_rate = 0.1 lr_decay = 1e-6 lr_drop = 20 # The data, shuffled and split between train and test sets: # (x_train, y_train), (x_test, y_test) = cifar10.load_data() (x_train, y_train), (x_test, y_test) = load_data() x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train, x_test = self.normalize(x_train, x_test) y_train = keras.utils.to_categorical(y_train, self.num_classes) y_test = keras.utils.to_categorical(y_test, self.num_classes) def lr_scheduler(epoch): return learning_rate * (0.5**(epoch // lr_drop)) reduce_lr = keras.callbacks.LearningRateScheduler(lr_scheduler) #data augmentation datagen = ImageDataGenerator( featurewise_center=False, # set input mean to 0 over the dataset samplewise_center=False, # set each sample mean to 0 featurewise_std_normalization= False, # divide inputs by std of the dataset samplewise_std_normalization=False, # divide each input by its std zca_whitening=False, # apply ZCA whitening rotation_range= 15, # randomly rotate images in the range (degrees, 0 to 180) width_shift_range= 0.1, # randomly shift images horizontally (fraction of total width) height_shift_range= 0.1, # randomly shift images vertically (fraction of total height) horizontal_flip=True, # randomly flip images vertical_flip=False) # randomly flip images # (std, mean, and principal components if ZCA whitening is applied). datagen.fit(x_train) #optimization details sgd = optimizers.SGD(lr=learning_rate, decay=lr_decay, momentum=0.9, nesterov=True) model.compile(loss='binary_crossentropy', optimizer=sgd, metrics=['accuracy']) # training process in a for loop with learning rate drop every 25 epoches. historytemp = model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size), steps_per_epoch=x_train.shape[0] // batch_size, epochs=maxepoches, validation_data=(x_test, y_test), callbacks=[reduce_lr], verbose=2, class_weight='auto') model.save_weights('cifar10vgg.h5') return model
from keras.models import Model, load_model import numpy as np from LoadData import load_data import gc import random # from keras.applications.mobilenet import relu6,DepthwiseConv2D import datetime from keras.preprocessing import image gc.collect() import numpy as np from skimage import io, transform, img_as_ubyte import os lst = ['鸟', '荷', '竹', '马', '菊', '兰', '柳', '梅', '山'] starttime = datetime.datetime.now() X_test, Y_test = load_data('E:\\Imagedecolor\\test') image_size = (224, 224) X_test = X_test.astype('float32') X_test /= 255. X_test -= 0.5 X_test *= 2. # model = load_model('finalmobilenet.hdf5',custom_objects={ # 'relu6': relu6, # 'DepthwiseConv2D': DepthwiseConv2D}) model = load_model('data_argumentation_vgg16.hdf5')
Step 4: (this part is updated) 4.1 load_data 4.2 for loop -> roll over all time period, ''' # import 'LoadData.py' module from Local Finder 'Preprocessing' # import load_data, clean_set function from 'LoadData.py' module # this need update on GitHub -> Update Project from VCS (Command + T on MacBook) y_type = 'qoq' db_string = 'postgres://*****:*****@hkpolyu.cgqhw7rofrpo.ap-northeast-2.rds.amazonaws.com:5432/postgres' engine = create_engine(db_string) # 4.1. run load data -> return entire dataframe (153667, 3174) for all datacqtr (period) main = load_data( lag_year=5, sql_version=False ) # change sql_version -> True if trying to run this code through Postgres Database col = main.columns[2:-4].to_list() # print(len(col), col) explanation_ratio_dict = { } # create dictionary contains explained_variance_ratio for all 40 sets # 4.2. for loop -> roll over all time period from main dataset period_1 = dt.datetime(2017, 12, 31) for i in tqdm( range(1) ): # change to 40 for full 40 sets, change to False to stop saving csv testing_period = period_1 + i * relativedelta(
# coding: utf-8 #使用自訂的模式 from LoadData import load_data import numpy as np import random np.random.seed(10) num_class = 2 RGB = 3 # 彩色 batchSize = 8 # Step 1. 資料準備 (x_train, y_train), (x_test, y_test) = load_data() # x_train = x_train.transpose(0, 2, 3, 1) # x_test = x_test.transpose(0, 2, 3, 1) # 打亂資料 index_1 = [i for i in range(len(x_train))] random.shuffle(index_1) x_train = x_train[index_1] y_train = y_train[index_1] index_2 = [i for i in range(len(x_test))] random.shuffle(index_2) x_test = x_test[index_2] y_test = y_test[index_2] print("train data:", 'images:', x_train.shape, " labels:", y_train.shape)
KERNEL_SIZE = (3, 3) # 卷积核大小 INPUT_SHAPE = (64, 64, 3) # 图像张量 POOL_SIZE = (2, 2) # 池化缩小比例因素 NB_CLASSES = 0 # 分类数 EPOCHS = 100 # 循环的次数 KIND_LISTS = ['anger', 'fear', 'happy', 'normal', 'sad', 'surprised'] # 主函数 if __name__ == '__main__': print('[INFO] start...') train_images_path = "/media/wsk/移动磁盘1/face_images/train" test_images_path = "/media/wsk/移动磁盘1/face_images/test" # 加载图片 print("[INFO] loading images...") x_train_background, y_train_background = load_data(train_images_path, IMAGE_SIZE) x_test_background, y_test_background = load_data(test_images_path, IMAGE_SIZE) #初始化模型 print("[INFO] initialize background model...") background_model = initialize_model(FILTERS, KERNEL_SIZE, INPUT_SHAPE, POOL_SIZE, len(os.listdir(train_images_path))) # 训练模型 print("[INFO] compiling background model...") train(background_model, x_train_background, y_train_background, x_test_background, y_test_background, 8, EPOCHS, 'models/Base_model.h5') # 测试模型并输出分类日志 image_lists = load_test_image(test_images_path, IMAGE_SIZE)
clusters = get_clusters(points, centroids) for i in range(iterations): clusters = get_clusters(points, centroids) centroids = center(clusters) return clusters, centroids if __name__ == "__main__": filepath = './data/iris.data' data = load_data(filepath) X = np.array([f[:-1] for f in data]) Y = np.array([f[-1] for f in data]) # Target clusters, centroids = k_means(X, 3) print(centroids) for i, cluster in enumerate(clusters): cluster = np.array(cluster) plt.scatter(cluster[:, 0], cluster[:, 1], c=COLORS[i], label="Cluster {}".format(i)) for i, centroid in enumerate(centroids):
from keras import objectives, losses from LoadData import load_data import PlottingHelpers import ProcessingHelpers importlib.reload(ProcessingHelpers) # while still working on than fun importlib.reload(PlottingHelpers) # while still working on than fun sns.set() dirname = os.getcwd() pth = os.path.join(dirname, 'CMAPSSData') print('loading data...') dc = load_data(pth) print('done') # get the first data set training data df = dc['FD_003']['df_train'].copy() ''' Make a Column for the RUL data According to the data description document the data set contains multiple units, each unit starts at a certain degradation point and the measurement data ends closely before the unit was decommissioned of broke. Therefore assume, that for the last measurement time that is available for a unit the units RUL=0 (stopped measuring just before machine broke) ''' # get the time of the last available measurement for each unit