def show_data_frequent():
redis_dealer = redis_deal()
datas = redis_dealer.read_from_redis('/home/wxw/data/iec104/fre')
i = 0
print(type(datas))
for key in datas:
print(key)
def get_new_correct_rank_words(key):
word_redis = redis_deal()
correct_words = word_redis.read_from_redis(key)
correct_words = analyzer.filter_words(correct_words, 60)
correct_words.sort(key=cmp_to_key(cmp_word), reverse=True)
pure_correct_words = [word[0] for word in correct_words]
word_rank_result('aa', 'bb', 100, pure_correct_words)
def __init__(self):
self.words_fre = None
self.words_table = None
self.words_entry = None
self.glvotes = None
self.svotes = None
self.redisDeal = redis_deal()
self.wCvert = word_convert()
def split_by_order_ve(self, messages):
voter = voters()
redis_read = redis_deal()
raw_words = redis_read.read_from_redis('order_raw_words')
w_converter = word_convert()
order_words = w_converter.convert_order_to_raw(raw_words)
order_words['300'] = 1000000
boundaries = voter.raw_boundary_generate(messages, order_words)
return boundaries
def __init__(self):
super().__init__()
self.converter = Converter()
self.msgSpliter = MsgSpliter()
self.redis_dealer = redis_deal()
self.splt = splitter()
self.desiner = Desiner()
self.msAb = MeasureAb()
self.cvt = Converter()
self.dataTuning = DataTuning()
def raw_to_redis(file_path, r_way):
datas = read_datas(file_path, r_way)
datas = get_puredatas(datas)
raw_datas = []
converter = Converter()
for data in datas:
raw_datas.append(converter.convert_raw_to_text(data))
key = file_path
phrase_redis = redis_deal()
phrase_redis.insert_to_redis(key, raw_datas)
def __init__(self):
self.msgLogic = MegSplitLogic()
self.modbus = ModBusDataTuning()
self.md = modbus()
self.anlzer = base_analyzer()
self.ftp = FTPDataTuning()
self.ftpPaser = FTPParser()
self.cmPaser = ComPaser()
self.cvt = Converter()
self.mtool = MessageSplitMeasure()
self.rds = redis_deal()
def word_rank_result(key_true, key_test, rank_k, words_infer=None):
word_redis = redis_deal()
words_true = word_redis.read_from_redis(key_true)
if words_infer == None:
words_infer = word_redis.read_from_redis(key_test)
i = 10
t_measure = Fields_measure(words_true, words_infer)
t_X = []
t_Y = []
while (i <= rank_k):
t_ratio = t_measure.measure(i)
t_X.append(i)
t_Y.append(t_ratio)
i = i + 10
print(t_X)
print(t_Y)
def ve_word():
word_dis = words_discover()
word_redis = redis_deal()
word_r = word_dis.infer_words_by_ve(["/home/wxw/data/modbusdata", "/home/wxw/data/modbus_github"], "single", 3, "yes", "abs", "loose", 0, 0)
word_redis.insert_to_redis(ve_stra_str + 'word_rank_correct', word_r)
word_pures = [word[0] for word in word_r]
word_redis.insert_to_redis(ve_stra_str + 'word_pure_rank_correct', word_pures)
word_transer = transer()
modbus_w = modbus()
word_t = word_transer.field_keys(modbus_w.fields)
word_redis.insert_to_redis(ve_stra_str + 'word_true_correct', word_t)
t_measure = Fields_measure(word_t, word_pures)
t_cnt = t_measure.measure(1000)
print(t_cnt)
t_now = time.strftime("%Y-%m-%d %H:%m:%s", time.localtime(time.time()))
words_logger = get_logger(log_path + '/word_log' + vote_pre + t_now, 'word_logger')
words_logger.error(word_r)
def get_format_by_voting_expert(messages, h, combine, model, v_way, T, r):
message_splitter = splitter()
#message_split = message_splitter.split_by_ve(messages, h, combine, model, v_way, T, r)
redis_dealer = redis_deal()
strategy = ve_strategy().get_strategy_str()
#redis_dealer.insert_to_redis('split' + strategy, json.dumps(message_split))
message_split = redis_dealer.read_from_redis('split' + strategy)
message_prim_format = {}
for key in message_split:
message_prim_format[key[0]] = prime_b(key[1])
tree_builder = treefL(message_prim_format, int(0.1 * len(message_split)),
0.2)
t_result = tree_builder.generate_T()
t_result.depth_traverse()
for f in t_result.result:
print("format start")
for node_i in f:
print(node_i.loc)
from Data_base.Data_redis.redis_deal import redis_deal
import numpy as np
import sys
from sklearn.feature_extraction.text import CountVectorizer
import math
redis_read = redis_deal()
class base_analyzer:
def __init__(self):
pass
def rank_words(self, raw_words, max_num, top, reverse=True):
t_dic = {}
t_dic[1] = []
t_dic[2] = []
t_dic[3] = []
t_dic[4] = []
t_dic[5] = []
for word in raw_words:
t_dic[len(word.split(' '))].append((word, raw_words[word]))
for i in range(1, 5):
t_dic[i] = sorted(t_dic[i],
key=lambda key: key[1],
reverse=reverse)
print(len(t_dic[i]))
t_result = {}
for i in range(1, 5):
t_result[i] = t_dic[i][0:top]
t_last_items = [item[1] for item in t_dic[i][top:]]
def __init__(self):
self.prefix = ve_strategy().get_strategy_str()
self.redis_read = redis_deal()
self.parameters = ve_strategy().vote_parameters
self.ngram = voters()
self.cvt = Converter()
def __init__(self):
self.prefix = ve_strategy().get_strategy_str()
self.redis_read = redis_deal()
self.parameters = ve_strategy().vote_parameters
def __init__(self):
self.ftp = FTPDataTuning()
self.redis = RedisDataTuning()
self.redis_deal = redis_deal()
self.fConfig = FileConfig()
def show_raw_data(file_path):
redis_dealer = redis_deal()
datas = redis_dealer.read_from_redis(file_path)
print(datas[0])
def __init__(self):
super().__init__()
self.converter = Converter()
self.msgSpliter = MsgSpliter()
self.redis_dealer = redis_deal()
def __init__(self):
self.redisR = redis_deal()
self.mysqlR = MysqlDeal()
from common.readdata import *
from Config.ve_strategy import ve_strategy
from Config.log_config import log_path
from Config.encode_types import Message_encoder
from common.Converter.base_convert import Converter
from Data_base.Data_redis.redis_deal import redis_deal
from Config.UserConfig import UserConfig
from Config.VeConfig import VeConfig
from common.Converter.word_converter import word_convert
import sys
now_time = time.strftime("%Y-%m-%d %H:%m:%s", time.localtime(time.time()))
voter_logger = get_logger(log_path + '/message_vote' + vote_pre + now_time,
'messagedetaillogger')
ve_parameter = ve_strategy().vote_parameters
redis_writer = redis_deal()
redis_prefix = ve_strategy().get_strategy_str()
class voters:
def __init__(self):
self.words_fre = None
self.words_table = None
self.words_entry = None
self.glvotes = None
self.svotes = None
self.redisDeal = redis_deal()
self.wCvert = word_convert()
def query_key(self, key):
return self.words_table[key], self.words_fre[key], self.words_entry[
