本文整理汇总了Python中weka.classifiers.Classifier类的典型用法代码示例。如果您正苦于以下问题:Python Classifier类的具体用法?Python Classifier怎么用?Python Classifier使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了Classifier类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: main
def main(args):
"""
Trains a NaiveBayesUpdateable classifier incrementally on a dataset. The dataset can be supplied as parameter.
:param args: the commandline arguments
:type args: list
"""
# load a dataset
if len(args) <= 1:
data_file = helper.get_data_dir() + os.sep + "vote.arff"
else:
data_file = args[1]
helper.print_info("Loading dataset: " + data_file)
loader = Loader(classname="weka.core.converters.ArffLoader")
data = loader.load_file(data_file, incremental=True)
data.class_is_last()
# classifier
nb = Classifier(classname="weka.classifiers.bayes.NaiveBayesUpdateable")
nb.build_classifier(data)
# train incrementally
for inst in loader:
nb.update_classifier(inst)
print(nb)
示例2: main
def main(args):
"""
Loads a dataset, shuffles it, splits it into train/test set. Trains J48 with training set and
evaluates the built model on the test set.
:param args: the commandline arguments (optional, can be dataset filename)
:type args: list
"""
# load a dataset
if len(args) <= 1:
data_file = helper.get_data_dir() + os.sep + "vote.arff"
else:
data_file = args[1]
helper.print_info("Loading dataset: " + data_file)
loader = Loader(classname="weka.core.converters.ArffLoader")
data = loader.load_file(data_file)
data.class_is_last()
# generate train/test split of randomized data
train, test = data.train_test_split(66.0, Random(1))
# build classifier
cls = Classifier(classname="weka.classifiers.trees.J48")
cls.build_classifier(train)
print(cls)
# evaluate
evl = Evaluation(train)
evl.test_model(cls, test)
print(evl.summary())
示例3: main
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())))
示例4: main
def main():
"""
Just runs some example code.
"""
# load a dataset
iris_file = helper.get_data_dir() + os.sep + "iris.arff"
helper.print_info("Loading dataset: " + iris_file)
loader = Loader("weka.core.converters.ArffLoader")
iris_data = loader.load_file(iris_file)
iris_data.class_is_last()
# train classifier
classifier = Classifier("weka.classifiers.trees.J48")
classifier.build_classifier(iris_data)
# save and read object
helper.print_title("I/O: single object")
outfile = tempfile.gettempdir() + os.sep + "j48.model"
serialization.write(outfile, classifier)
model = Classifier(jobject=serialization.read(outfile))
print(model)
# save classifier and dataset header (multiple objects)
helper.print_title("I/O: single object")
serialization.write_all(outfile, [classifier, Instances.template_instances(iris_data)])
objects = serialization.read_all(outfile)
for i, obj in enumerate(objects):
helper.print_info("Object #" + str(i+1) + ":")
if javabridge.get_env().is_instance_of(obj, javabridge.get_env().find_class("weka/core/Instances")):
obj = Instances(jobject=obj)
elif javabridge.get_env().is_instance_of(obj, javabridge.get_env().find_class("weka/classifiers/Classifier")):
obj = Classifier(jobject=obj)
print(obj)
示例5: python_weka
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
示例6: setOptions
def setOptions(self, options):
"""
Parses a given list of options.
Parameter(s):
'options' -- the list of options as an array of strings
"""
Classifier.setOptions(self, options)
return
示例7: assign_classify
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()
示例8: predict
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()
示例9: playback_speed_checker
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
示例10: getCapabilities
def getCapabilities(self):
"""
returns the capabilities of this classifier
Return:
the capabilities of this classifier
"""
result = Classifier.getCapabilities(self)
# attributes
result.enable(Capability.NOMINAL_ATTRIBUTES)
result.enable(Capability.NUMERIC_ATTRIBUTES)
result.enable(Capability.DATE_ATTRIBUTES)
result.enable(Capability.STRING_ATTRIBUTES)
result.enable(Capability.RELATIONAL_ATTRIBUTES)
result.enable(Capability.MISSING_VALUES)
# class
result.enable(Capability.NOMINAL_CLASS)
result.enable(Capability.NUMERIC_CLASS)
result.enable(Capability.DATE_CLASS)
result.enable(Capability.MISSING_CLASS_VALUES)
# instances
result.setMinimumNumberInstances(0)
return result
示例11: main
def main():
"""
Just runs some example code.
"""
# load a dataset
bodyfat_file = helper.get_data_dir() + os.sep + "bodyfat.arff"
helper.print_info("Loading dataset: " + bodyfat_file)
loader = Loader("weka.core.converters.ArffLoader")
bodyfat_data = loader.load_file(bodyfat_file)
bodyfat_data.class_is_last()
# classifier help
helper.print_title("Creating help string")
classifier = Classifier(classname="weka.classifiers.trees.M5P")
classifier.build_classifier(bodyfat_data)
print(classifier)
示例12: train_model
def train_model(self, training_data):
model_weka = None
if os.path.isfile(self.model_file):
print 'Model ' + self.name + ' already trained.'
else:
print 'Starting to train_model model ' + self.name + '.'
model_weka = Classifier(classname = self.classname, options = self.options)
model_weka.build_classifier(data = training_data)
serialization.write(filename = self.model_file, jobject = model_weka)
print 'Model ' + self.name + ' trained and saved.'
if os.path.isfile(self.parameter_file):
print 'Parameters of the model ' + self.name + ' already saved.'
else:
if model_weka == None:
model_weka = Classifier(jobject = serialization.read(self.model_file))
save_file(file_name = self.parameter_file, content = str(model_weka))
print 'Parameters of the model ' + self.name + ' saved.'
示例13: train_JRip
def train_JRip(self, min_per_rule=20, optimizations=2, folds=3, seed=42):
params = [
'-F', str(folds), # folds
'-N', str(min_per_rule), # min elements per rule
'-O', str(optimizations), # optimizations
'-S', str(seed) #seed
]
self.base_classifier = Classifier(classname='weka.classifiers.rules.JRip', options=params)
self._train()
示例14: train_J48
def train_J48(self, min_per_rule=20):
params = [
'-C','0.3',
'-M',str(min_per_rule),
# '-N',str(folds),
# '-R',
]
self.base_classifier = Classifier(classname='weka.classifiers.trees.J48', options=params)
self._train()
示例15: train
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)