def __process(nrOfIterations, learningRate, hiddenNeuronsNumber, aConst): dataset = ProblemData("resources/data.data") trainX, trainY, testX, testY = dataset.splitData() neuralNetwork = ANN(deepcopy(trainX), deepcopy(trainY), learningRate, hiddenNeuronsNumber, aConst) iterations = [] for i in range(nrOfIterations): neuralNetwork.feedForward() neuralNetwork.backProp() iterations.append(i) for i in range(len(testX)): predictedOut = neuralNetwork.getOutput(testX[i]) print("Predicted output: {0}\nReal value: {1}".format( predictedOut, testY[i])) matplotlib.pyplot.plot(iterations, neuralNetwork.getLoss(), label='loss value vs iteration') matplotlib.pyplot.xlabel('Iterations') matplotlib.pyplot.ylabel('Loss function') matplotlib.pyplot.legend() matplotlib.pyplot.show()
def main(): """ Solve riddle. """ house_number = 5 riddle = ProblemData(house_number, build_assertions()) for rounds in range(15): progress_made = False # have any changes (progress) been made this round? riddle, progress_made = deduce(riddle) if not progress_made: print("\t\tNo progress made in round #" + str(rounds + 1) + ". Breaking loop.") print("\t\tAssertions used: " + str(riddle.assertions_used.count(True)) + "/" + str(len(riddle.assertions_used))) break riddle.house_state() riddle.element_state()
def main(): if (len(sys.argv) < 2): sys.stderr.write("Error: Not enough arguments.\n") sys.stderr.write("usage: " + sys.argv[0] + " <input_file>\n") return 1 input_file = sys.argv[1] try: ProblemData.readFile(input_file) except: sys.stderr.write("Error: Failed file parsing: Invalid input file.\n") return 2 print("--------------------------------------") print("--- Timetable Scheduling Problem ---") print("--------------------------------------\n") print("1. Genetic Algorithm") print("2. Hill Climbing") print("3. Simulated Annealing\n") while True: try: option = int(input("Choose the desired algorithm: ")) if option in [1, 2, 3]: break except ValueError: continue t1 = time.time() if option == 1: geneticAlgorithm() elif option == 2: hillClimbing() elif option == 3: simulatedAnnealing() t2 = time.time() print("Execution time: {:.4f} seconds".format(t2-t1))
def main(): # loading the data as prblmData prblmData = ProblemData(defaultSignalValue=defaultSignalValue, numNodes=numNodes) prblmData = prblmData.loadData(useStoredData=useStoredData, inputFileName=inputFileName, storeReadData=storeReadData, storeDataName=storeDataName, rowReadUntil=readDataUntilRow) # partitioning data and providing test and train sets and corresponding labels as dataPar dataPar = DataPartition() dataPar = dataPar.makeTrainTest(prblmData=prblmData, readSampleSize=sampleSize, testPartitionSize=testPartitionSize, randomState=0, doNormalize=False, useSubSample=useSubSample, storeSubSample=True, subSamplePcklName=subSamplePcklName) # providing normalized data of dataPar as dataParNormal dataParNormal = DataPartition() dataParNormal = dataParNormal.makeTrainTest( prblmData=prblmData, readSampleSize=sampleSize, testPartitionSize=testPartitionSize, randomState=0, doNormalize=True, useSubSample=useSubSample, storeSubSample=True, subSamplePcklName=subSamplePcklName) # Feature reduction of normalized data by PCA(with pcaNcomponents dimensions) as dataParPca pcaNcomponent = 10 pcaObj = PCA(n_components=pcaNcomponent) fit = pcaObj.fit(dataParNormal.fVecTrain) dataParPca = DataPartition() dataParPca.fVecTrain = pcaObj.fit_transform(dataParNormal.fVecTrain) dataParPca.fVecTest = pcaObj.fit_transform(dataParNormal.fVecTest) dataParPca.labelTrain = dataParNormal.labelTrain dataParPca.labelTest = dataParNormal.labelTest dataParPca.isNormalized = True # plotting data by first and second principle components of applied PCA on data plt.plot(dataParPca.fVecTrain[:, 0], dataParPca.fVecTrain[:, 1], 'b.') plt.title('2D PCA') plt.show() # Three classifiers (random forest, KNN, SVM) with hyper parameters (will be tuned by cross validation) are defined below: # parameter cv shows number of partitions for cross validation of hyper parameter tuning # n_jobs = -1 run the data on multiple cores # Random Forest: # n_estimators: number of trees to make the forest #criteria: measuring quality of a split. “gini” for the Gini impurity and “entropy” for the information gain # max_features: number of features to consider when looking for the best split paramGrid_rf = { 'n_estimators': [5, 10, 17, 30], 'criterion': ['gini', 'entropy'], 'max_features': ['auto', 0.01, 0.1, 0.9], 'n_jobs': [-1] } #paramGrid_rf = {'n_estimators': [30] ,'criterion': ['gini'] ,'n_jobs': [-1]} # n_jobs => runs in parallel clf_rf = GridSearchCV(RandomForestClassifier(), paramGrid_rf, cv=3) # ,scoring='%s_macro' % score # KNN: # n_neighbors: number of neighbours to consider # weights: how to weight labels of neighbors. uniform or distance(consider reverse of the neighbors distance) # metric: how to measure the distance: 'minkowski', 'euclidean' or 'manhattan' paramGrid_knn = { 'n_neighbors': [3, 5, 9, 15], 'weights': ['uniform', 'distance'], 'metric': ['minkowski', 'euclidean', 'manhattan'] } #paramGrid_knn = {'n_neighbors': [5, 9], 'weights': ['distance'],'metric': ['manhattan']} clf_knn = GridSearchCV(KNeighborsClassifier(algorithm='kd_tree', n_jobs=-1), paramGrid_knn, cv=3) #, verbose=10 # ,scoring='%s_macro' % score # SVM: # C : Penalty parameter for miss classification # kernel: used kernel 'linear', 'poly', 'rbf' // rbf is more time consuming but seems to be more concordat to problem # gamma: kernel coefficient. How far the influence of a single training data reaches [low: far / high: close] param_grid_svm = {'C': [0.1], 'kernel': ['rbf'], 'gamma': [0.01]} # param_grid_svm = {'C': [0.01, 0.1, 1, 10], 'kernel': ['linear', 'poly', 'rbf'], 'gamma': [0.001, 0.01, 0.1, 1]} # rbf is time consuming comparing to others clf_svm = GridSearchCV( svm.SVC(), param_grid_svm, cv=3) # , verbose=10: write the result of each epoc of cv clfNames = ['random_forest', 'knn', 'svm'] dataTypes = ['original ', 'normalized', 'nomalized_PCA'] for idx, clf in enumerate([clf_rf, clf_knn, clf_svm]): for idx2, datap in enumerate([dataPar, dataParNormal, dataParPca]): runCl = RunClassifier() prediction, accuracy, conf_matrix, clf.best_params = runCl.doClassification( clf, datap.fVecTrain, datap.fVecTest, datap.labelTrain, datap.labelTest, showPlot=True, savePickleModel=savePickleModel, clfName=clfNames[idx], dataType=dataTypes[idx2]) print('\n+++++++++++++++++++\n')
#I = array([0,3,1,0]) #J = array([0,3,1,2]) #V = array([4,5,7,9]) #A = sparse.coo_matrix((V,(I,J)),shape=(4,4)) # We define the data for the problem, i.e., # * the cross sections for node; # * the length of every node; # * the boudnary conditions; # * and the local refinement of every node; # prob_data = ProblemData() # D Sigma_a nu Sigma_f Delta_x prob_data.set_xs('0',[1/(3*0.416667), 0.334, 1.0, 0.000, 2.7]) #moderator prob_data.set_xs('1',[1/(3*0.416667), 0.334, 1.0, 0.178, 2.4]) #fuel prob_data.set_composition(['0', '1', '0', '1', '0', '1', '0']) prob_data.set_bc(0,0) prob_data.set_refinements(20) prob_data.setup() state = State(prob_data) matrices = SpatialD(state)