def Adaboost_onNonDynamicData(): #Parsing Full training dataset XFull = common.parseFile('../UCI HAR Dataset/train/X_train.txt') YFull = common.parseFile('../UCI HAR Dataset/train/y_train.txt') #Parsing Full testing dataset XFullTest = common.parseFile('../UCI HAR Dataset/test/X_test.txt') YFullTest = common.parseFile('../UCI HAR Dataset/test/y_test.txt') #Getting the dataset associated with Non-Dynamic Activities on training X_NonDynamic, Y_NonDynamic = common.getDataSubset(XFull, YFull.flatten(), [4, 5, 6]) #Getting the dataset associated with Non-Dynamic Activities on testing X_NonDynamicTest, Y_NonDynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [4, 5, 6]) #Fitting data using Adaboost classifier for i in [50, 100, 200, 300, 500]: clf = ensemble.AdaBoostClassifier(n_estimators=i) clf.fit(X_NonDynamic, Y_NonDynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_NonDynamicTest), Y_NonDynamicTest, [4, 5, 6]) print("For the NonDynamic dataset with n_estimators = ", i) common.createConfusionMatrix( clf.predict(X_NonDynamicTest).flatten(), Y_NonDynamicTest.flatten(), [4, 5, 6]) print(fscore) #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3]) print(len(X_DynamicTest), len(Y_DynamicTest)) #Fitting data using Adaboost classifier clf = ensemble.AdaBoostClassifier(n_estimators=300) clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3]) common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3]) print(fscore)
def QDA_onNonDynamicData(): #Parsing Full training dataset XFull = common.parseFile('../UCI HAR Dataset/train/X_train.txt') YFull = common.parseFile('../UCI HAR Dataset/train/y_train.txt') #Parsing Full testing dataset XFullTest = common.parseFile('../UCI HAR Dataset/test/X_test.txt') YFullTest = common.parseFile('../UCI HAR Dataset/test/y_test.txt') #Getting the dataset associated with Non-Dynamic Activities on training X_NonDynamic, Y_NonDynamic = common.getDataSubset(XFull, YFull.flatten(), [4, 5, 6]) #Getting the dataset associated with Non-Dynamic Activities on testing X_NonDynamicTest, Y_NonDynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [4, 5, 6]) #Fitting data using QDA classifier clf = QDA() clf.fit(X_NonDynamic, Y_NonDynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_NonDynamicTest), Y_NonDynamicTest, [4, 5, 6]) common.createConfusionMatrix( clf.predict(X_NonDynamicTest).flatten(), Y_NonDynamicTest.flatten(), [4, 5, 6]) print fscore #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3]) print len(X_DynamicTest), len(Y_DynamicTest) #Fitting data using QDA classifier clf = QDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3]) common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3]) print fscore
def Adaboost_onNonDynamicData(): #Parsing Full training dataset XFull = common.parseFile('../UCI HAR Dataset/train/X_train.txt') YFull = common.parseFile('../UCI HAR Dataset/train/y_train.txt') #Parsing Full testing dataset XFullTest = common.parseFile('../UCI HAR Dataset/test/X_test.txt') YFullTest = common.parseFile('../UCI HAR Dataset/test/y_test.txt') #Getting the dataset associated with Non-Dynamic Activities on training X_NonDynamic,Y_NonDynamic = common.getDataSubset(XFull,YFull.flatten(),[4,5,6]) #Getting the dataset associated with Non-Dynamic Activities on testing X_NonDynamicTest,Y_NonDynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[4,5,6]) #Fitting data using Adaboost classifier for i in [50,100,200,300,500]: clf = ensemble.AdaBoostClassifier(n_estimators = i) clf.fit(X_NonDynamic, Y_NonDynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_NonDynamicTest),Y_NonDynamicTest,[4,5,6]) print "For the NonDynamic dataset with n_estimators = ",i common.createConfusionMatrix(clf.predict(X_NonDynamicTest).flatten(),Y_NonDynamicTest.flatten(),[4,5,6]) print fscore #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3]) print len(X_DynamicTest),len(Y_DynamicTest) #Fitting data using Adaboost classifier clf = ensemble.AdaBoostClassifier(n_estimators = 300) clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3]) common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3]) print fscore
def MLP_onNonDynamicData(): #Parsing Full training dataset XFull = common.parseFile('../UCI HAR Dataset/train/X_train.txt') YFull = common.parseFile('../UCI HAR Dataset/train/y_train.txt') #Parsing Full testing dataset XFullTest = common.parseFile('../UCI HAR Dataset/test/X_test.txt') YFullTest = common.parseFile('../UCI HAR Dataset/test/y_test.txt') #Getting the dataset associated with Non-Dynamic Activities on training X_NonDynamic,Y_NonDynamic = common.getDataSubset(XFull,YFull.flatten(),[4,5,6]) #Getting the dataset associated with Non-Dynamic Activities on testing X_NonDynamicTest,Y_NonDynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[4,5,6]) #Fitting data using MLP classifier clf = MLPClassifier() clf.fit(X_NonDynamic, Y_NonDynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_NonDynamicTest),Y_NonDynamicTest,[4,5,6]) common.createConfusionMatrix(clf.predict(X_NonDynamicTest).flatten(),Y_NonDynamicTest.flatten(),[4,5,6]) print fscore #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3]) print len(X_DynamicTest),len(Y_DynamicTest) #Fitting data using MLP classifier clf = MLPClassifier() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3]) common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3]) print fscore
def MLP_onFullDataset(): #Parsing Full training dataset XFull = common.parseFile('../UCI HAR Dataset/train/X_train.txt') YFull = common.parseFile('../UCI HAR Dataset/train/y_train.txt') #Parsing Full testing dataset XFullTest = common.parseFile('../UCI HAR Dataset/test/X_test.txt') YFullTest = common.parseFile('../UCI HAR Dataset/test/y_test.txt') #Fitting data using MLP classifier clf = MLPClassifier() clf.fit(XFull, YFull.flatten()) #Testing the results precision,recall,fscore = common.checkAccuracy(clf.predict(XFullTest),YFullTest,[1,2,3,4,5,6]) print fscore
def Adaboost_onFullDataset(): #Parsing Full training dataset XFull = common.parseFile('../UCI HAR Dataset/train/X_train.txt') YFull = common.parseFile('../UCI HAR Dataset/train/y_train.txt') #Parsing Full testing dataset XFullTest = common.parseFile('../UCI HAR Dataset/test/X_test.txt') YFullTest = common.parseFile('../UCI HAR Dataset/test/y_test.txt') #Fitting data using Adaboost classifier clf = ensemble.AdaBoostClassifier(n_estimators = 300) clf.fit(XFull, YFull.flatten()) #Testing the results precision,recall,fscore = common.checkAccuracy(clf.predict(XFullTest),YFullTest,[1,2,3,4,5,6]) print "For the whole dataset",fscore
def Adaboost_onFullDataset(): #Parsing Full training dataset XFull = common.parseFile('../UCI HAR Dataset/train/X_train.txt') YFull = common.parseFile('../UCI HAR Dataset/train/y_train.txt') #Parsing Full testing dataset XFullTest = common.parseFile('../UCI HAR Dataset/test/X_test.txt') YFullTest = common.parseFile('../UCI HAR Dataset/test/y_test.txt') #Fitting data using Adaboost classifier clf = ensemble.AdaBoostClassifier(n_estimators=300) clf.fit(XFull, YFull.flatten()) #Testing the results precision, recall, fscore = common.checkAccuracy(clf.predict(XFullTest), YFullTest, [1, 2, 3, 4, 5, 6]) print("For the whole dataset", fscore)
def drawParamTest(): print('*' * 20, "绘图开始-读取数据", '*' * 20) plt.figure(figsize=(8, 8), dpi=80) activityLabels = [ 'WALKING', 'WALKING_UPSTAIRS', 'WALKING_DOWNSTAIRS', 'SITTING', 'STANDING', 'LAYING' ] plt.ion() CsetDraw = [] FscoreDraw = [] meanDraw = [] for Cset in np.arange(0.01, 1.01, 0.01): print("参数C为:{0:.2f}".format(Cset)) plt.cla() plt.title("SVM Adjust Params-C") plt.grid(True) clf = svm.SVC(kernel='linear', C=Cset, probability=False) clf.fit(X_Train, Y_Train) Y_predict = clf.predict(X_Test) prec, rec, f_score = common.checkAccuracy(Y_Test, Y_predict) FscoreDraw.append(list(f_score)) CsetDraw.append(Cset) meanDraw.append(np.mean([f_score])) for modeIndex in range(6): plt.plot(CsetDraw, [mode[modeIndex] for mode in FscoreDraw], color='#' + '8' * (5 - modeIndex) + '0' + 'B' * (modeIndex), label=activityLabels[modeIndex]) plt.plot(CsetDraw, meanDraw, 'k--', label='Mean') plt.legend(loc='upper right', shadow=True) plt.pause(0.1) plt.ioff() plt.show()
n_neighbors = i ## Hyper - Parameter ## clf = neighbors.KNeighborsClassifier(n_neighbors, weights='distance') clf.fit(X_train, Y_train) print"Done" print "Predicting" predicted = [] for x_test in X_test: predicted.append( clf.predict(x_test)[0] ) print "Done" print "Checking accuracy" precision,recall,f_score = common.checkAccuracy( Y_test , predicted , [1,0]) # Must provide list of relavent labels # ne.append(i) mean.append( np.mean(f_score)) print mean print "Done" ###########################################################
def LDA_onGyroData(): XFull = common.parseFile('../UCI HAR Dataset/train/X_train.txt') YFull = common.parseFile('../UCI HAR Dataset/train/y_train.txt') XFull = common.getGyroFeatures(XFull) #Parsing Full testing dataset XFullTest = common.parseFile('../UCI HAR Dataset/test/X_test.txt') YFullTest = common.parseFile('../UCI HAR Dataset/test/y_test.txt') XFullTest = common.getGyroFeatures(XFullTest) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3, 4, 5, 6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3, 4, 5, 6]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3, 4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3, 4, 5, 6])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3, 4, 5, 6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3, 4, 5, 6]) X_Dynamic = common.getPowerK(X_Dynamic, [1, 2]) X_DynamicTest = common.getPowerK(X_DynamicTest, [1, 2]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3, 4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3, 4, 5, 6])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3, 4, 5, 6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3, 4, 5, 6]) X_Dynamic = common.getPowerK(X_Dynamic, [1, 2, 3]) X_DynamicTest = common.getPowerK(X_DynamicTest, [1, 2, 3]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3, 4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3, 4, 5, 6])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3]) print(len(X_DynamicTest), len(Y_DynamicTest)) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3]) X_Dynamic = common.getPowerK(X_Dynamic, [1, 2]) X_DynamicTest = common.getPowerK(X_DynamicTest, [1, 2]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3]) X_Dynamic = common.getPowerK(X_Dynamic, [1, 2, 3]) X_DynamicTest = common.getPowerK(X_DynamicTest, [1, 2, 3]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Non-Dynamic Activities on training X_NonDynamic, Y_NonDynamic = common.getDataSubset(XFull, YFull.flatten(), [4, 5, 6]) #Getting the dataset associated with Non-Dynamic Activities on testing X_NonDynamicTest, Y_NonDynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [4, 5, 6]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_NonDynamic, Y_NonDynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_NonDynamicTest), Y_NonDynamicTest, [4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_NonDynamicTest).flatten(), Y_NonDynamicTest.flatten(), [4, 5, 6])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [4, 5, 6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [4, 5, 6]) X_Dynamic = common.getPowerK(X_Dynamic, [1, 2]) X_DynamicTest = common.getPowerK(X_DynamicTest, [1, 2]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [4, 5, 6])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [4, 5, 6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [4, 5, 6]) X_Dynamic = common.getPowerK(X_Dynamic, [1, 2, 3]) X_DynamicTest = common.getPowerK(X_DynamicTest, [1, 2, 3]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [4, 5, 6])) print(fscore)
# YFullTest = common.parseCSVFile('y_test.csv') ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3, 4, 5, 6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset(XFullTest, YFullTest.flatten(), [1, 2, 3, 4, 5, 6]) print("Done") print("Fitting Data") clf = neighbors.KNeighborsClassifier(n_neighbors=5, weights='distance') clf.fit(X_Dynamic, Y_Dynamic.flatten()) accuracy, precision, recall, fscore, fw = common.checkAccuracy( clf.predict(X_Dynamic), Y_Dynamic, [1, 2, 3, 4, 5, 6]) print(accuracy) print(fscore) print(fw) print( common.createConfusionMatrix( clf.predict(X_Dynamic).flatten(), Y_Dynamic.flatten(), [1, 2, 3, 4, 5, 6])) accuracy, precision, recall, fscore, fw = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3, 4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3, 4, 5, 6])) print(accuracy) print(fscore)
def LDA_onGyroData(): XFull = common.parseFile('../UCI HAR Dataset/train/X_train.txt') YFull = common.parseFile('../UCI HAR Dataset/train/y_train.txt') XFull = common.getGyroFeatures(XFull) #Parsing Full testing dataset XFullTest = common.parseFile('../UCI HAR Dataset/test/X_test.txt') YFullTest = common.parseFile('../UCI HAR Dataset/test/y_test.txt') XFullTest = common.getGyroFeatures(XFullTest) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3,4,5,6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3,4,5,6]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3,4,5,6]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3,4,5,6]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3,4,5,6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3,4,5,6]) X_Dynamic = common.getPowerK(X_Dynamic,[1,2]) X_DynamicTest = common.getPowerK(X_DynamicTest,[1,2]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3,4,5,6]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3,4,5,6]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3,4,5,6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3,4,5,6]) X_Dynamic = common.getPowerK(X_Dynamic,[1,2,3]) X_DynamicTest = common.getPowerK(X_DynamicTest,[1,2,3]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3,4,5,6]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3,4,5,6]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3]) print len(X_DynamicTest),len(Y_DynamicTest) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3]) X_Dynamic = common.getPowerK(X_Dynamic,[1,2]) X_DynamicTest = common.getPowerK(X_DynamicTest,[1,2]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3]) X_Dynamic = common.getPowerK(X_Dynamic,[1,2,3]) X_DynamicTest = common.getPowerK(X_DynamicTest,[1,2,3]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3]) print fscore ################################################################################################################################# #Getting the dataset associated with Non-Dynamic Activities on training X_NonDynamic,Y_NonDynamic = common.getDataSubset(XFull,YFull.flatten(),[4,5,6]) #Getting the dataset associated with Non-Dynamic Activities on testing X_NonDynamicTest,Y_NonDynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[4,5,6]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_NonDynamic, Y_NonDynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_NonDynamicTest),Y_NonDynamicTest,[4,5,6]) print common.createConfusionMatrix(clf.predict(X_NonDynamicTest).flatten(),Y_NonDynamicTest.flatten(),[4,5,6]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[4,5,6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[4,5,6]) X_Dynamic = common.getPowerK(X_Dynamic,[1,2]) X_DynamicTest = common.getPowerK(X_DynamicTest,[1,2]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[4,5,6]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[4,5,6]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[4,5,6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[4,5,6]) X_Dynamic = common.getPowerK(X_Dynamic,[1,2,3]) X_DynamicTest = common.getPowerK(X_DynamicTest,[1,2,3]) #Fitting data using LDA classifier clf = LDA() clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[4,5,6]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[4,5,6]) print fscore
print len(X_nondynamic_train), len(Y_nondynamic_train), Y_nondynamic_train sample_weights=common.getSampleWeights( X_nondynamic_train, Y_nondynamic_train , [4,5,6]) # Get sample weights for non-dynamic Data #print sample_weights ################################################################################################ #Code used for Dynamic Data - Commented for now '''clf = svm.LinearSVC(multi_class='crammer_singer') clf.fit(X_dynamic_train, Y_dynamic_train) Y_predict_dynamic=clf.predict(X_dynamic_test) print type(Y_predict_dynamic), size(Y_predict_dynamic), Y_predict_dynamic prec, rec, f_score=common.checkAccuracy(Y_dynamic_test, Y_predict_dynamic, [1,2,3]) print prec print rec print f_score print common.createConfusionMatrix(Y_predict_dynamic, Y_dynamic_test, [1,2,3]) #print clf.n_support_''' ################################################################################################ # SVM Code for Linear Kernel with sample weights for non-dynamic classes [4,5,6] clf = svm.SVC(kernel='linear') clf.fit(X_nondynamic_train, Y_nondynamic_train, sample_weight=sample_weights) # Fit SVM using sample weights Y_predict_nondynamic=clf.predict(X_nondynamic_test) # Predict Labels for test data print type(Y_predict_nondynamic), size(Y_predict_nondynamic), Y_predict_nondynamic # Print Lenghts and predicted labels for verification prec, rec, f_score=common.checkAccuracy(Y_nondynamic_test, Y_predict_nondynamic, [4,5,6]) # Check accuracy print prec # Print Precision, Recall and f-score print rec print f_score print common.createConfusionMatrix(Y_predict_nondynamic, Y_nondynamic_test, [4,5,6]) # Print Confusion Matrix for the same
Y_test = (common.parseFile('Y_test.txt')) Y_test = Y_test.flatten() # Appropriate Subset of data is got here X_train, Y_train = common.getDataSubset(X_train, Y_train, [4, 5, 6]) X_test, Y_test = common.getDataSubset(X_test, Y_test, [4, 5, 6]) # Accelerometer/Gyroscope Data is got here. COMMENT IF NOT NEEDED X_train = common.getGyroFeatures( X_train, 'features.txt' ) # X_train = common.getAccFeatures( X_train, 'features.txt') X_test = common.getGyroFeatures( X_test, 'features.txt') # X_test = common.getAccFeatures( X_test, 'features.txt') # Blowing up the feature space. COMMENT IF NOT NEEDED X_train = common.getPowerK(X_train, [1, 2]) X_test = common.getPowerK(X_test, [1, 2]) # Weight samples are obtained here. COMMENT IF NOT NEEDED sample_weights = common.getSampleWeights( X_train, Y_train, [4, 5, 6]) # Get sample weights for non-dynamic Data # SVM Training, Prediction. clf = svm.SVC(kernel='linear') clf.fit(X_train, Y_train) Y_predict = clf.predict(X_test) # Check and print accuracy prec, rec, f_score = common.checkAccuracy(Y_test, Y_predict, [4, 5, 6]) print f_score
def LinearSVC_onData(): #Parsing Full training dataset XFull = common.parseFile('../UCI HAR Dataset/train/X_train.txt') YFull = common.parseFile('../UCI HAR Dataset/train/y_train.txt') #Parsing Full testing dataset XFullTest = common.parseFile('../UCI HAR Dataset/test/X_test.txt') YFullTest = common.parseFile('../UCI HAR Dataset/test/y_test.txt') ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3, 4, 5, 6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3, 4, 5, 6]) #Fitting data using LinearSVC classifier clf = LinearSVC(multi_class='crammer_singer') clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy(clf.predict(X_Dynamic), Y_Dynamic, [1, 2, 3, 4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_Dynamic).flatten(), Y_Dynamic.flatten(), [1, 2, 3, 4, 5, 6])) #Fitting data using LinearSVC classifier clf = SVC(kernel="linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy(clf.predict(X_Dynamic), Y_Dynamic, [1, 2, 3, 4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_Dynamic).flatten(), Y_Dynamic.flatten(), [1, 2, 3, 4, 5, 6])) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3, 4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3, 4, 5, 6])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3, 4, 5, 6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3, 4, 5, 6]) X_Dynamic = common.getPowerK(X_Dynamic, [1, 2]) X_DynamicTest = common.getPowerK(X_DynamicTest, [1, 2]) #Fitting data using LinearSVC classifier clf = SVC(kernel="linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3, 4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3, 4, 5, 6])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3, 4, 5, 6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3, 4, 5, 6]) X_Dynamic = common.getPowerK(X_Dynamic, [1, 2, 3]) X_DynamicTest = common.getPowerK(X_DynamicTest, [1, 2, 3]) #Fitting data using LinearSVC classifier clf = SVC(kernel="linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3, 4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3, 4, 5, 6])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3]) print(len(X_DynamicTest), len(Y_DynamicTest)) #Fitting data using LinearSVC classifier clf = SVC(kernel="linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3]) X_Dynamic = common.getPowerK(X_Dynamic, [1, 2]) X_DynamicTest = common.getPowerK(X_DynamicTest, [1, 2]) #Fitting data using LinearSVC classifier clf = SVC(kernel="linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [1, 2, 3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [1, 2, 3]) X_Dynamic = common.getPowerK(X_Dynamic, [1, 2, 3]) X_DynamicTest = common.getPowerK(X_DynamicTest, [1, 2, 3]) #Fitting data using LinearSVC classifier clf = SVC(kernel="linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [1, 2, 3]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [1, 2, 3])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Non-Dynamic Activities on training X_NonDynamic, Y_NonDynamic = common.getDataSubset(XFull, YFull.flatten(), [4, 5, 6]) #Getting the dataset associated with Non-Dynamic Activities on testing X_NonDynamicTest, Y_NonDynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [4, 5, 6]) #Fitting data using LinearSVC classifier clf = SVC(kernel="linear") clf.fit(X_NonDynamic, Y_NonDynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_NonDynamicTest), Y_NonDynamicTest, [4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_NonDynamicTest).flatten(), Y_NonDynamicTest.flatten(), [4, 5, 6])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [4, 5, 6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [4, 5, 6]) X_Dynamic = common.getPowerK(X_Dynamic, [1, 2]) X_DynamicTest = common.getPowerK(X_DynamicTest, [1, 2]) #Fitting data using LinearSVC classifier clf = SVC(kernel="linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [4, 5, 6])) print(fscore) ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic, Y_Dynamic = common.getDataSubset(XFull, YFull.flatten(), [4, 5, 6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest, Y_DynamicTest = common.getDataSubset( XFullTest, YFullTest.flatten(), [4, 5, 6]) X_Dynamic = common.getPowerK(X_Dynamic, [1, 2, 3]) X_DynamicTest = common.getPowerK(X_DynamicTest, [1, 2, 3]) #Fitting data using LinearSVC classifier clf = SVC(kernel="linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision, recall, fscore = common.checkAccuracy( clf.predict(X_DynamicTest), Y_DynamicTest, [4, 5, 6]) print( common.createConfusionMatrix( clf.predict(X_DynamicTest).flatten(), Y_DynamicTest.flatten(), [4, 5, 6])) print(fscore)
def LinearSVC_onData(): #Parsing Full training dataset XFull = common.parseFile('../UCI HAR Dataset/train/X_train.txt') YFull = common.parseFile('../UCI HAR Dataset/train/y_train.txt') #Parsing Full testing dataset XFullTest = common.parseFile('../UCI HAR Dataset/test/X_test.txt') YFullTest = common.parseFile('../UCI HAR Dataset/test/y_test.txt') ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3,4,5,6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3,4,5,6]) #Fitting data using LinearSVC classifier clf = LinearSVC(multi_class='crammer_singer') clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_Dynamic),Y_Dynamic,[1,2,3,4,5,6]) print common.createConfusionMatrix(clf.predict(X_Dynamic).flatten(),Y_Dynamic.flatten(),[1,2,3,4,5,6]) #Fitting data using LinearSVC classifier clf = SVC(kernel = "linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_Dynamic),Y_Dynamic,[1,2,3,4,5,6]) print common.createConfusionMatrix(clf.predict(X_Dynamic).flatten(),Y_Dynamic.flatten(),[1,2,3,4,5,6]) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3,4,5,6]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3,4,5,6]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3,4,5,6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3,4,5,6]) X_Dynamic = common.getPowerK(X_Dynamic,[1,2]) X_DynamicTest = common.getPowerK(X_DynamicTest,[1,2]) #Fitting data using LinearSVC classifier clf = SVC(kernel = "linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3,4,5,6]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3,4,5,6]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3,4,5,6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3,4,5,6]) X_Dynamic = common.getPowerK(X_Dynamic,[1,2,3]) X_DynamicTest = common.getPowerK(X_DynamicTest,[1,2,3]) #Fitting data using LinearSVC classifier clf = SVC(kernel = "linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3,4,5,6]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3,4,5,6]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3]) print len(X_DynamicTest),len(Y_DynamicTest) #Fitting data using LinearSVC classifier clf = SVC(kernel = "linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3]) X_Dynamic = common.getPowerK(X_Dynamic,[1,2]) X_DynamicTest = common.getPowerK(X_DynamicTest,[1,2]) #Fitting data using LinearSVC classifier clf = SVC(kernel = "linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3]) X_Dynamic = common.getPowerK(X_Dynamic,[1,2,3]) X_DynamicTest = common.getPowerK(X_DynamicTest,[1,2,3]) #Fitting data using LinearSVC classifier clf = SVC(kernel = "linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3]) print fscore ################################################################################################################################# #Getting the dataset associated with Non-Dynamic Activities on training X_NonDynamic,Y_NonDynamic = common.getDataSubset(XFull,YFull.flatten(),[4,5,6]) #Getting the dataset associated with Non-Dynamic Activities on testing X_NonDynamicTest,Y_NonDynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[4,5,6]) #Fitting data using LinearSVC classifier clf = SVC(kernel = "linear") clf.fit(X_NonDynamic, Y_NonDynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_NonDynamicTest),Y_NonDynamicTest,[4,5,6]) print common.createConfusionMatrix(clf.predict(X_NonDynamicTest).flatten(),Y_NonDynamicTest.flatten(),[4,5,6]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[4,5,6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[4,5,6]) X_Dynamic = common.getPowerK(X_Dynamic,[1,2]) X_DynamicTest = common.getPowerK(X_DynamicTest,[1,2]) #Fitting data using LinearSVC classifier clf = SVC(kernel = "linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[4,5,6]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[4,5,6]) print fscore ################################################################################################################################# #Getting the dataset associated with Dynamic Activities on training X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[4,5,6]) #Getting the dataset associated with Dynamic Activities on testing X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[4,5,6]) X_Dynamic = common.getPowerK(X_Dynamic,[1,2,3]) X_DynamicTest = common.getPowerK(X_DynamicTest,[1,2,3]) #Fitting data using LinearSVC classifier clf = SVC(kernel = "linear") clf.fit(X_Dynamic, Y_Dynamic.flatten()) precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[4,5,6]) print common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[4,5,6]) print fscore
Y_test = common.parseFile('Y_test.txt') Y_test = Y_test.flatten() X_test, Y_test = common.getDataSubset(X_test, Y_test, [4, 5, 6]) print "Done" print "Fitting Data" clf = tree.DecisionTreeClassifier() clf = clf.fit(X_train, Y_train) print "Done" print "Predicting" predicted = [] for x_test in X_test: predicted.append(clf.predict(x_test)[0]) print "Done" print "Checking accuracy" precision, recall, f_score = common.checkAccuracy( Y_test, predicted, [4, 5, 6]) # Must provide list of relavent labels # print f_score print "Done"
# X_test = common.parseCSVFile('X_test.csv') # Y_test = common.parseCSVFile('y_test.csv') print(X_test.shape) print(Y_test.shape) Y_test= Y_test.flatten() print(Y_test.shape) X_test,Y_test = common.getDataSubset(X_test, Y_test, [1,2,3,4,5,6]) print("Done") print("Fitting Data") clf = tree.DecisionTreeClassifier() clf = clf.fit(X_train, Y_train) print("Done") print("Predicting") accuracy,precision,recall,fscore,fw = common.checkAccuracy(clf.predict(X_train),Y_train,[1,2,3,4,5,6]) print(accuracy) print(fscore) print(fw) print(common.createConfusionMatrix(clf.predict(X_train).flatten(),Y_train,[1,2,3,4,5,6])) accuracy,precision,recall,fscore,fw = common.checkAccuracy(clf.predict(X_test),Y_test,[1,2,3,4,5,6]) print(common.createConfusionMatrix(clf.predict(X_test).flatten(),Y_test,[1,2,3,4,5,6])) print(accuracy) print(fscore) print(fw)
print len(featureArray[0]) ####################### # Training an SVM# print "Training an SVM" #sample_weights = common.getSampleWeights(X_train,Y_train, requiredLabels) clf = svm.SVC(kernel='linear') clf.fit(X_train_expanded, Y_train) #,sample_weight = sample_weights Y_predict=clf.predict(X_test_expanded) print "Done" ####################### # Check Accuracy print "Checking accuracy" precision,recall, f_score = common.checkAccuracy( Y_test , Y_predict , requiredLabels ) print f_score confusionMatrix = common.createConfusionMatrix(Y_predict ,Y_test,requiredLabels) print confusionMatrix print "Done" ######################################################################
y_test_resh = y_test.reshape(y_test.shape[0], y_test.shape[2], -1) y_test_resh_argmax = np.argmax(y_test_resh, axis=2) labels_test_unary = y_test_resh_argmax.reshape(y_test_resh_argmax.size) file_labels_test_unary = 'labels_gd_'+args.dataset+'_'+str(subseq)+'_'+args.net+args.block+'_0503.npy' np.save(file_labels_test_unary,labels_test_unary) y_pred_raw = model.predict(X_test, batch_size=batch_size) y_pred_resh = y_pred_raw.reshape(y_pred_raw.shape[0], y_pred_raw.shape[2], -1) y_pred_resh_argmax = np.argmax(y_pred_resh, axis=2) y_pred = y_pred_resh_argmax.reshape(y_pred_resh_argmax.size) y_pred_prob = y_pred_resh.reshape(y_pred_resh_argmax.size,y_pred_resh.shape[2]) print(y_pred_prob.shape) file_y_pred = 'y_pred_'+args.dataset+'_'+str(subseq)+'_'+args.net+args.block+'_0503.npy' np.save(file_y_pred,y_pred) file_y_pred_prob = 'y_pred_prob_'+args.dataset+'_'+str(subseq)+'_'+args.net+args.block+'_0503.npy' np.save(file_y_pred_prob,y_pred_prob) label_index = list(range(1,act_classes+1)) accuracy,precision,recall,fscore,fw = common.checkAccuracy(labels_test_unary+1,y_pred+1,label_index) print("testing confusionmatrix:") print(common.createConfusionMatrix(labels_test_unary+1,y_pred+1,label_index)) logging.info("testing confusionmatrix:") logging.info('testing confusionmatrix:{}'.format(common.createConfusionMatrix(labels_test_unary+1,y_pred+1,label_index))) print('testing acc:{}'.format(accuracy)) logging.info('testing acc:{}'.format(accuracy)) print('testing fscore:{}'.format(fscore)) logging.info('testing fscore:{}'.format(fscore)) print('testing weighted fscore:{}'.format(fw)) logging.info('testing weighted fscore:{}'.format(fw))
'''clf = svm.LinearSVC(multi_class='crammer_singer') clf.fit(X_dynamic_train, Y_dynamic_train) Y_predict_dynamic=clf.predict(X_dynamic_test) print type(Y_predict_dynamic), size(Y_predict_dynamic), Y_predict_dynamic prec, rec, f_score=common.checkAccuracy(Y_dynamic_test, Y_predict_dynamic, [1,2,3]) print prec print rec print f_score print common.createConfusionMatrix(Y_predict_dynamic, Y_dynamic_test, [1,2,3]) #print clf.n_support_''' ################################################################################################ # SVM Code for Linear Kernel with sample weights for non-dynamic classes [4,5,6] clf = svm.SVC(kernel='linear') clf.fit(X_nondynamic_train, Y_nondynamic_train, sample_weight=sample_weights) # Fit SVM using sample weights Y_predict_nondynamic = clf.predict( X_nondynamic_test) # Predict Labels for test data print type(Y_predict_nondynamic), size( Y_predict_nondynamic ), Y_predict_nondynamic # Print Lenghts and predicted labels for verification prec, rec, f_score = common.checkAccuracy(Y_nondynamic_test, Y_predict_nondynamic, [4, 5, 6]) # Check accuracy print prec # Print Precision, Recall and f-score print rec print f_score print common.createConfusionMatrix( Y_predict_nondynamic, Y_nondynamic_test, [4, 5, 6]) # Print Confusion Matrix for the same
####################### # Training an SVM# print("Training an SVM") #sample_weights = common.getSampleWeights(X_train,Y_train, requiredLabels) clf = svm.SVC(kernel='linear') clf.fit(X_train_expanded, Y_train) #,sample_weight = sample_weights Y_predict = clf.predict(X_test_expanded) print("Done") ####################### # Check Accuracy print("Checking accuracy") precision, recall, f_score = common.checkAccuracy(Y_test, Y_predict, requiredLabels) print(f_score) confusionMatrix = common.createConfusionMatrix(Y_predict, Y_test, requiredLabels) print(confusionMatrix) print("Done") ######################################################################
def main(): # 特征选择 maskSaveName = "SVM-features-mask.out" if (os.path.exists(maskSaveName)): print("存在特征文件,开始读取...") maskInteger = np.loadtxt(maskSaveName) mask = (maskInteger == 1) print("读取完成,准备显示...") print("特征选择数量: {0}".format(sum(mask == 1))) else: print("特征文件不存在~") print("开始特征选择...") start = perf_counter() estimator = svm.SVC(kernel='linear', C=0.9, probability=False) selector = RFECV(estimator, step=5, min_features_to_select=300, cv=20, n_jobs=6) selector = selector.fit(X_Train, Y_Train) mask = selector.get_support() print("特征选择完成!") print("用时 {0:.2f}mins".format((perf_counter() - start) / 60)) print("特征选择数量: {0}".format(sum(mask == 1))) np.savetxt(maskSaveName, mask, fmt='%d') # 画图 plt.matshow(mask.reshape(1, -1), cmap='tab20c_r') plt.title("Feature Selected: {0}".format(sum(mask == 1)), fontsize=14, y=2.5) plt.ylim([-5, 5]) plt.xlabel("Feature Index(Deeper Color means Selected)", fontsize=10) plt.show() print('\n') # 选择特征抽取 print('*' * 20, "特征选择后的数据结果", '*' * 20) X_Train_selected = X_Train[:, mask] X_Test_selected = X_Test[:, mask] clf_selected = svm.SVC(kernel='linear', C=0.9, probability=False) clf_selected.fit(X_Train_selected, Y_Train) Y_predict_selected = clf_selected.predict(X_Test_selected) prec_selected, rec_selected, f_score_selected = common.checkAccuracy( Y_Test, Y_predict_selected) print("训练结果:") print("准确率:{0}\n召回率:{1}\nF1度量:{2}".format(prec_selected, rec_selected, f_score_selected)) print("混淆矩阵:") print(common.createConfusionMatrix(Y_predict_selected, Y_Test)) print('\n') # 原始数据的训练结果 print('*' * 20, "特征选择前的数据结果", '*' * 20) clf = svm.SVC(kernel='linear', C=0.9, probability=False) clf.fit(X_Train, Y_Train) Y_predict = clf.predict(X_Test) prec, rec, f_score = common.checkAccuracy(Y_Test, Y_predict) print("训练结果:") print("准确率:{0}\n召回率:{1}\nF1度量:{2}".format(prec, rec, f_score)) print("混淆矩阵:") print(common.createConfusionMatrix(Y_predict, Y_Test))
X_train = common.parseFile('X_train.txt') Y_train = common.parseFile('Y_train.txt') Y_train = Y_train.flatten() X_train, Y_train = common.getDataSubset(X_train, Y_train, [4, 5, 6]) X_test = common.parseFile('X_test.txt') Y_test = common.parseFile('Y_test.txt') Y_test = Y_test.flatten() X_test, Y_Test = common.getDataSubset(X_test, Y_test, [4, 5, 6]) print("Done") clf = RandomForestClassifier(n_estimators=50) clf = clf.fit(X_train, Y_train) print("Predicting") predicted = [] for x_test in X_test: predicted.append(clf.predict(x_test)[0]) print("Done") print("Checking accuracy") precision, recall, f_score = common.checkAccuracy(predicted, Y_test, [4, 5, 6]) print(f_score)
Y_train = Y_train.flatten() X_train,Y_train = common.getDataSubset(X_train, Y_train, [4,5,6]) X_test = common.parseFile( 'X_test.txt') Y_test = common.parseFile( 'Y_test.txt') Y_test= Y_test.flatten() X_test,Y_Test = common.getDataSubset(X_test, Y_test, [4,5,6]) print "Done" clf = RandomForestClassifier(n_estimators=50) clf = clf.fit(X_train, Y_train) print "Predicting" predicted = [] for x_test in X_test: predicted.append( clf.predict(x_test)[0] ) print "Done" print "Checking accuracy" precision,recall,f_score = common.checkAccuracy( predicted , Y_test , [4,5,6] ) print f_score