Esempi in Python per parseFile

Esempio n. 1

File: AdaBoost.py Progetto: BrightHammer/Human-Activity-Recognition

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)

Esempio n. 2

File: ANN.py Progetto: ztc125521/Human-Activity-Recognition

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

Esempio n. 3

File: AdaBoost.py Progetto: Ninja91/Human-Activity-Recognition

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

Esempio n. 4

File: QDA.py Progetto: ztc125521/Human-Activity-Recognition

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

Esempio n. 5

File: AdaBoost.py Progetto: BrightHammer/Human-Activity-Recognition

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)

Esempio n. 6

File: AdaBoost.py Progetto: Ninja91/Human-Activity-Recognition

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

Esempio n. 7

File: ANN.py Progetto: Ninja91/Human-Activity-Recognition

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

Esempio n. 8

File: knn.py Progetto: zhangzhao156/Human-Activity-Recognition-Codes-Datasets

## Author: Hariharan Seshadri ##
## This program uses the KNN classifer to classify human activities ##

import numpy as np
from sklearn import neighbors, datasets
import common

###########################################################

print("Parsing")
#UCI DATASET1
# XFull = common.parseFile('X_train.txt')
# YFull = common.parseFile('y_train.txt')
#UCI DATASET2
XFull = common.parseFile('hapt/X_train.txt')
YFull = common.parseFile('hapt/y_train.txt')
#WISDM DATASET
# XFull = common.parseCSVFile('X_train.csv')
# YFull = common.parseCSVFile('y_train.csv')
#Parsing Full testing dataset
# XFullTest = common.parseFile('X_test.txt')
# YFullTest = common.parseFile('y_test.txt')
XFullTest = common.parseFile('hapt/X_test.txt')
YFullTest = common.parseFile('hapt/y_test.txt')
# XFullTest = common.parseCSVFile('X_test.csv')
# 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

Esempio n. 9

File: SVM-featureSelect.py Progetto: BrightHammer/Human-Activity-Recognition

# -*- coding: utf-8 -*-
"""
@author: MelonEater
"""

import numpy as np
import common
from sklearn.feature_selection import RFECV
from sklearn import svm
import matplotlib.pyplot as plt
from time import perf_counter
import os

# 写入数据
print('*' * 20, "程序开始-读取数据", '*' * 20)
X_Train = common.parseFile('../UCI HAR Dataset/train/X_train.txt')
Y_Train = common.parseFile('../UCI HAR Dataset/train/y_train.txt').flatten()
X_Test = common.parseFile('../UCI HAR Dataset/test/X_test.txt')
Y_Test = common.parseFile('../UCI HAR Dataset/test/y_test.txt').flatten()


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:

Esempio n. 10

File: LDA.py Progetto: Ninja91/Human-Activity-Recognition

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

Esempio n. 11

#from sympy import Symbol,cos,sin
from operator import *
from numpy.linalg import *
import time
import ctypes
from sklearn import *
from collections import defaultdict
import common
from matplotlib import pyplot as plt
# Prints the numbers in float instead of scientific format
set_printoptions(suppress=True)

filename = '../UCI HAR Dataset/'  # Dataset Used (Change as per your computer's path)
#--------------------------------------------------------------------------------------------#

X_train = common.parseFile(filename + 'train/X_train.txt')  # Read X Train
Y_train = (common.parseFile(filename + 'train/y_train.txt')
           ).flatten()  # Read Y Train and flatten it to 1D array
X_test = common.parseFile(filename + 'test/X_test.txt')  # Read X Test
Y_test = (common.parseFile(filename + 'test/y_test.txt')
          ).flatten()  # Read Y test and flatten it to 1D array

print len(X_train), len(Y_train)  # Printing Lengths of Train and Test Data
print len(X_test), len(Y_test)

X_dynamic_train, Y_dynamic_train = common.getDataSubset(
    X_train, Y_train, [1, 2, 3])  # Get Train sub data for [1,2,3]
