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)
def serialize(self, model, path): """Serialize the java model in specific path Arguments: model {java object} -- the model to serialize path {str} -- path to save the model serialized """ serialization.write(path, model)
def train_weka_model(self, training_data_dir, save_model_dir, log_file, mimic_env=None): """ Just runs some example code. """ loader = Loader(classname="weka.core.converters.CSVLoader") training_data = loader.load_file(training_data_dir) training_data.class_is_last() self.classifier = Classifier(classname="weka.classifiers.trees.M5P", options=self.options) # classifier help, check https://weka.sourceforge.io/doc.dev/weka/classifiers/trees/M5P.html self.classifier.build_classifier(training_data) # print(classifier) graph = self.classifier.graph node_number = float(graph.split('\n')[-3].split()[0].replace('N', '')) leaves_number = node_number / 2 serialization.write(save_model_dir, self.classifier) # print('Leaves number is {0}'.format(leave_number), file=log_file) evaluation = Evaluation(training_data) predicts = evaluation.test_model(self.classifier, training_data) # return_value = None # if mimic_env is not None: predict_dictionary = {} for predict_index in range(len(predicts)): predict_value = predicts[predict_index] if predict_value in predict_dictionary.keys(): predict_dictionary[predict_value].append(predict_index) else: predict_dictionary.update({predict_value: [predict_index]}) # return_value = mimic_env.get_return(state=list(predict_dictionary.values())) return_value_log = mimic_env.get_return( state=list(predict_dictionary.values())) return_value_log_struct = mimic_env.get_return( state=list(predict_dictionary.values()), apply_structure_cost=True) return_value_var_reduction = mimic_env.get_return( state=list(predict_dictionary.values()), apply_variance_reduction=True) # print("Training return is {0}".format(return_value), file=log_file) summary = evaluation.summary() numbers = summary.split('\n') corr = float(numbers[1].split()[-1]) mae = float(numbers[2].split()[-1]) rmse = float(numbers[3].split()[-1]) rae = float(numbers[4].split()[-2]) / 100 rrse = float(numbers[5].split()[-2]) / 100 # print(evl) # print("Training summary is "+summary, file=log_file) return return_value_log, return_value_log_struct, \ return_value_var_reduction, mae, rmse, leaves_number
def serialize(self, ser_file): """ Serializes the filter to the specified file. :param ser_file: the file to save the filter to :type ser_file: str """ serialization.write(ser_file, self)
def __init__(self, index = 0, inference = "ExactInference", ghostAgents = None): BustersAgent.__init__(self, index, inference, ghostAgents) jvm.start(max_heap_size="512m") self.loader = Loader(classname="weka.core.converters.ArffLoader") self.data = self.loader.load_file("data/training-fase3.arff") self.data.class_is_last() self.cls = Classifier(classname="weka.classifiers.trees.REPTree", options=["-M", "2","-V", "0.001","-N", "3", "-S", "1", "-L", "-1"]) self.cls.build_classifier(self.data) serialization.write("data/out.model", self.cls)
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: model (using serialization module)") 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: model and header (using serialization module)") 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) # save and read object helper.print_title("I/O: just model (using Classifier class)") outfile = tempfile.gettempdir() + os.sep + "j48.model" classifier.serialize(outfile) model, _ = Classifier.deserialize(outfile) print(model) # save classifier and dataset header (multiple objects) helper.print_title("I/O: model and header (using Classifier class)") classifier.serialize(outfile, header=iris_data) model, header = Classifier.deserialize(outfile) print(model) if header is not None: print(header)
def save_all_models(results_dir_str, train_data): c = 0 for algo in algo_func_dict.keys(): gc.collect() print "Training: " + str(algo) model = algo_func_dict[algo](train_data) out_file = results_dir_str + '/' + algo + ".model" serialization.write(out_file, model) c += 1 print str(c) + ": Model Saved =>" + str(out_file)
def save_all_models(): id = str(expression) + '_' + str(user) target_dir = '../results/' + str(expression) + '/' + str(user) + '/' train_data_file = "../data/arff_files/" + str(user) + "/" loader = Loader(classname="weka.core.converters.ArffLoader") train_data = loader.load_file(train_data_file) for algo in algo_func_dict.keys(): model = algo_func_dict[algo](train_data) out_file = target_dir + algo + ".model" serialization.write(out_file, model)
def case1(): loader = Loader(classname="weka.core.converters.ArffLoader") file = input("Enter the name of the file without the extension:") data = loader.load_file(file + ".arff", incremental=True) data.class_is_last() # print(data) # print(str(data1)) cls = Classifier(classname="weka.classifiers.bayes.NaiveBayesUpdateable") cls.build_classifier(data) for inst in loader: cls.update_classifier(inst) serialization.write(file + ".bin", cls) print("Model created with name:", file, ".bin")
def create_cluster_model(arff_file, n=10, loader_type="csv", model="kmeans.model"): """ create cluster model """ check_jvm() if loader_type == "csv": loader = converters.Loader(classname="weka.core.converters.CSVLoader") else : loader = conventers.Loader(classname="weka.core.converters.ArffLoader") data = loader.load_file(arff_file) clusterer = Clusterer( classname="weka.clusterers.SimpleKMeans", options=["-N", str(n)]) clusterer.build_clusterer(data) serialization.write(model, clusterer)
def test_weka_model(self, testing_data_dir, save_model_dir, log_file, mimic_env=None): self.classifier = Classifier( jobject=serialization.read(save_model_dir)) graph = self.classifier.graph node_number = float(graph.split('\n')[-3].split()[0].replace('N', '')) leaves_number = node_number / 2 serialization.write(save_model_dir, self.classifier) # print('Leaves number is {0}'.format(leave_number), file=log_file) loader = Loader(classname="weka.core.converters.CSVLoader") testing_data = loader.load_file(testing_data_dir) testing_data.class_is_last() evaluation = Evaluation(testing_data) predicts = evaluation.test_model(self.classifier, testing_data) predict_dictionary = {} for predict_index in range(len(predicts)): predict_value = predicts[predict_index] if predict_value in predict_dictionary.keys(): predict_dictionary[predict_value].append(predict_index) else: predict_dictionary.update({predict_value: [predict_index]}) return_value_log = mimic_env.get_return( state=list(predict_dictionary.values())) return_value_log_struct = mimic_env.get_return( state=list(predict_dictionary.values()), apply_structure_cost=True) return_value_var_reduction = mimic_env.get_return( state=list(predict_dictionary.values()), apply_variance_reduction=True) summary = evaluation.summary() numbers = summary.split('\n') corr = float(numbers[1].split()[-1]) mae = float(numbers[2].split()[-1]) rmse = float(numbers[3].split()[-1]) rae = float(numbers[4].split()[-2]) / 100 rrse = float(numbers[5].split()[-2]) / 100 # print(evl) # print("Testing summary is "+summary, file=log_file) return return_value_log, return_value_log_struct, \ return_value_var_reduction, mae, rmse, leaves_number
def serialize(self, ser_file, header=None): """ Serializes the clusterer to the specified file. :param ser_file: the file to save the model to :type ser_file: str :param header: the (optional) dataset header to store alongside; recommended :type header: Instances """ if (header is not None) and header.num_instances > 0: header = Instances.template_instances(header) if header is not None: serialization.write_all(ser_file, [self, header]) else: serialization.write(ser_file, self)
def output_model(objs, paras, outfiles): global op outfile = preprocess(outfiles) c = Classifier(classname="weka.classifiers.trees.M5P") for obj in objs: data = cleanup(outfile, paras, obj) print 'output_model', op, obj, paras, data.num_instances, outfile header = [] for a in data.attributes(): header.append(a.name) c.build_classifier(data) #print c serialization.write(model_file(op, obj), c) #e = Evaluation(data) #e.test_model(c, data) #print e.summary() subprocess.call('rm %s' % outfile, shell=True)
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.'
def test_read_write(self): """ Tests methods read and write. """ fname = self.tempfile("readwrite.ser") self.delfile(fname) lin = ["A", "B", "C", "D"] vin = javabridge.make_instance("java/util/Vector", "()V") for element in lin: javabridge.call(vin, "add", "(Ljava/lang/Object;)Z", element) serialization.write(fname, vin) self.assertTrue(os.path.exists(fname), msg="Failed to write to " + fname + "?") vout = serialization.read(fname) self.assertIsNotNone(vout, msg="Failed to read from " + fname + "?") enm = javabridge.call(vin, "elements", "()Ljava/util/Enumeration;") lout = typeconv.enumeration_to_list(enm) self.delfile(fname) self.assertEqual(lin, lout, msg="Input/output differ")
def test_read_write(self): """ Tests methods read and write. """ fname = self.tempfile("readwrite.ser") self.delfile(fname) lin = ["A", "B", "C", "D"] vin = javabridge.make_instance("java/util/Vector", "()V") for element in lin: javabridge.call(vin, "add", "(Ljava/lang/Object;)Z", element) serialization.write(fname, vin) self.assertTrue(os.path.exists(fname), msg="Failed to write to " + fname + "?") vout = serialization.read(fname) self.assertIsNotNone(vout, msg="Failed to read from " + fname + "?") enm = javabridge.call(vin, "elements", "()Ljava/util/Enumeration;") lout = typeconv.enumeration_to_list(enm) self.delfile(fname) self.assertEqual(lin, lout, msg="Input/output differ")
def main(): # load a dataset loader = Loader(classname="weka.core.converters.ArffLoader") train_data = loader.load_file( "/home/atos-user/project/Logs/arff/logs_training.arff") train_data.class_is_last() # set class attribute classifier = Classifier(classname="weka.classifiers.rules.PART", options=["-C", "0.25", "-M", "2", "-Q", "1"]) # classifier = Classifier(classname="weka.classifiers.rules.JRip", options=["-F", "3", "-N", "2.0", "-O", "2", "-S", "1"]) # classifier = Classifier(classname="weka.classifiers.trees.RandomForest", options=["-P", "100", "-I", "100", "-num-slots", "1", "-S", "1", "-K", "0", "-M", "1.0", "-V", "0.001"]) # classifier = Classifier(classname="weka.classifiers.functions.MultilayerPerceptron", options=["-L", "0.3", "-M", "0.2", "-N", "500", "-S", "0", "-V", "0", "-E", "20", "-H", "a"]) classifier.build_classifier(train_data) predicted_index = 0 notpredicted_index = 0 index = 0 index_predicted = 0 index_notpredicted = 0 fauxpositif1 = 0 fauxpositif2 = 0 for index, pred in enumerate(evaluation.predictions): if pred.predicted == 1.0 and pred.actual == 1.0: index_predicted += 1 if pred.predicted == 0.0 and pred.actual == 0.0: index_notpredicted += 1 if pred.predicted == 1.0 and pred.actual == 0.0: fauxpositif1 += 1 if pred.predicted == 0.0 and pred.actual == 1.0: fauxpositif2 += 1 print("index_predicted = ", index_predicted) print("index_notpredicted = ", index_notpredicted) print("fauxpositif1 = ", fauxpositif1) print("fauxpositif2 = ", fauxpositif2) print(evaluation.summary()) serialization.write("/home/atos-user/project/project_files/PART.model", classifier) # save model
def save_all_models(): for user in user_list: user_train_dir = os.listdir("../data/arff_files/" + str(user) + "/train/") user_train_dir.sort() n = len(user_train_dir) c = 0 for expression_index in range(n): print "\n", expression_index, "=>", str(expression_list[expression_index]), ':', str(user_train_dir[expression_index]) id = str(expression_list[expression_index]) + '_' + str(user) target_dir = '../models/' + str(expression_list[expression_index]) + '/' + str(user) + '/' train_data_file = "../data/arff_files/" + str(user) + "/train/" + str(user_train_dir[expression_index]) print train_data_file, "=>", target_dir, "\n" loader = Loader(classname="weka.core.converters.ArffLoader") train_data = loader.load_file(train_data_file) for algo in algo_func_dict.keys(): print "training - " + str(algo) model = algo_func_dict[algo](train_data) out_file = target_dir + algo + ".model" serialization.write(out_file, model) c = c + 1 print str(c) + ": Model Saved =>" + str(out_file)
def stream(file, option): jvm.start(packages=True) if option == 1: print( "Hi! This is a protected command, please insert the password to proceed!" ) for x in range(3): password = input('') if password.strip() == 'DMMLproject': print("All good!") break else: if x == 2: print( "This command is protected and can be used only by an administrator, please use another command." ) return else: print( "Wrong password, please provide the correct password") hoeffding = loadModel('models/HoeffdingTree.model') f = open(file, 'r') while True: line = f.readline() if not line: break if option == 0: classifyOne(line.strip(), hoeffding) else: print('Stream update start at: ', datetime.now().time()) hoeffding = retrainOneInc(line.strip(), hoeffding) print('Stream update end at: ', datetime.now().time()) f.close() sr.write('models/HoeffdingTree.model', hoeffding)
def classify(data, classifier, cv, modelPath, folds=10, splitPerc=70, randomSeed=10): # cross validate the model if cv: print('CV start at: ', datetime.now().time()) evaluation = Evaluation(data) evaluation.crossvalidate_model(classifier, data, folds, Random(randomSeed)) print('CV end at: ', datetime.now().time()) displayResults("Cross Validation", evaluation) else: # split data into train and test print('Split start training at: ', datetime.now().time()) train, test = data.train_test_split(splitPerc, Random(randomSeed)) # build classifier with training set classifier.build_classifier(train) print(classifier) print('Split end training at: ', datetime.now().time()) evaluation = Evaluation(train) print('Split start at: ', datetime.now().time()) evaluation.test_model(classifier, test) print('Split end at: ', datetime.now().time()) # evaluation.evaluate_model(classifier, ["-t", test]) displayResults("TrainTestSplit", evaluation) sr.write(modelPath, classifier)
def run(self): # Attach JVM javabridge.attach() # Debug print "Classifier" print self.classifier print "Params" print self.parameters 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
def saveModel(self, model, method, mname): finalname = "%s_%s.model" %(method, mname) serialization.write(os.path.join(self.modelDir, finalname), model) logger.info('[%s] : [INFO] Saved mode %s ', datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S'), finalname)
def call_weka(file_dir, ml_opt, ofile_dir): loader = Loader(classname="weka.core.converters.CSVLoader") data = loader.load_file(file_dir) data.class_is_last() filtered = data ml_id = '' if ml_opt != '0': if ml_opt == '1': classifier = Classifier( classname="weka.classifiers.functions.LibSVM", options=[ "-S", "0", "-K", "2", "-D", "3", "-G", "0.0", "-R", "0.0", "-N", "0.5", "-M", "40.0", "-C", "1.0", "-E", "0.001", "-P", "0.1", "-seed", "1" ]) ml_id = 'SVM' elif ml_opt == '3': classifier = Classifier( classname="weka.classifiers.functions.MLPClassifier", options=[ '-N', '2', '-R', '0.01', '-O', '1.0E-6', '-P', '1', '-E', '1', '-S', '1' ]) ml_id = 'MLPC' elif ml_opt == '4': classifier = Classifier( classname="weka.classifiers.trees.RandomForest", options=["-I", "100", "-K", "0", "-S", "1", "-num-slots", "1"]) ml_id = 'RF' elif ml_opt == '2': classifier = Classifier(classname="weka.classifiers.meta.Bagging", options=[ "-P", "100", "-S", "1", "-I", "10", "-W", "weka.classifiers.trees.M5P", "--", "-M", "4.0" ]) ml_id = 'BagM5P' elif ml_opt == '5': classifier = Classifier(classname="weka.classifiers.trees.J48", options=["-C", "0.25", "-M", "2"]) ml_id = 'J48' elif ml_opt == '7': classifier = Classifier( classname="weka.classifiers.functions.RBFNetwork", options=[ "-B", "2", "-S", "1", "-R", "1.0E-8", "-M", "-1", "-W", "0.1" ]) ml_id = 'RBFNet' elif ml_opt == '8': classifier = Classifier( classname="weka.classifiers.bayes.BayesNet", options=[ "-D", "-Q", "weka.classifiers.bayes.net.search.local.K2", "--", "-P", "1", "-S", "BAYES", "-E", "weka.classifiers.bayes.net.estimate.SimpleEstimator", "--", "-A", "0.5" ]) ml_id = 'BayesNet' elif ml_opt == '6': classifier = Classifier( classname="weka.classifiers.bayes.NaiveBayes") ml_id = 'NaiveBayes' elif ml_opt == '9': classifier = Classifier( classname="weka.classifiers.functions.SimpleLogistic", options=["-I", "0", "-M", "500", "-H", "50", "-W", "0.0"]) ml_id = 'LogReg' filtered.class_is_last() evaluation = Evaluation(filtered) evaluation.crossvalidate_model(classifier, filtered, 10, Random(42)) print "Evaluation: Done." ofile = open(ofile_dir + ml_id + "_results.txt", 'wb') print >> ofile, evaluation.summary() print >> ofile, evaluation.class_details().encode('ascii', 'ignore') print >> ofile, evaluation.matrix().encode('ascii', 'ignore') serialization.write(ofile_dir + ml_id + ".model", classifier) print "Saving " + ml_id + " Model: Done." ofile.close()
# cl2 = clusterEM.cluster_instance(inst) # dist2 = clusterEM.distribution_for_instance(inst) # print ("cluster=" + str(cl2) + ", distribution=" + str(dist2)) # print inst # clusterDBSCAN = Clusterer( classname="weka.clusterers.DBSCAN", options=[ "-E", "0.9", "-M", "6", "-I", "weka.clusterers.forOPTICSAndDBScan.Databases.SequentialDatabase", "-D", "weka.clusterers.forOPTICSAndDBScan.DataObjects.EuclideanDataObject" ]) clusterDBSCAN.build_clusterer(data) serialization.write(os.path.join(modelDir, "dbscan.model"), clusterDBSCAN) cluster = Clusterer( jobject=serialization.read(os.path.join(modelDir, "dbscan.model"))) # print clusterDBSCAN # print clusterDBSCAN.number_of_clusters for inst in data: cl3 = cluster.cluster_instance(inst) dist3 = cluster.distribution_for_instance(inst) print(("cluster=" + str(cl3) + ", distribution=" + str(dist3))) # for inst in data: # cl3 = clusterDBSCAN.cluster_instance(inst) # dist3 = clusterDBSCAN.distribution_for_instance(inst) # print ("cluster=" + str(cl3) + ", distribution=" + str(dist3)) jvm.stop()
jvm.start(max_heap_size="4g",packages=True) Wtrain = converters.load_any_file("train.csv") Wtest = converters.load_any_file("test.csv") Wtrain.class_is_last() Wtest.class_is_last() if(Path('lmt.model').exists()): lmt = Classifier(jobject=serialization.read("lmt.model")) else: lmt = Classifier(classname="weka.classifiers.trees.LMT") lmt.build_classifier(Wtrain) serialization.write("lmt.model", lmt) evlmt = Evaluation(Wtrain) evlmt.crossvalidate_model(lmt, Wtrain, 5, Random(1)) print("Error is",evlmt.error_rate) cm2e = evlmt.confusion_matrix cm2E = pd.DataFrame(cm2e, index = ["neg","pos"],columns = ["neg","pos"]) plt.figure(figsize = (7,7)) axis = sns.heatmap(cm2E, annot=True, cbar=False, cmap="Reds") plcls.plot_roc(evlmt,class_index=[1]) tevlmt = Evaluation(Wtrain)
def save_model_weka(classifier, path): serialization.write(path, classifier)
def runner(self, cdat, heap_size = 16384, seed = None, verbose = True): self.set_status(Pipeline.RUNNING) self.logs.append('Initializing Pipeline') para = self.config self.logs.append('Reading Pipeline Configuration') head = '' name = get_rand_uuid_str() self.logs.append('Reading Input File') for i, stage in enumerate(self.stages): if stage.code in ('dat.fle', 'prp.bgc', 'prp.nrm', 'prp.pmc', 'prp.sum'): self.stages[i].status = Pipeline.RUNNING if stage.code == 'dat.fle': head = os.path.abspath(stage.value.path) name, _ = os.path.splitext(stage.value.name) self.logs.append('Parsing to ARFF') path = os.path.join(head, '{name}.arff'.format(name = name)) # This bug, I don't know why, using Config.schema instead. # cdat.toARFF(path, express_config = para.Preprocess.schema, verbose = verbose) for i, stage in enumerate(self.stages): if stage.code in ('dat.fle', 'prp.bgc', 'prp.nrm', 'prp.pmc', 'prp.sum'): self.stages[i].status = Pipeline.COMPLETE self.logs.append('Saved ARFF at {path}'.format(path = path)) self.logs.append('Splitting to Training and Testing Sets') JVM.start(max_heap_size = '{size}m'.format(size = heap_size)) load = Loader(classname = 'weka.core.converters.ArffLoader') # data = load.load_file(path) # save = Saver(classname = 'weka.core.converters.ArffSaver') data = load.load_file(os.path.join(head, 'iris.arff')) # For Debugging Purposes Only data.class_is_last() # For Debugging Purposes Only # data.class_index = cdat.iclss for i, stage in enumerate(self.stages): if stage.code == 'prp.kcv': self.stages[i].status = Pipeline.RUNNING self.logs.append('Splitting Training Set') # TODO - Check if this seed is worth it. seed = assign_if_none(seed, random.randint(0, 1000)) opts = ['-S', str(seed), '-N', str(para.Preprocess.FOLDS)] wobj = Filter(classname = 'weka.filters.supervised.instance.StratifiedRemoveFolds', options = opts + ['-V']) wobj.inputformat(data) tran = wobj.filter(data) self.logs.append('Splitting Testing Set') wobj.options = opts test = wobj.filter(data) for i, stage in enumerate(self.stages): if stage.code == 'prp.kcv': self.stages[i].status = Pipeline.COMPLETE self.logs.append('Performing Feature Selection') feat = [ ] for comb in para.FEATURE_SELECTION: if comb.USE: 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.RUNNING srch = ASSearch(classname = 'weka.attributeSelection.{classname}'.format( classname = comb.Search.NAME, options = assign_if_none(comb.Search.OPTIONS, [ ]) )) ewal = ASEvaluation(classname = 'weka.attributeSelection.{classname}'.format( classname = comb.Evaluator.NAME, options = assign_if_none(comb.Evaluator.OPTIONS, [ ]) )) attr = AttributeSelection() attr.search(srch) attr.evaluator(ewal) attr.select_attributes(tran) 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)
def save_model(model, fname, dir_name): outfile = realpath(join(dir_name, fname)) # "fname.model" serialization.write(outfile, model)
def train(request): jvm.start() d_att1 = Attribute.create_numeric("bodydearword.feature") d_att2 = Attribute.create_numeric("bodyform.feature") d_att3 = Attribute.create_numeric("bodyhtml.feature") d_att4 = Attribute.create_numeric("bodymultipart.feature") d_att5 = Attribute.create_numeric("bodynumchars.feature") d_att6 = Attribute.create_numeric("bodynumfunctionwords.feature") d_att7 = Attribute.create_numeric("bodynumuniqwords.feature") d_att8 = Attribute.create_numeric("bodynumwords.feature") d_att9 = Attribute.create_numeric("bodyrichness.feature") d_att10 = Attribute.create_numeric("bodysuspensionword.feature") d_att11 = Attribute.create_numeric("bodyverifyyouraccountphrase.feature") d_att12 = Attribute.create_numeric("externalsabinary.feature") d_att13 = Attribute.create_numeric("externalsascore.feature") d_att14 = Attribute.create_numeric("scriptjavascript.feature") d_att15 = Attribute.create_numeric("scriptonclick.feature") d_att16 = Attribute.create_numeric("scriptpopup.feature") d_att17 = Attribute.create_numeric("scriptstatuschange.feature") d_att18 = Attribute.create_numeric("scriptunmodalload.feature") d_att19 = Attribute.create_numeric("senddiffreplyto.feature") d_att20 = Attribute.create_numeric("sendnumwords.feature") d_att21 = Attribute.create_numeric("sendunmodaldomain.feature") d_att22 = Attribute.create_numeric("subjectbankword.feature") d_att23 = Attribute.create_numeric("subjectdebitword.feature") d_att24 = Attribute.create_numeric("subjectfwdword.feature") d_att25 = Attribute.create_numeric("subjectnumchars.feature") d_att26 = Attribute.create_numeric("subjectnumwords.feature") d_att27 = Attribute.create_numeric("subjectreplyword.feature") d_att28 = Attribute.create_numeric("subjectrichness.feature") d_att29 = Attribute.create_numeric("subjectverifyword.feature") d_att30 = Attribute.create_numeric("urlatchar.feature") d_att31 = Attribute.create_numeric("urlbaglink.feature") d_att32 = Attribute.create_numeric("urlip.feature") d_att33 = Attribute.create_numeric("urlnumdomains.feature") d_att34 = Attribute.create_numeric("urlnumexternallink.feature") d_att35 = Attribute.create_numeric("urlnumimagelink.feature") d_att36 = Attribute.create_numeric("urlnuminternallink.feature") d_att37 = Attribute.create_numeric("urlnumip.feature") d_att38 = Attribute.create_numeric("urlnumlink.feature") d_att39 = Attribute.create_numeric("urlnumperiods.feature") d_att40 = Attribute.create_numeric("urlnumport.feature") d_att41 = Attribute.create_numeric("urlport.feature") d_att42 = Attribute.create_numeric("urltwodoains.feature") d_att43 = Attribute.create_numeric("urlunmodalbaglink.feature") d_att44 = Attribute.create_numeric("urlwordclicklink.feature") d_att45 = Attribute.create_numeric("urlwordherelink.feature") d_att46 = Attribute.create_numeric("urlwordloginlink.feature") d_att47 = Attribute.create_numeric("urlwordupdatelink.feature") d_att48 = Attribute.create_nominal("class", {'phish', 'ham'}) # data_dir = settings.BASE_DIR + "/phishing/public/datasets/" # loader = Loader(classname="weka.core.converters.ArffLoader") data = loader.load_file(data_dir + "dataset.arff") data.class_is_last() cls = Classifier(classname="weka.classifiers.trees.J48") cls.options = ["-C", "0.3"] cls.build_classifier(data) serialization.write(data_dir + "out.model", cls) classifier = Classifier(jobject=serialization.read(data_dir + "out.model")) dataset = Instances.create_instances("test", [ d_att1, d_att2, d_att3, d_att4, d_att5, d_att6, d_att7, d_att8, d_att9, d_att10, d_att11, d_att12, d_att13, d_att14, d_att15, d_att16, d_att17, d_att18, d_att19, d_att20, d_att21, d_att22, d_att23, d_att24, d_att25, d_att26, d_att27, d_att28, d_att29, d_att30, d_att31, d_att32, d_att33, d_att34, d_att35, d_att36, d_att37, d_att38, d_att39, d_att40, d_att41, d_att42, d_att43, d_att44, d_att45, d_att46, d_att47, d_att48 ], 0) values = [ 0, 0, 0, 0, 890, 1, 124, 198, 0.22247191011236, 0, 0, 0, 0.0, 0, 0, 0, 0, 0, 1, 4, 0, 0, 0, 0, 21, 4, 1, 0.19047619047619, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Instance.missing_value() ] inst = Instance.create_instance(values) dataset.add_instance(inst) dataset.class_is_last() # print(str(dataset)) var = '' for inst1 in dataset: pred = classifier.classify_instance(inst1) var = inst1.class_attribute.value(int(pred)) if var == 'ham': print('No es pishing') # do somthing else: print('Es pishing') # do somthing print(var) jvm.stop() return HttpResponse(str(var))
jvm.start() # executar a tecnica variando de 1 a 9 clusters for i in range(1, 10): print '**************Numero de clusters: ' + str(i) clusterer = Clusterer(classname="weka.clusterers.SimpleKMeans", options=["-N", str(i)]) clusterer.build_clusterer(eca) print(clusterer) clusterer = Clusterer(classname="weka.clusterers.SimpleKMeans", options=["-N", "4"]) clusterer.build_clusterer(eca) print(clusterer) serialization.write("model/kmeans_eca_reprovacao.model", clusterer) # ler model '''objects = serialization.read_all("cluster.model") clusterer = Clusterer(jobject=objects[0]) data_aluno = loader.load_file("aluno_temp.csv") for instancia in data_aluno: resultado = clusterer.cluster_instance(instancia) print ('O aluno pertence ao cluster: ' + str(resultado))''' """ for inst in data: cl = clusterer.cluster_instance(inst) # 0-based cluster index dist = clusterer.distribution_for_instance(inst) # cluster membership distribution print("cluster=" + str(cl) + ", distribution=" + str(dist))
dataSet20x50 = loader.load_file("trainingSet/dataSet20x50.arff") dataSet20x50.class_is_last() dataSet50x20 = loader.load_file("trainingSet/dataSet50x20.arff") dataSet50x20.class_is_last() classifier1 = Classifier(classname="weka.classifiers.functions.MultilayerPerceptron", options=["-L", "0.3", "-M", "0.2", "-N", "500", "-V", "0", "-S", "0", "-E", "20", "-H", "9"]) classifier2 = Classifier(classname="weka.classifiers.functions.MultilayerPerceptron", options=["-L", "0.3", "-M", "0.2", "-N", "500", "-V", "0", "-S", "0", "-E", "20", "-H", "11"]) classifier3 = Classifier(classname="weka.classifiers.functions.MultilayerPerceptron", options=["-L", "0.3", "-M", "0.2", "-N", "500", "-V", "0", "-S", "0", "-E", "20", "-H", "9"]) print "\n\nTraining neural network 1" evaluation1 = Evaluation(dataSet20x20) evaluation1.crossvalidate_model(classifier1, dataSet20x20, 10, Random(42)) classifier1.build_classifier(dataSet20x20) serialization.write("trainingSet/nn1.model", classifier1) print "\n\n====================================================== NUERAL NETWORK 1 ======================================================" print(evaluation1.summary()) print(evaluation1.class_details()) print "Training neural network 2" evaluation2 = Evaluation(dataSet20x50) evaluation2.crossvalidate_model(classifier2, dataSet20x50, 10, Random(42)) classifier2.build_classifier(dataSet20x50) serialization.write("trainingSet/nn2.model", classifier2) print "\n\n====================================================== NUERAL NETWORK 2 ======================================================" print(evaluation2.summary()) print(evaluation2.class_details()) print "Training neural network 3" evaluation3 = Evaluation(dataSet50x20)
def saveModel(self, model, method, mname): finalname = "%s_%s.model" %(method, mname) serialization.write(os.path.join(self.modelDir, finalname), model) logger.info('[%s] : [INFO] Saved mode %s ', datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S'), finalname)