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