X_nondynamic_train, Y_nondynamic_train = common.getDataSubset(
    X_train, Y_train, [4, 5, 6])  # Get Train sub data for [4,5,6]

X_dynamic_test, Y_dynamic_test = common.getDataSubset(

Esempio n. 12

File: decisionTree.py Progetto: zhangzhao156/Human-Activity-Recognition-Codes-Datasets

## Author: Hariharan Seshadri ##
## This script tries to distinguish between SITTING,STANDING, and LAYING labels using Decision Trees ##

import numpy as np
from sklearn import tree
import common


print("Parsing")
#UCI dataset1
# X_train = common.parseFile( 'X_train.txt')
# Y_train = common.parseFile( 'y_train.txt')
#UCI dataset2
X_train = common.parseFile( 'hapt/X_train.txt')
Y_train = common.parseFile( 'hapt/y_train.txt')
#wisdm dataset
# X_train = common.parseCSVFile('X_train.csv')
# Y_train = common.parseCSVFile('y_train.csv')
Y_train = Y_train.flatten()
X_train,Y_train = common.getDataSubset(X_train, Y_train, [1,2,3,4,5,6])

# X_test = common.parseFile('X_test.txt')
# Y_test = common.parseFile('y_test.txt')
X_test = common.parseFile('hapt/X_test.txt')
Y_test = common.parseFile('hapt/y_test.txt')
# 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)

Esempio n. 13

File: SVM.py Progetto: Ninja91/Human-Activity-Recognition

#from sympy import Symbol,cos,sin
from operator import *
from numpy.linalg import *
import time
import ctypes
from sklearn import *
from collections import defaultdict
import common
from matplotlib import pyplot as plt
# Prints the numbers in float instead of scientific format
set_printoptions(suppress=True)

filename='../UCI HAR Dataset/' 							# Dataset Used (Change as per your computer's path)
#--------------------------------------------------------------------------------------------#

X_train=common.parseFile(filename+'train/X_train.txt')				# Read X Train 
Y_train=(common.parseFile(filename+'train/y_train.txt')).flatten()		# Read Y Train and flatten it to 1D array
X_test=common.parseFile(filename+'test/X_test.txt')				# Read X Test
Y_test=(common.parseFile(filename+'test/y_test.txt')).flatten()			# Read Y test and flatten it to 1D array

print len(X_train), len(Y_train)						# Printing Lengths of Train and Test Data
print len(X_test), len(Y_test)

X_dynamic_train, Y_dynamic_train=common.getDataSubset(X_train, Y_train, [1,2,3])	# Get Train sub data for [1,2,3]
X_nondynamic_train, Y_nondynamic_train=common.getDataSubset(X_train, Y_train, [4,5,6])  # Get Train sub data for [4,5,6]

X_dynamic_test, Y_dynamic_test=common.getDataSubset(X_test, Y_test, [1,2,3])		# Get Test sub data for [1,2,3]
X_nondynamic_test, Y_nondynamic_test=common.getDataSubset(X_test, Y_test, [4,5,6])	# Get Test sub data for [4,5,6]

X_nondynamic_train=common.getPowerK(X_nondynamic_train, [1,2])				# Convert X Train to X+X^2
X_nondynamic_test=common.getPowerK(X_nondynamic_test, [1,2])				# Convert X Test to X+X^2

Esempio n. 14

File: subjectAnalysis_EuclideanDistance.py Progetto: ztc125521/Human-Activity-Recognition

# Author - Hariharan Seshadri #

import common
import math
import numpy as np
from sklearn import *
import scipy
from collections import Counter

print "\n"

#######################
# Parse the files

X_train = common.parseFile('X_train.txt')
Y_train = (common.parseFile('Y_train.txt'))
Y_train = Y_train.flatten()

X_test = common.parseFile('X_test.txt')
Y_test = (common.parseFile('Y_test.txt'))
Y_test = Y_test.flatten()

#######################
# Pre-processing of data

print "Pre_processing"

X_test, Y_test = common.getDataSubset(X_test, Y_test, [4, 5])

X_train = common.getPowerK(X_train, [1, 2])
X_test = common.getPowerK(X_test, [1, 2])

Esempio n. 15

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)

