Exemplo n.º 1
0
          ).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
#X_nondynamic_train_6, Y_nondynamic_train_6=common.getDataSubset(X_train, Y_train, [6]) # Used earlier to get Sub data for just 6th label
#X_nondynamic_test_6, Y_nondynamic_test_6=common.getDataSubset(X_test, Y_test, [6])
#Y_nondynamic_train_sublabels=common.convertLabel(Y_nondynamic_train, [4,5], [6])	# Used earlier to convert [4,5] to [1] and [6] to [0]
#Y_nondynamic_test_sublabels=common.convertLabel(Y_nondynamic_test, [4,5], [6])

print len(X_dynamic_train), len(
    Y_dynamic_train
), Y_dynamic_train  # Printing lenghts and Labels extracted for verification
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
Exemplo n.º 2
0
# Hyper-parameters #

#top_N = 5

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

print("Computing means and covariances")
print("Get trainSubjects&noDynamic static data...")
trainSubjects = [
    1, 3, 5, 6, 7, 8, 11, 14, 15, 16, 17, 19, 21, 22, 23, 25, 26, 27, 28, 29,
    30
]
requiredLabels = [1, 2, 3, 4, 5, 6]
# 每一行原数据用上他们的幂次形成2倍大小的特征矩阵
X_train = common.getPowerK(X_train, [1, 2])

mean_array = []
cov_array = []
label_array = []

for i in trainSubjects:
    for j in requiredLabels:

        # Get subject info
        X_train_new, Y_train_new, subjectInfo = common.getSubjectData(
            X_train, Y_train, [i])

        # Get Data Subset #
        X_train_new, Y_train_new = common.getDataSubset(
            X_train, Y_train, requiredLabels)
Exemplo n.º 3
0
def LDA_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 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)
Y_test = Y_test.flatten()	

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

#top_N = 5 

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

print "Computing means and covariances"

trainSubjects = [1,3,5,6,7,8,11,14,15,16,17,19,21,22,23,25,26,27,28,29,30]
requiredLabels = [4,5,6]

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

mean_array = []
cov_array = []
label_array = []

for i in trainSubjects:
	for j in requiredLabels:

		# Get subject info
		X_train_new , Y_train_new , subjectInfo= common.getSubjectData(X_train,Y_train,[i])

		# Get Data Subset #
		X_train_new , Y_train_new = common.getDataSubset(X_train, Y_train, requiredLabels)

		mean,cov = common.getDistribution(X_train_new,Y_train_new,j)
Exemplo n.º 5
0
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
#X_nondynamic_train_6, Y_nondynamic_train_6=common.getDataSubset(X_train, Y_train, [6]) # Used earlier to get Sub data for just 6th label
#X_nondynamic_test_6, Y_nondynamic_test_6=common.getDataSubset(X_test, Y_test, [6])
#Y_nondynamic_train_sublabels=common.convertLabel(Y_nondynamic_train, [4,5], [6])	# Used earlier to convert [4,5] to [1] and [6] to [0]
#Y_nondynamic_test_sublabels=common.convertLabel(Y_nondynamic_test, [4,5], [6])

print len(X_dynamic_train), len(Y_dynamic_train), Y_dynamic_train		# Printing lenghts and Labels extracted for verification
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
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
Exemplo n.º 7
0
def LDA_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 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