调整

server/classify_grpc_server.py → classify_grpc_server.py

@@ -4,25 +4,37 @@ import grpc
 from protobuf import classify_pb2
 from protobuf import classify_pb2_grpc
 
+from utils.config import model_config
+from utils.predic_fac import PredictorFac
+
+
+class Classify(classify_pb2_grpc.classifyServicer):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.predictorfac = PredictorFac(model_config)
 
-class classify(classify_pb2_grpc.classifyServicer):
     def SingleClassify(self, request, context):
-        return classify_pb2.SingleClassifyReply(message='result {msg}'.format(msg=request.keyword))
+        res = self.predictorfac.predic(request.keyword)
+        return classify_pb2.SingleClassifyReply(message='result {msg}'.format(msg=res))
+
+    def fac_test_predic(self, data):
+        res = self.predictorfac.predic(data)
+        return res
 
 
 def serve():
     # 启动 rpc 服务
     server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
-    classify_pb2_grpc.add_classifyServicer_to_server(classify(), server)
+    classify_pb2_grpc.add_classifyServicer_to_server(Classify(), server)
     server.add_insecure_port('[::]:50051')
     server.start()
     try:
         while True:
-            time.sleep(60*60*24)  # one day in seconds
+            time.sleep(60 * 60 * 24)  # one day in seconds
     except KeyboardInterrupt:
         server.stop(0)
 
+
 if __name__ == '__main__':
     serve()
-
-
+    print(Classify().fac_test_predic('lm358'))

predict/__init__.py

+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+__all__ = ['kw_predict', 'list_predict']
\ No newline at end of file

predict/base_handler.py

+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+
+from utils.log_manager import get_logger
+from utils.robots import dd_send_msg
+import pandas as pd
+
+
+class BasePredictor:
+    '''
+        预测类基类
+    '''
+
+    def __init__(self, name, extractor, classifier):
+        self.name = name
+        self.classifier = classifier
+        self.extractor = extractor
+        self.error = get_logger(self.name + '_error')
+        self.info = get_logger(self.name + '_info')
+        self.robot_msg = dd_send_msg
+        self.pd = pd
+
+    def predict(self, key):
+        raise NotImplementedError
+
+    def get_single_predict(self, string: object) -> tuple:
+        '''
+
+        :param string: 接收单个要判断的字符串
+        :return tuple: 返回两个元素的元组, 第一个元素为判断结果, 第二个元素为可能性的字典
+        '''
+        series = self.pd.Series([string])
+        feature = self.extractor.transform(series)
+        predictions = self.classifier.predict(feature)
+        proba = self.classifier.predict_proba(feature)
+        classes = self.classifier.classes_
+        deal_list = [round(i, 3) for i in proba[0].tolist()]
+        dic_proba = {k: v for k, v in zip(classes, deal_list)}
+        return predictions[0], dic_proba

predict/kw_predict.py

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
-from sklearn.externals import joblib
-import pandas as pd
-import pickle
+from predict.base_handler import BasePredictor
 
 
-class KwPredict:
-
-    def PredictKeyword(self, keyword):
-        with open('extractor', 'rb') as f:
-            extractor = pickle.load(f)
-        classifier = joblib.load('model')
-        kw_series = pd.Series(keyword)
-        feature = extractor.transform(kw_series)
-        predictions = classifier.predict(feature)
-        return predictions
-
+class KwPredict(BasePredictor):
 
+    def predict(self, key):
+        res, prab = self.get_single_predict(key)
+        return res

predict/list_predict.py

+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+from predict.base_handler import BasePredictor
+
+
+class LiPredict(BasePredictor):
+
+    pass
\ No newline at end of file

utils/__init__.py

+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
\ No newline at end of file

utils/config.py

+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+
+import sys
+
+ENVIRONMENT = 'test' if sys.platform in ('darwin', 'win32') else 'produce'
+model_config = {}
+if ENVIRONMENT == 'test':
+    model_config['model_path'] = r'model'
+    model_config['extractor_path'] = r'extractor'
+else:
+    model_config['model_path'] = r''
+    model_config['extractor_path'] = r''

utils/log_manager.py

+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+
+loggerLevel = logging.INFO
+root_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+log_dir = root_path + '/logs'
+# log_dir = "logs"
+console_formatter = '%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s'
+json_formatter = '%(message)s'
+logger_dict = dict()
+
+
+def create_logger(log_name, log_type):
+    g_logger = logging.getLogger(log_name)
+    rt = log_name.split('_')[0]
+    log_path = "%s/%s" % (log_dir, rt)
+    if not os.path.exists(log_path):
+        os.makedirs(log_path)
+    logfile = log_name + ".log"
+    log_file = "%s/%s" % (log_path, logfile)
+    console = logging.StreamHandler()
+    console.setFormatter(logging.Formatter(console_formatter))
+    handler = RotatingFileHandler(log_file, maxBytes=2 * 1204 * 1024, backupCount=1)
+    fmt = json_formatter if log_type == 'json' else console_formatter
+    handler.setFormatter(logging.Formatter(fmt))
+    g_logger.addHandler(console)
+    g_logger.addHandler(handler)
+    g_logger.setLevel(loggerLevel)
+    return g_logger
+
+
+def get_logger(log_name, log_type='file'):
+    if log_name not in logger_dict:
+        create_logger(log_name, log_type)
+        logger_dict[log_name] = logging.getLogger(log_name)
+    return logging.getLogger(log_name)

utils/predic_fac.py

+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+from sklearn.externals import joblib
+import pickle
+from predict import *
+
+class PredictorFac():
+    def __init__(self, config):
+        with open(config['extractor_path'], 'rb') as f:
+            extractor = pickle.load(f)
+        classifier = joblib.load(config['model_path'])
+        self.kw_predictor = kw_predict.KwPredict('single', extractor, classifier)
+        self.list_predictor = list_predict.LiPredict('list', extractor, classifier)
+
+    def _get_predictor(self, data):
+        if isinstance(data, str):
+            return self.kw_predictor
+        elif isinstance(data, list):
+            return self.list_predictor
+
+    def predic(self, data):
+        predictor = self._get_predictor(data)
+        res = predictor.predict(data)
+        return res

utils/robots.py

+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+import time
+
+import requests
+
+dd_robot_api = ' https://oapi.dingtalk.com/robot/send?access_token='
+tom = 'c19beeab837f5c6e019e7fc602d470704d634ae33510f40fb0e903cde215fb24'
+
+
+def dd_send_msg(msg, robot=tom):
+    data = {
+        "msgtype": "text",
+        "text": {
+            "content": msg
+        }
+    }
+    requests.post(dd_robot_api + robot, json=data)
+    time.sleep(5)
+
+
+if __name__ == "__main__":
+    dd_send_msg('喂喂 你发的太多了！')