Esempio n. 16

File: knn_dynamic.py Progetto: Ninja91/Human-Activity-Recognition

## Author: Hariharan Seshadri ##
## This program uses the KNN classifer to distinguish between dynamic/non-dynamic activities ##

import numpy as np
from sklearn import neighbors, datasets
import common

###########################################################

print "Parsing"

X_train = common.parseFile( 'X_train.txt')
Y_train = common.parseFile( 'Y_train.txt')
Y_train = Y_train.flatten()
Y_train = common.convertLabel( Y_train )

X_test = common.parseFile( 'X_test.txt')
Y_test = common.parseFile( 'Y_test.txt')
Y_test= Y_test.flatten()
Y_test = common.convertLabel( Y_test )


print "Done"

print "Fitting Data"

ne = []
mean = []


for i in range(5,55,5):

Esempio n. 17

File: SVM_nitin.py Progetto: BrightHammer/Human-Activity-Recognition

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)

Esempio n. 18

# Author - Hariharan Seshadri #

import common
import math
import numpy as np
from sklearn import *
import scipy
from collections import Counter
import copy

print("\n")

#######################
# Parse the files #

X_train = common.parseFile('../UCI HAR Dataset/train/X_train.txt')
Y_train = common.parseFile('../UCI HAR Dataset/train/Y_train.txt')
Y_train = Y_train.flatten()
subject_train = common.parseFile('../UCI HAR Dataset/train/subject_train.txt')
subject_train = subject_train.flatten()

X_test = common.parseFile('../UCI HAR Dataset/test/X_test.txt')
Y_test = common.parseFile('../UCI HAR Dataset/test/Y_test.txt')
Y_test = Y_test.flatten()

######################
# Hyper-parameters #

#top_N = 5

#######################

Esempio n. 19

File: subjectAnalysisSVM.py Progetto: ztc125521/Human-Activity-Recognition

# Author - Hariharan Seshadri #

import common
import math
import numpy as np
from sklearn import *
import scipy
from collections import Counter
import copy

print "\n"

#######################
# Parse the files #

X_train = common.parseFile('X_train.txt')
Y_train = common.parseFile('Y_train.txt')
Y_train = Y_train.flatten()
subject_train = common.parseFile('subject_train.txt')
subject_train = subject_train.flatten()

X_test = common.parseFile('X_test.txt')
Y_test = common.parseFile('Y_test.txt')
Y_test = Y_test.flatten()

######################
# Hyper-parameters #

#top_N = 5

#######################

Esempio n. 20

@author: MelonEater
"""

from sklearn.datasets import load_iris
import xgboost as xgb
from xgboost import plot_importance
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score  # 准确率
import common
## 记载样本数据集
#iris = load_iris()
#X,y = iris.data,iris.target
## 数据集分割
#X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=123457)
X_train = common.parseFile('../UCI HAR Dataset/train/X_train.txt')
y_train = (
    common.parseFile('../UCI HAR Dataset/train/y_train.txt')).flatten() - 1
X_test = common.parseFile('../UCI HAR Dataset/test/X_test.txt')
y_test = (common.parseFile('../UCI HAR Dataset/test/y_test.txt')).flatten() - 1
# 算法参数
params = {
    'booster': 'gbtree',
    'objective': 'multi:softmax',
    'num_class': 6,
    'gamma': 0.1,
    'max_depth': 6,
    'lambda': 2,
    'subsample': 0.7,
    'colsample_bytree': 0.7,
    'min_child_weight': 3,

Esempio n. 21

File: SVM_nitin.py Progetto: Ninja91/Human-Activity-Recognition

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