def __init__(self, config):
''' initialization '''
self.config = config
self.preprocessor = Preprocessor(self.config, None)
''' general settings '''
self.subdirs = self.config['used_gestures'].split(',')
self.nClasses = int(self.config['used_classes'])
self.samples_per_frame = int(self.config['samples_per_frame'])
''' static settings '''
self.gestures_path = os.path.join(os.path.dirname(__file__), '..',
'..', '..', 'gestures')
def __init__(self, recorder=None, config=None, relative=""):
''' initialization '''
self.config = config
''' general settings '''
self.subdirs = self.config['used_gestures'].split(',')
self.nClasses = int(self.config['used_classes'])
self.samples_per_frame = int(self.config['samples_per_frame'])
''' preprocessing settings '''
self.slice_left = int(self.config['slice_left'])
self.slice_right = int(self.config['slice_right'])
self.wanted_frames = self.samples_per_frame - self.slice_left - self.slice_right
self.framerange = int(self.config['framerange'])
self.timeout = int(self.config['timeout'])
self.smooth = float(self.config['smooth'])
self.use_each_second = int(self.config['use_each_second'])
self.threshold = float(self.config['threshold'])
self.new_preprocess = self.config['new_preprocess'] in ["True", "true", "1"]
''' svm settings '''
self.kernel = self.config['kernel']
self.c = float(self.config['c'])
self.gamma = float(self.config['gamma'])
self.degree = int(self.config['degree'])
self.coef0 = float(self.config['coef0'])
''' static settings '''
self.gestures_path = os.path.join(os.path.dirname(__file__), '..', '..', '..', 'gestures')
self.path = os.path.join(os.path.dirname(__file__), 'svm_trained.pkl')
self.datalist = []
self.datanum = 0
self.gesturefound = 0
self.gestureindex = 0
self.X_train, self.Y_train = None, None
''' initialization methods '''
self.classifier = self.load(self.path)
# create dataloader instance
self.dataloader = Dataloader(self.config)
self.ref_frequency_frame = self.dataloader.load_ref_frequency_frame()
self.dataloader.updatePreprocessorInstance(self.ref_frequency_frame)
# create preprocessor instance
self.preprocessor = Preprocessor(self.config, self.ref_frequency_frame)
# create appstarter instance
self.appstarter = Starter()
def __init__(self, config):
''' initialization '''
self.config = config
self.preprocessor = Preprocessor(self.config, None)
''' general settings '''
self.subdirs = self.config['used_gestures'].split(',')
self.nClasses = int(self.config['used_classes'])
self.samples_per_frame = int(self.config['samples_per_frame'])
''' static settings '''
self.gestures_path = os.path.join(os.path.dirname(__file__), '..', '..', '..', 'gestures')
def __init__(self, recorder=None, config=None, relative=""):
""" initialization """
self.config = config
""" general settings """
self.subdirs = self.config["used_gestures"].split(",")
self.nClasses = int(self.config["used_classes"])
self.samples_per_frame = int(self.config["samples_per_frame"])
""" preprocessing settings """
self.slice_left = int(self.config["slice_left"])
self.slice_right = int(self.config["slice_right"])
self.wanted_frames = self.samples_per_frame - self.slice_left - self.slice_right
self.framerange = int(self.config["framerange"])
self.timeout = int(self.config["timeout"])
self.smooth = float(self.config["smooth"])
self.use_each_second = int(self.config["use_each_second"])
self.threshold = float(self.config["threshold"])
self.new_preprocess = self.config["new_preprocess"] in ["True", "true", "1"]
""" svm settings """
self.kernel = self.config["kernel"]
self.c = float(self.config["c"])
self.gamma = float(self.config["gamma"])
self.degree = int(self.config["degree"])
self.coef0 = float(self.config["coef0"])
""" static settings """
self.gestures_path = os.path.join(os.path.dirname(__file__), "..", "..", "..", "gestures")
self.path = os.path.join(os.path.dirname(__file__), "svm_trained.pkl")
self.datalist = []
self.datanum = 0
self.gesturefound = 0
self.gestureindex = 0
self.X_train, self.Y_train = None, None
""" initialization methods """
self.classifier = self.load(self.path)
# create dataloader instance
self.dataloader = Dataloader(self.config)
self.ref_frequency_frame = self.dataloader.load_ref_frequency_frame()
self.dataloader.updatePreprocessorInstance(self.ref_frequency_frame)
# create preprocessor instance
self.preprocessor = Preprocessor(self.config, self.ref_frequency_frame)
# create appstarter instance
self.appstarter = Starter()
class SVM(IClassifier):
def __init__(self, recorder=None, config=None, relative=""):
""" initialization """
self.config = config
""" general settings """
self.subdirs = self.config["used_gestures"].split(",")
self.nClasses = int(self.config["used_classes"])
self.samples_per_frame = int(self.config["samples_per_frame"])
""" preprocessing settings """
self.slice_left = int(self.config["slice_left"])
self.slice_right = int(self.config["slice_right"])
self.wanted_frames = self.samples_per_frame - self.slice_left - self.slice_right
self.framerange = int(self.config["framerange"])
self.timeout = int(self.config["timeout"])
self.smooth = float(self.config["smooth"])
self.use_each_second = int(self.config["use_each_second"])
self.threshold = float(self.config["threshold"])
self.new_preprocess = self.config["new_preprocess"] in ["True", "true", "1"]
""" svm settings """
self.kernel = self.config["kernel"]
self.c = float(self.config["c"])
self.gamma = float(self.config["gamma"])
self.degree = int(self.config["degree"])
self.coef0 = float(self.config["coef0"])
""" static settings """
self.gestures_path = os.path.join(os.path.dirname(__file__), "..", "..", "..", "gestures")
self.path = os.path.join(os.path.dirname(__file__), "svm_trained.pkl")
self.datalist = []
self.datanum = 0
self.gesturefound = 0
self.gestureindex = 0
self.X_train, self.Y_train = None, None
""" initialization methods """
self.classifier = self.load(self.path)
# create dataloader instance
self.dataloader = Dataloader(self.config)
self.ref_frequency_frame = self.dataloader.load_ref_frequency_frame()
self.dataloader.updatePreprocessorInstance(self.ref_frequency_frame)
# create preprocessor instance
self.preprocessor = Preprocessor(self.config, self.ref_frequency_frame)
# create appstarter instance
self.appstarter = Starter()
def classify(self, data):
if self.classifier != None:
""" start first preprocessing of framedata """
frame = self.preprocessor.preprocess_frame(data)
""" store frame in datalist and increment running index """
self.datalist.append(frame)
self.datanum += 1
""" increment timeout value to allow user to move his hand without any classification after one gesture """
if self.timeout < self.framerange / 2:
self.timeout += 1
if self.timeout == self.framerange / 2:
print "..."
""" check if frame has some relevant information and store this running index """
if np.amax(frame) > 0.0 and self.gesturefound == False and self.timeout == self.framerange / 2:
self.gestureindex = self.datanum
self.gesturefound = True
""" check if framerange is reached and gesturefound is true """
if self.gestureindex + self.framerange == self.datanum and self.gesturefound == True:
self.gestureindex = 0
self.gesturefound = False
self.timeout = 0
normalised_gesture_frame = self.preprocessor.preprocess_frames(self.datalist[-self.framerange :])
try:
""" start actual classification and applicationstarter """
target_prediction = self.classifier.predict(normalised_gesture_frame)[0] # only each second?!?
self.appstarter.controlProgram(target_prediction)
except:
print "some error occured =("
""" delete unneeded frames from datalist """
if self.datanum > self.framerange:
del self.datalist[0]
def loadData(self, filename=""):
""" delegate the task of loading the data to the specific module instance dataloader """
data, targets = self.dataloader.load_gesture_framesets()
return data, targets
def load(self, filename=""):
try:
return joblib.load(filename)
except:
print "file does not exist"
return None
def getName(self):
return "SVM"
def startTraining(self, args=[]):
""" load training data if necessary """
if self.X_train == None or self.Y_train == None:
self.X_train, self.Y_train = self.loadData()
""" start training """
classifier = svm.SVC(kernel=self.kernel, C=self.c, gamma=self.gamma, degree=self.degree, coef0=self.coef0)
classifier.fit(self.X_train, self.Y_train)
""" save classifier and store reference in global variable """
joblib.dump(classifier, self.path, compress=9)
self.classifier = classifier
def startValidation(self):
if self.X_train == None or self.Y_train == None:
self.X_train, self.Y_train = self.loadData()
""" own implementation of confusion matrix """
l = len(self.Y_train) / 10
p = 0
confmat = np.zeros((self.nClasses, self.nClasses))
for i in range(len(self.Y_train)):
if (i + 1) % l == 0:
p += 10
print p, "%"
realclass = self.Y_train[i]
predictedclass = self.classifier.predict(self.X_train[i])[0]
confmat[realclass][predictedclass] += 1
""" compute error """
sum_wrong = 0
sum_all = 0
for i in range(self.nClasses):
for j in range(self.nClasses):
if i != j:
sum_wrong += confmat[i][j]
sum_all += confmat[i][j]
error = sum_wrong / sum_all
print (confmat)
print ("error: " + str(100.0 * error) + "%")
def save(self, filename=""):
pass
def saveData(self, filename=""):
pass
def printClassifier(self):
if self.classifier != None:
pattern = re.compile(r"\s+")
classifierinfo = [
re.sub(pattern, "", part).replace("SVC(", "").replace(")", "").replace("=", " : ")
for part in str(self.classifier).split(",")
]
print 100 * "="
print "Path to saved classifier:\n\t", self.path, "\n"
print "Information about saved classifier:"
for i in classifierinfo:
print "\t", i
print 100 * "="
def show_confusion_matrix(self):
""" method for creating confusion matrix with graphical visualization """
""" callable from separate svm_confusion.py module """
x, y = self.loadData()
a_train, a_test, b_train, b_test = train_test_split(x, y, test_size=0.33, random_state=42)
""" start training """
classifier = svm.SVC(kernel=self.kernel, C=self.c, gamma=self.gamma, degree=self.degree, coef0=self.coef0)
classifier.fit(a_train, b_train)
target_names = ["gesture 0", "gesture 1", "gesture 2", "gesture 3", "gesture 4", "gesture 5", "gesture 6"]
b_pred = self.classifier.predict(a_test)
cm = confusion_matrix(b_test, b_pred)
print 100 * "="
print "Confusion matrix:\n"
print (cm)
print "\nReport:\n"
print (classification_report(b_test, b_pred, target_names=target_names))
definition = """
The precision is the ratio tp / (tp + fp) where tp is the number of true positives and fp the number of false positives.
The precision is intuitively the ability of the classifier not to label as positive a sample that is negative.
The recall is the ratio tp / (tp + fn) where tp is the number of true positives and fn the number of false negatives.
The recall is intuitively the ability of the classifier to find all the positive samples.
The F-beta score can be interpreted as a weighted harmonic mean of the precision and recall,
where an F-beta score reaches its best value at 1 and worst score at 0.
The F-beta score weights recall more than precision by a factor of beta.
beta == 1.0 means recall and precision are equally important.
The support is the number of occurrences of each class in y_true.
"""
print "\nDefinition:"
print definition
print 100 * "="
""" plot confusion matrix in a separate window """
pl.matshow(cm)
pl.title("Confusion matrix")
pl.colorbar()
pl.ylabel("Actual gestures")
pl.xlabel("Predicted gestures")
pl.show()
def updatePreprocessorInstance(self, ref_frequency_frame):
self.preprocessor = Preprocessor(self.config, ref_frequency_frame)
class Dataloader():
def __init__(self, config):
''' initialization '''
self.config = config
self.preprocessor = Preprocessor(self.config, None)
''' general settings '''
self.subdirs = self.config['used_gestures'].split(',')
self.nClasses = int(self.config['used_classes'])
self.samples_per_frame = int(self.config['samples_per_frame'])
''' static settings '''
self.gestures_path = os.path.join(os.path.dirname(__file__), '..', '..', '..', 'gestures')
def updatePreprocessorInstance(self, ref_frequency_frame):
self.preprocessor = Preprocessor(self.config, ref_frequency_frame)
def load_framesets(self, textfile):
#frames_plain = np.asarray(pd.read_csv(textfile, sep=',', header=None))
frames_plain = np.loadtxt(textfile, delimiter=",")
num_framesets = frames_plain.shape[0]
num_samples_total = frames_plain.shape[1]
num_frames_per_frameset = num_samples_total / self.samples_per_frame
framesets = frames_plain.reshape(num_framesets, num_frames_per_frameset, self.samples_per_frame)
return framesets
def load_gesture_framesets(self):
gestures = []
targets = []
for gesture_nr in range(0, self.nClasses):
print "load gesture", gesture_nr
for subdir in self.subdirs:
filepath = os.path.join(self.gestures_path, subdir, 'gesture_' + str(gesture_nr))
files = [allfiles for root, dirs, allfiles in os.walk(filepath)][0]
for textfile in files:
#print "\t",os.path.join(filepath, textfile)
''' load and reshape textfile with gesture data '''
text_file_with_path = os.path.join(self.gestures_path, subdir, 'gesture_' + str(gesture_nr),
textfile)
gesture_framesets_plain = self.load_framesets(text_file_with_path)
''' reduce each framewindow from 64 to 40 values '''
gesture_framesets = self.preprocessor.slice_framesets(gesture_framesets_plain)
''' create one gesture frame from relevant frames '''
for frameset_nr in range(0, gesture_framesets.shape[0]):
''' start preprocessing of frameset '''
normalised_gesture_frame = self.preprocessor.preprocess_frames(gesture_framesets[frameset_nr])
''' append gestureframe and targetclass to their corresponding arrays '''
gestures.append(normalised_gesture_frame)
targets.append(gesture_nr)
''' convert to numpy array '''
data = np.array(gestures)
targets = np.array(targets)
print data.shape, targets.shape
return data, targets
def load_ref_frequency_frame(self):
''' load referencefrequency data with 18500Hz '''
ref_frequency_txt_file = os.path.join(self.gestures_path, 'Benjamin', 'gesture_6', '1389637026.txt')
ref_frequency_framesets_plain = self.load_framesets(ref_frequency_txt_file)
''' normalse referencefrequency datadarames '''
ref_frequency_framesets = self.preprocessor.normalise_framesets(ref_frequency_framesets_plain, 0)
''' reduce to one single average referencefrequency frame and slice to 40 datavalues '''
ref_frequency_avg_frameset = np.mean(ref_frequency_framesets, axis=1)
ref_frequency_frame = self.preprocessor.slice_frame(np.mean(ref_frequency_avg_frameset, axis=0))
return ref_frequency_frame
def updatePreprocessorInstance(self, ref_frequency_frame):
self.preprocessor = Preprocessor(self.config, ref_frequency_frame)
class Dataloader():
def __init__(self, config):
''' initialization '''
self.config = config
self.preprocessor = Preprocessor(self.config, None)
''' general settings '''
self.subdirs = self.config['used_gestures'].split(',')
self.nClasses = int(self.config['used_classes'])
self.samples_per_frame = int(self.config['samples_per_frame'])
''' static settings '''
self.gestures_path = os.path.join(os.path.dirname(__file__), '..',
'..', '..', 'gestures')
def updatePreprocessorInstance(self, ref_frequency_frame):
self.preprocessor = Preprocessor(self.config, ref_frequency_frame)
def load_framesets(self, textfile):
#frames_plain = np.asarray(pd.read_csv(textfile, sep=',', header=None))
frames_plain = np.loadtxt(textfile, delimiter=",")
num_framesets = frames_plain.shape[0]
num_samples_total = frames_plain.shape[1]
num_frames_per_frameset = num_samples_total / self.samples_per_frame
framesets = frames_plain.reshape(num_framesets,
num_frames_per_frameset,
self.samples_per_frame)
return framesets
def load_gesture_framesets(self):
gestures = []
targets = []
for gesture_nr in range(0, self.nClasses):
print "load gesture", gesture_nr
for subdir in self.subdirs:
filepath = os.path.join(self.gestures_path, subdir,
'gesture_' + str(gesture_nr))
files = [
allfiles for root, dirs, allfiles in os.walk(filepath)
][0]
for textfile in files:
#print "\t",os.path.join(filepath, textfile)
''' load and reshape textfile with gesture data '''
text_file_with_path = os.path.join(
self.gestures_path, subdir,
'gesture_' + str(gesture_nr), textfile)
gesture_framesets_plain = self.load_framesets(
text_file_with_path)
''' reduce each framewindow from 64 to 40 values '''
gesture_framesets = self.preprocessor.slice_framesets(
gesture_framesets_plain)
''' create one gesture frame from relevant frames '''
for frameset_nr in range(0, gesture_framesets.shape[0]):
''' start preprocessing of frameset '''
normalised_gesture_frame = self.preprocessor.preprocess_frames(
gesture_framesets[frameset_nr])
''' append gestureframe and targetclass to their corresponding arrays '''
gestures.append(normalised_gesture_frame)
targets.append(gesture_nr)
''' convert to numpy array '''
data = np.array(gestures)
targets = np.array(targets)
print data.shape, targets.shape
return data, targets
def load_ref_frequency_frame(self):
''' load referencefrequency data with 18500Hz '''
ref_frequency_txt_file = os.path.join(self.gestures_path, 'Benjamin',
'gesture_6', '1389637026.txt')
ref_frequency_framesets_plain = self.load_framesets(
ref_frequency_txt_file)
''' normalse referencefrequency datadarames '''
ref_frequency_framesets = self.preprocessor.normalise_framesets(
ref_frequency_framesets_plain, 0)
''' reduce to one single average referencefrequency frame and slice to 40 datavalues '''
ref_frequency_avg_frameset = np.mean(ref_frequency_framesets, axis=1)
ref_frequency_frame = self.preprocessor.slice_frame(
np.mean(ref_frequency_avg_frameset, axis=0))
return ref_frequency_frame
class SVM(IClassifier):
def __init__(self, recorder=None, config=None, relative=""):
''' initialization '''
self.config = config
''' general settings '''
self.subdirs = self.config['used_gestures'].split(',')
self.nClasses = int(self.config['used_classes'])
self.samples_per_frame = int(self.config['samples_per_frame'])
''' preprocessing settings '''
self.slice_left = int(self.config['slice_left'])
self.slice_right = int(self.config['slice_right'])
self.wanted_frames = self.samples_per_frame - self.slice_left - self.slice_right
self.framerange = int(self.config['framerange'])
self.timeout = int(self.config['timeout'])
self.smooth = float(self.config['smooth'])
self.use_each_second = int(self.config['use_each_second'])
self.threshold = float(self.config['threshold'])
self.new_preprocess = self.config['new_preprocess'] in ["True", "true", "1"]
''' svm settings '''
self.kernel = self.config['kernel']
self.c = float(self.config['c'])
self.gamma = float(self.config['gamma'])
self.degree = int(self.config['degree'])
self.coef0 = float(self.config['coef0'])
''' static settings '''
self.gestures_path = os.path.join(os.path.dirname(__file__), '..', '..', '..', 'gestures')
self.path = os.path.join(os.path.dirname(__file__), 'svm_trained.pkl')
self.datalist = []
self.datanum = 0
self.gesturefound = 0
self.gestureindex = 0
self.X_train, self.Y_train = None, None
''' initialization methods '''
self.classifier = self.load(self.path)
# create dataloader instance
self.dataloader = Dataloader(self.config)
self.ref_frequency_frame = self.dataloader.load_ref_frequency_frame()
self.dataloader.updatePreprocessorInstance(self.ref_frequency_frame)
# create preprocessor instance
self.preprocessor = Preprocessor(self.config, self.ref_frequency_frame)
# create appstarter instance
self.appstarter = Starter()
def classify(self, data):
if self.classifier != None:
''' start first preprocessing of framedata '''
frame = self.preprocessor.preprocess_frame(data)
''' store frame in datalist and increment running index '''
self.datalist.append(frame)
self.datanum += 1
''' increment timeout value to allow user to move his hand without any classification after one gesture '''
if self.timeout < self.framerange / 2:
self.timeout += 1
if self.timeout == self.framerange / 2:
print "..."
''' check if frame has some relevant information and store this running index '''
if np.amax(frame) > 0.0 and self.gesturefound == False and self.timeout == self.framerange / 2:
self.gestureindex = self.datanum
self.gesturefound = True
''' check if framerange is reached and gesturefound is true '''
if self.gestureindex + self.framerange == self.datanum and self.gesturefound == True:
self.gestureindex = 0
self.gesturefound = False
self.timeout = 0
normalised_gesture_frame = self.preprocessor.preprocess_frames(self.datalist[-self.framerange:])
try:
''' start actual classification and applicationstarter '''
target_prediction = self.classifier.predict(normalised_gesture_frame)[0] # only each second?!?
self.appstarter.controlProgram(target_prediction)
except:
print "some error occured =("
''' delete unneeded frames from datalist '''
if self.datanum > self.framerange:
del self.datalist[0]
def loadData(self, filename=""):
''' delegate the task of loading the data to the specific module instance dataloader '''
data, targets = self.dataloader.load_gesture_framesets()
return data, targets
def load(self, filename=""):
try:
return joblib.load(filename)
except:
print "file does not exist"
return None
def getName(self):
return "SVM"
def startTraining(self, args=[]):
''' load training data if necessary '''
if self.X_train == None or self.Y_train == None:
self.X_train, self.Y_train = self.loadData()
''' start training '''
classifier = svm.SVC(kernel=self.kernel, C=self.c, gamma=self.gamma, degree=self.degree, coef0=self.coef0)
classifier.fit(self.X_train, self.Y_train)
''' save classifier and store reference in global variable '''
joblib.dump(classifier, self.path, compress=9)
self.classifier = classifier
def startValidation(self):
if self.X_train == None or self.Y_train == None:
self.X_train, self.Y_train = self.loadData()
''' own implementation of confusion matrix '''
l = len(self.Y_train) / 10
p = 0
confmat = np.zeros((self.nClasses, self.nClasses))
for i in range(len(self.Y_train)):
if (i + 1) % l == 0:
p += 10
print p, "%"
realclass = self.Y_train[i]
predictedclass = self.classifier.predict(self.X_train[i])[0]
confmat[realclass][predictedclass] += 1
''' compute error '''
sum_wrong = 0
sum_all = 0
for i in range(self.nClasses):
for j in range(self.nClasses):
if i != j:
sum_wrong += confmat[i][j]
sum_all += confmat[i][j]
error = sum_wrong / sum_all
print(confmat)
print("error: " + str(100. * error) + "%")
def save(self, filename=""):
pass
def saveData(self, filename=""):
pass
def printClassifier(self):
if self.classifier != None:
pattern = re.compile(r'\s+')
classifierinfo = [re.sub(pattern, '', part).replace("SVC(", "").replace(")", "").replace("=", " : ") for
part in str(self.classifier).split(',')]
print 100 * "="
print "Path to saved classifier:\n\t", self.path, "\n"
print "Information about saved classifier:"
for i in classifierinfo:
print "\t", i
print 100 * "="
def show_confusion_matrix(self):
''' method for creating confusion matrix with graphical visualization '''
''' callable from separate svm_confusion.py module '''
x, y = self.loadData()
a_train, a_test, b_train, b_test = train_test_split(x, y, test_size=0.33, random_state=42)
''' start training '''
classifier = svm.SVC(kernel=self.kernel, C=self.c, gamma=self.gamma, degree=self.degree, coef0=self.coef0)
classifier.fit(a_train, b_train)
target_names = ["gesture 0", "gesture 1", "gesture 2", "gesture 3", "gesture 4", "gesture 5", "gesture 6"]
b_pred = self.classifier.predict(a_test)
cm = confusion_matrix(b_test, b_pred)
print 100 * "="
print "Confusion matrix:\n"
print(cm)
print "\nReport:\n"
print(classification_report(b_test, b_pred, target_names=target_names))
definition = '''
The precision is the ratio tp / (tp + fp) where tp is the number of true positives and fp the number of false positives.
The precision is intuitively the ability of the classifier not to label as positive a sample that is negative.
The recall is the ratio tp / (tp + fn) where tp is the number of true positives and fn the number of false negatives.
The recall is intuitively the ability of the classifier to find all the positive samples.
The F-beta score can be interpreted as a weighted harmonic mean of the precision and recall,
where an F-beta score reaches its best value at 1 and worst score at 0.
The F-beta score weights recall more than precision by a factor of beta.
beta == 1.0 means recall and precision are equally important.
The support is the number of occurrences of each class in y_true.
'''
print "\nDefinition:"
print definition
print 100 * "="
''' plot confusion matrix in a separate window '''
pl.matshow(cm)
pl.title('Confusion matrix')
pl.colorbar()
pl.ylabel('Actual gestures')
pl.xlabel('Predicted gestures')
pl.show()
