本文整理汇总了Python中weka.classifiers.Classifier.classify_instance方法的典型用法代码示例。如果您正苦于以下问题:Python Classifier.classify_instance方法的具体用法?Python Classifier.classify_instance怎么用?Python Classifier.classify_instance使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类weka.classifiers.Classifier
的用法示例。
在下文中一共展示了Classifier.classify_instance方法的14个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: main
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
def main(args):
"""
Trains a J48 classifier on a training set and outputs the predicted class and class distribution alongside the
actual class from a test set. Class attribute is assumed to be the last attribute.
:param args: the commandline arguments (train and test datasets)
:type args: list
"""
# load a dataset
helper.print_info("Loading train: " + args[1])
loader = Loader(classname="weka.core.converters.ArffLoader")
train = loader.load_file(args[1])
train.class_index = train.num_attributes - 1
helper.print_info("Loading test: " + args[2])
test = loader.load_file(args[2])
test.class_is_last()
# classifier
cls = Classifier(classname="weka.classifiers.trees.J48")
cls.build_classifier(train)
# output predictions
print("# - actual - predicted - error - distribution")
for index, inst in enumerate(test):
pred = cls.classify_instance(inst)
dist = cls.distribution_for_instance(inst)
print(
"%d - %s - %s - %s - %s" %
(index+1,
inst.get_string_value(inst.class_index),
inst.class_attribute.value(int(pred)),
"yes" if pred != inst.get_value(inst.class_index) else "no",
str(dist.tolist())))
示例2: python_weka
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
class python_weka(object):
def __init__(self, input_x, input_y, labels):
self.input_x = input_x
self.input_y = input_y
self.labels = labels
def write_arff(self, filename, relation, train_or_predict, input_x, input_y=None):
f = open(filename, "w")
f.write("@relation " + relation + "\n")
for i in self.labels:
train_or_predict += 1
if train_or_predict == len(self.labels):
break
f.write("@attribute " + i + " " + self.labels[i] + "\n")
f.write("\n")
f.write("@data" + "\n")
for i in range(len(input_x)):
for j in input_x[i]:
f.write(str(j) + " ")
if train_or_predict == 0:
f.write(str(input_y[i]))
else:
f.write(str(0))
f.write("\n")
f.close()
def train(self):
filename = "train.arff"
self.write_arff(filename, "train", 0, self.input_x, self.input_y)
loader = Loader(classname="weka.core.converters.ArffLoader")
data = loader.load_file(filename)
data.class_is_last()
self.cls = Classifier(classname="weka.classifiers.meta.Bagging", options=["-S", "5"])
self.cls.build_classifier(data)
os.remove(filename)
def predict(self, test_data):
filename = "test.arff"
self.write_arff(filename, "test", 0, test_data)
loader = Loader(classname="weka.core.converters.ArffLoader")
data = loader.load_file(filename)
data.class_is_last()
# evl = Evaluation(data)
# evl.evaluate_model(self.cls,data)
# data.set_class_label(data.numAttributes() - 1)
# data.setClassIndex(data.numAttributes() - 1)
result = []
for index, inst in enumerate(data):
pred = self.cls.classify_instance(inst)
dist = self.cls.distribution_for_instance(inst)
result.append(dist[0])
# print(str(index+1) + ": label index=" + str(pred) + ", class distribution=" + str(dist))
# print str(index+1) + 'dist:'+ str(dist)
os.remove(filename)
return result
示例3: assign_classify
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
def assign_classify(file_location, output="classified.out", model="naivebayes.model"):
data = read_csv_file(file_location)
jvm.start()
# load clusters
obj = serialization.read(model)
classifier = Classifier(jobject=obj)
# create file with cluster group
with open(output, 'w') as cluster_file:
for index, attrs in enumerate(data):
inst = Instance.create_instance(attrs[1:])
pred = classifier.classify_instance(inst)
print(str(index + 1) + ": label index=" + str(pred))
jvm.stop()
示例4: playback_speed_checker
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
def playback_speed_checker(inputFile, dirRef):
TRAINING_ARFF = 'dataset_playback.arff'
inputRef = ""
# Start JVM
jvm.start()
jvm.start(system_cp=True, packages=True)
jvm.start(max_heap_size="512m")
# Find reference file
for file in os.listdir(dirRef):
if str(file).find(str(os.path.basename(inputFile))) != -1:
inputRef = os.path.join(dirRef, file)
break
# Calculation distance
(result, distance) = dtw_checker(inputFile, inputRef)
# Loading data
loader = Loader(classname="weka.core.converters.ArffLoader")
data = loader.load_file(TRAINING_ARFF)
data.class_is_last() # set class attribute
# Train the classifier
#cls = Classifier(classname="weka.classifiers.functions.SMO")
cls = Classifier(classname="weka.classifiers.trees.J48", options = ["-C", "0.3", "-M", "10"])
cls.build_classifier(data)
# Classify instance
speed_instance = Instance.create_instance(numpy.ndarray(distance), classname='weka.core.DenseInstance', weight=1.0)
speed_instance.dataset = data
# Classify instance
speed_flag = cls.classify_instance(speed_instance)
if (distance == 0):
speed_class = 'nominal'
else:
if speed_flag == 0: speed_class = 'down_speed'
if speed_flag == 0: speed_class = 'up_speed'
# print os.path.basename(inputFile) + ' --- ' + speed_class
# Stop JVM
jvm.stop()
print "SPEED IS: " + speed_class
return speed_class
示例5: predict
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
def predict(attributes):
jvm.start()
file_path = print_to_file(attributes)
# load the saved model
objects = serialization.read_all("/Users/hosyvietanh/Desktop/data_mining/trained_model.model")
classifier = Classifier(jobject=objects[0])
loader = Loader(classname="weka.core.converters.ArffLoader")
data = loader.load_file(file_path)
data.class_is_last()
for index, inst in enumerate(data):
pred = classifier.classify_instance(inst)
dist = classifier.distribution_for_instance(inst)
return int(pred)
jvm.stop()
示例6: riaa_checker
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
def riaa_checker(inputFile):
TRAINING_ARFF = 'C:\Users\ASUS\Desktop\IGNASI\SMC\Workspace\dataset_riaa.arff'
# Start JVM
jvm.start()
jvm.start(system_cp=True, packages=True)
jvm.start(max_heap_size="512m")
# Calculation of bark bands information
(absolute_bark, relative_bark, bark_ratios) = compute_bark_spectrum(inputFile)
# Loading data
loader = Loader(classname="weka.core.converters.ArffLoader")
data = loader.load_file(TRAINING_ARFF)
data.class_is_last() # set class attribute
# Train the classifier
cls = Classifier(classname="weka.classifiers.functions.SMO")
#cls = Classifier(classname="weka.classifiers.trees.J48", options = ["-C", "0.3", "-M", "10"])
cls.build_classifier(data)
# Classify instance
bark_instance = Instance.create_instance(bark_ratios, classname='weka.core.DenseInstance', weight=1.0)
bark_instance.dataset = data
# Classify instance
riaa_flag = cls.classify_instance(bark_instance)
if riaa_flag == 0:
riaa_class = 'riaa_ok'
else:
riaa_class = 'riaa_ko'
# print os.path.basename(inputFile) + ' --- ' + riaa_class
# Stop JVM
jvm.stop()
print "RIAA FILTERING?: " + riaa_class
return riaa_class
示例7: classify
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
def classify(train, test, name="RF", tuning=False):
jvm.start()
if isinstance(train, list) and isinstance(test, list):
train = weka_instance(train)
trn_data = converters.load_any_file(train)
test = weka_instance(test)
tst_data = converters.load_any_file(test)
elif os.path.isfile(train) and os.path.isfile(test):
trn_data = converters.load_any_file(train)
tst_data = converters.load_any_file(test)
else:
trn = csv_as_ndarray(train)
tst = csv_as_ndarray(test)
trn_data = converters.ndarray_to_instances(trn, relation="Train")
tst_data = converters.ndarray_to_instances(tst, relation="Test")
trn_data.class_is_last()
tst_data.class_is_last()
# t = time()
if tuning:
opt = tune(train)
else:
opt = default_opt
# print("Time to tune: {} seconds".format(time() - t))
cls = Classifier(classname=classifiers[name.lower()], options=opt)
cls.build_classifier(trn_data)
distr = [cls.distribution_for_instance(inst)[1] for inst in tst_data]
preds = [cls.classify_instance(inst) for inst in tst_data]
jvm.stop()
return preds, distr
示例8: __init__
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
#.........这里部分代码省略.........
print "Model Params"
print self.modelParams
# Get data for testing and learning
learnerData = self.retrieveData(self.questionID, "learner")
testData = self.retrieveData(self.questionID, 'test')
masterData = self.retrieveData(self.questionID, 'all')
masterData = self.addNominals(masterData)
# Check if there is enough correct data to run
if (learnerData.num_instances < 1 or testData.num_instances < 1):
self.status = self.config.NOT_ENOUGH_DATA
return False
# If this is a prediction and there is a valid patient, change masterData header
patientObj = self.buildPatientObject()
patientInstance = None
if ((patientObj is not None) and (self.predict == 1)):
masterData = self.addPatientNominals(patientObj, masterData)
patientInstance = self.createPatientInstance(patientObj, masterData)
masterData.add_instance(patientInstance)
elif (patientObj is None) and (self.predict == 1):
print 'No patient defined for prediction. Exiting'
return True
# Fix dataset headers up to match and fix instances to match headers
masterData.delete()
learner = masterData.copy_instances(masterData, 0, 0)
test = masterData.copy_instances(masterData, 0, 0)
self.addInstancesToDataset(learnerData, learner)
self.addInstancesToDataset(testData, test)
# Comparison of data for testing purposes
# print 'learnerData'
# print learnerData
# print 'learner'
# print learner
# print 'testData'
# print testData
# print 'test'
# print test
# pdb.set_trace()
# Instantiate classifier
self.cls = Classifier(classname=self.classifier, options=self.parameters)
# Run classifier
self.cls.build_classifier(learner)
# for index, inst in enumerate(learnerData):
# prediction = self.cls.classify_instance(inst)
# distribution = self.cls.distribution_for_instance(inst)
# Test classifier
evl = Evaluation(learner)
evl.test_model(self.cls, test)
# Store information about matrix
self.acc = evl.percent_correct
self.val = None
# Convert numpy array into simple array
confusionMatrix = []
confusionMatrix.append([evl.confusion_matrix[0][0], evl.confusion_matrix[0][1]])
confusionMatrix.append([evl.confusion_matrix[1][0], evl.confusion_matrix[1][1]])
# Convert matrix into json format
self.matrix = json.dumps(confusionMatrix)
# print 'Classifier: ', self.classifier
# print 'ID: ', self.questionID
# print 'ACC: ', self.acc
# print(evl.summary())
# If this is a prediction... make the prediction
if ((patientObj is not None) and (self.predict == 1)):
masterData.add_instance(patientInstance)
print "Running prediction on patient: "
print masterData.get_instance(0)
self.prediction = self.cls.classify_instance(masterData.get_instance(0))
#self.uploadPrediction()
# Temporarily store file to serialize to
fileName = str(self.questionID) + self.algorithm + ".model"
serialization.write(fileName, self.cls)
# Open that file and store it
self.model = None
with open(fileName, 'rb') as f:
self.model = f.read()
# Remove temporary file
os.remove(fileName)
# Set status to awaiting feedback
self.status = self.config.AWAITING_FEEDBACK_STATUS
return True
示例9: list
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
tempList = list()
jvm.start()
data_dir = "C:\Users\Softmints\Desktop\Diss\Code\WEKA"
from weka.core.converters import Loader
#Prepare ARFF Loader
loader = Loader(classname="weka.core.converters.ArffLoader")
#Assign ands load ARFF data file
data = loader.load_file(data_dir + "\TestDataEleventoTwentyTwo.arff")
data.class_is_last()
from weka.classifiers import Classifier
#Classify data using J48 classifer
cls = Classifier(classname="weka.classifiers.trees.J48", options=["-C", "0.3"])
cls.build_classifier(data)
for index, inst in enumerate(data):
#Output predicition and distribution
pred = cls.classify_instance(inst)
dist = cls.distribution_for_instance(inst)
print(str(index) + ": label index=" + str(pred) + ", class distribution=" + str(dist))
if str(pred) == "0.0":
tempList.append(str(index))
print tempList
jvm.stop()
开发者ID:Softmints,项目名称:Recognising-Place-Names-in-Twitter-Posts--Machine-Learning-,代码行数:32,代码来源:wekaClass.py
示例10: run_classifier
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
def run_classifier(path, prot, sel, cols, prot_vals, beta):
DIs = dict()
jvm.start()
for i in range(len(cols)-1):
loader = Loader(classname="weka.core.converters.CSVLoader")
data = loader.load_file(path)
# remove selected attribute from the data
# NOTE: options are ONE indexed, not ZERO indexed
remove = Filter(classname="weka.filters.unsupervised.attribute.Remove", \
options=["-R", str(sel[2]+1)])
remove.inputformat(data)
data = remove.filter(data)
# if running for only one attribue, remove all others (except protected)
if i > 0:
for j in range(1, prot[2]+1):
if i != j:
remove = Filter(classname="weka.filters.unsupervised.attribute.Remove", \
options=["-R", ("1" if i>j else "2")])
remove.inputformat(data)
data = remove.filter(data)
# set prot attribute as Class attribute
data.class_is_last()
# run classifier
cls = Classifier(classname="weka.classifiers.bayes.NaiveBayes")
cls.build_classifier(data)
# count the number of each combination
pos_and_pred = float(0.0)
pos_and_not_pred = float(0.0)
neg_and_pred = float(0.0)
neg_and_not_pred = float(0.0)
for ind, inst in enumerate(data):
if cls.classify_instance(inst):
if prot_vals[ind] == prot[1]:
pos_and_pred += 1
else:
neg_and_pred += 1
else:
if prot_vals[ind] == prot[1]:
pos_and_not_pred += 1
else:
neg_and_not_pred += 1
# calculate DI
BER = ((pos_and_not_pred / (pos_and_pred + pos_and_not_pred)) + \
(neg_and_pred / (neg_and_pred + neg_and_not_pred))) * 0.5
if BER > 0.5:
BER = 1 - BER
DI = 1 - ((1 - 2 * BER) / (beta + 1 - 2 * BER))
if i == 0: # consider changing this to a 'code word' instead of 'all'
DIs["all"] = DI
else:
DIs[cols[i-1]] = DI
jvm.stop()
return DIs
示例11: runner
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
#.........这里部分代码省略.........
meta = addict.Dict()
meta.search = comb.Search.NAME
meta.evaluator = comb.Evaluator.NAME
meta.features = [tran.attribute(index).name for index in attr.selected_attributes]
feat.append(meta)
for i, stage in enumerate(self.stages):
if stage.code == 'ats':
search = stage.value.search.name
evaluator = stage.value.evaluator.name
if search == comb.Search.NAME and evaluator == comb.Evaluator.NAME:
self.stages[i].status = Pipeline.COMPLETE
models = [ ]
for model in para.MODEL:
if model.USE:
summary = addict.Dict()
self.logs.append('Modelling {model}'.format(model = model.LABEL))
summary.label = model.LABEL
summary.name = model.NAME
summary.options = assign_if_none(model.OPTIONS, [ ])
for i, stage in enumerate(self.stages):
if stage.code == 'lrn' and stage.value.name == model.NAME:
self.stages[i].status = Pipeline.RUNNING
for i, instance in enumerate(data):
iclass = list(range(instance.num_classes))
options = assign_if_none(model.OPTIONS, [ ])
classifier = Classifier(classname = 'weka.classifiers.{classname}'.format(classname = model.NAME), options = options)
classifier.build_classifier(tran)
serializer.write(os.path.join(head, '{name}.{classname}.model'.format(
name = name,
classname = model.NAME
)), classifier)
self.logs.append('Testing model {model}'.format(model = model.LABEL))
evaluation = Evaluation(tran)
evaluation.test_model(classifier, test)
summary.summary = evaluation.summary()
frame = pd.DataFrame(data = evaluation.confusion_matrix)
axes = sns.heatmap(frame, cbar = False, annot = True)
b64str = get_b64_plot(axes)
summary.confusion_matrix = addict.Dict({
'value': evaluation.confusion_matrix.tolist(),
'plot': b64str
})
self.logs.append('Plotting Learning Curve for {model}'.format(model = model.LABEL))
buffer = io.BytesIO()
plot_classifier_errors(evaluation.predictions, tran, test, outfile = buffer, wait = False)
b64str = buffer_to_b64(buffer)
summary.learning_curve = b64str
buffer = io.BytesIO()
plot_roc(evaluation, class_index = iclass, outfile = buffer, wait = False)
b64str = buffer_to_b64(buffer)
summary.roc_curve = b64str
buffer = io.BytesIO()
plot_prc(evaluation, class_index = iclass, outfile = buffer, wait = False)
b64str = buffer_to_b64(buffer)
summary.prc_curve = b64str
if classifier.graph:
summary.graph = classifier.graph
for i, instance in enumerate(test):
prediction = classifier.classify_instance(instance)
for i, stage in enumerate(self.stages):
if stage.code == 'lrn' and stage.value.name == model.NAME:
self.stages[i].status = Pipeline.COMPLETE
models.append(summary)
self.gist.models = models
JVM.stop()
JSON.write(os.path.join(head, '{name}.cgist'.format(name = name)), self.gist)
self.logs.append('Pipeline Complete')
self.set_status(Pipeline.COMPLETE)
示例12: evaluate_j48
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
def evaluate_j48(datasets_path, intermediary_path):
# for examples on how to use this function, refer to
# http://pythonhosted.org/python-weka-wrapper/examples.html#build-classifier-on-dataset-output-predictions
import weka.core.jvm as jvm
from weka.core.converters import Loader
from weka.classifiers import Classifier
from sklearn.metrics import precision_score, accuracy_score, f1_score
from networkx.drawing.nx_agraph import graphviz_layout
jvm.start()
json_results = {
'runs': {
'1': dict()
}
}
try:
for dataset in os.listdir(datasets_path):
dataset_name = dataset.split('.')[0]
json_results['runs']['1'][dataset_name] = dict()
loader = Loader(classname="weka.core.converters.ArffLoader")
y_pred_all = []
y_true_all = []
heights = []
n_nodes = []
for n_fold in it.count():
try:
train_s = loader.load_file(
os.path.join(intermediary_path, '%s_fold_%d_train.arff' % (dataset_name, n_fold)))
val_s = loader.load_file(
os.path.join(intermediary_path, '%s_fold_%d_val.arff' % (dataset_name, n_fold)))
test_s = loader.load_file(
os.path.join(intermediary_path, '%s_fold_%d_test.arff' % (dataset_name, n_fold)))
train_s.relationname = dataset_name
val_s.relationname = dataset_name
test_s.relationname = dataset_name
train_s.class_is_last()
val_s.class_is_last()
test_s.class_is_last()
warnings.warn('WARNING: appending validation set in training set.')
for inst in val_s:
train_s.add_instance(inst)
cls = Classifier(classname="weka.classifiers.trees.J48", options=["-C", "0.25", "-M", "2"])
# cls = Classifier(classname="weka.classifiers.trees.REPTree",
# options=["-M", "2", "-V", "0.001", "-N", "3", "-S", "1", "-L", "-1", "-I", "0.0"])
cls.build_classifier(train_s)
warnings.warn('WARNING: will only work for binary splits!')
graph = cls.graph.encode('ascii')
out = StringIO.StringIO(graph)
G = nx.Graph(nx.nx_pydot.read_dot(out))
# TODO plotting!
# fig = plt.figure(figsize=(40, 30))
# pos = graphviz_layout(G, root='N0', prog='dot')
#
# edgelist = G.edges(data=True)
# nodelist = G.nodes(data=True)
#
# edge_labels = {(x1, x2): v['label'] for x1, x2, v in edgelist}
# node_colors = {node_id: ('#98FB98' if 'shape' in _dict else '#0099FF') for node_id, _dict in nodelist}
# node_colors['N0'] = '#FFFFFF'
# node_colors = node_colors.values()
#
# nx.draw_networkx_nodes(G, pos, node_color=node_colors)
# nx.draw_networkx_edges(G, pos, style='dashed', arrows=False)
# nx.draw_networkx_labels(G, pos, {k: v['label'] for k, v in G.node.iteritems()})
# nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
# plt.axis('off')
# plt.show()
# exit(0)
# TODO plotting!
heights += [max(map(len, nx.shortest_path(G, source='N0').itervalues()))]
n_nodes += [len(G.node)]
y_test_true = []
y_test_pred = []
# y_train_true = []
# y_train_pred = []
# for index, inst in enumerate(train_s):
# y_train_true += [inst.get_value(inst.class_index)]
# y_train_pred += [cls.classify_instance(inst)]
for index, inst in enumerate(test_s):
y_test_true += [inst.get_value(inst.class_index)]
y_test_pred += [cls.classify_instance(inst)]
#.........这里部分代码省略.........
示例13: write_to_weka
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
X_test[:,-1] = classes[0] # make sure test classes is removed
y_test = Y[test_index]
write_to_weka('train.arff', 'training_data', data.columns, X_train, classes)
write_to_weka('test.arff', 'testing_data', data.columns, X_test, classes)
loader = Loader(classname="weka.core.converters.ArffLoader")
trdata = loader.load_file("train.arff")
trdata.class_is_last()
classifier = Classifier(classname="weka.classifiers.lazy.IBk")
classifier.options = ["-K", "10", "-W", "0", "-I", "-A",
"weka.core.neighboursearch.LinearNNSearch -A \"weka.core.ManhattanDistance -R first-last\""]
classifier.build_classifier(trdata)
tedata = loader.load_file("test.arff")
tedata.class_is_last()
for index, inst in enumerate(tedata):
result = classifier.classify_instance(inst)
Ypred[test_index[index]] = classes[int(result)]
accuracy = float(np.sum(y_test == Ypred[test_index])) / float(y_test.shape[0])
print " => Accuracy = ", accuracy
itr += 1
accuracy = float(np.sum(Y == Ypred)) / float(Y.shape[0])
print "Total accuracy = ", accuracy
os.remove('train.arff')
os.remove('test.arff')
jvm.stop()
示例14: range
# 需要导入模块: from weka.classifiers import Classifier [as 别名]
# 或者: from weka.classifiers.Classifier import classify_instance [as 别名]
predictions = [0]*len(sensors)
stepCount = 0
try:
while True:
for i in range(len(sensors)):
# aquire data
# df = sensors[i].getFrame()
df = dataManager.getNextWindow()
# run the data frame (df) through nathan's code, output is signle row arff
inst = # nathan, looks like the iotdata class has some capabilities for handling streaming data, ill let you do this
# classify
pred = classifier.classify_instance(inst)
# estimate step count
stepCount += countSteps(df)
# save prediciton
predictions[i] = pred
# output predictions
print predictions, stepCount
except KeyboardInterrupt:
for sensor in sensors:
sensor.closeDevice()
jvm.stop()