def SplitTrainTest(lSamples):
    if config.get_bool('SPLIT_BY_EASY_HARD'):
        setEasy = set(data.file_to_obj(config.get_string('EASY_CONNECTIONS_LIST_FILE')));
        lTrain = filter(lambda samp: samp.pddlconn.sPddlTo in setEasy, lSamples);
        lTest = filter(lambda samp: samp.pddlconn.sPddlTo not in setEasy, lSamples);
        print "NUM Train:", len(lTrain), "Test:", len(lTest);
        return lTrain, lTest;
    if config.get_bool('SPLIT_BY_FIRST_30'):
        setFirst30 = set(data.file_to_obj(config.get_string('FIRST_30_CONNECTIONS_LIST_FILE')));
        lTrain = filter(lambda samp: samp.pddlconn.sPddlTo in setFirst30, lSamples);
        lTest = filter(lambda samp: samp.pddlconn.sPddlTo not in setFirst30, lSamples);
        print "NUM Train:", len(lTrain), "Test:", len(lTest);
        return lTrain, lTest;
    if config.get_bool('SPLIT_BY_SENTENCE'):
        lRandomIndexes, iSplit = SplitSampleBySentence(lSamples);
    else:
        lRandomIndexes = range(len(lSamples));
        random.shuffle(lRandomIndexes);
        iSplit = len(lSamples)/2;
    if config.get_bool('TRAIN_AND_TEST_ON_ALL'):
        assert(not config.get_bool('TRAIN_ON_HALF_TEST_ON_ALL'));
        lTrainIndexes = range(len(lSamples));
        lTestIndexes = range(len(lSamples));
    elif config.get_bool('TRAIN_ON_HALF_TEST_ON_ALL'):
        lTrainIndexes = lRandomIndexes[:iSplit];
        lTestIndexes = range(len(lSamples));
    elif config.get_bool('TRAIN_ON_HALF_TEST_ON_HALF'):
        lTrainIndexes = lRandomIndexes[:iSplit];
        lTestIndexes = lRandomIndexes[iSplit:];
    else:
        assert False, 'No Test Train Split Method Specified';

    lTrain = map(lambda x:lSamples[x], lTrainIndexes);
    lTest = map(lambda x:lSamples[x], lTestIndexes);
    return lTrain, lTest;
def LoadRewardsDict():
    sFileRewards = config.get_string('REWARDS_FILE');
    dConnRewardsIndexes = collections.defaultdict(lambda:{'iNumNeg':0, 'iNumPos':0});
    iMaxIter = config.get_int('REWARDS_MAX_ITER');
    iMinIter = config.get_int('REWARDS_MIN_ITER');
    iCurIter = 0;
    for sLine in open(sFileRewards):
        sLine = sLine.strip();
        lConns = sLine.split();
        if len(lConns) > 5:
            iCurIter += 1;
            if iCurIter > iMaxIter:
                break;
            if iCurIter < iMinIter:
                continue;
        for sConn in lConns:
            iFrom, iTo, iNumPos, iNumNeg = sConn.split(':');
            iNumPos = int(iNumPos);
            iNumNeg = int(iNumNeg);
            iFrom = int(iFrom);
            iTo = int(iTo);
            dConnRewardsIndexes[(iFrom,iTo)]['iNumNeg'] += iNumNeg; 
            dConnRewardsIndexes[(iFrom,iTo)]['iNumPos'] += iNumPos; 
    dIndexToPredList = predicate.PredDictFileToPredListDict(config.get_string('PRED_DICT_FILE'), lambda x:x.iIndex);
    dConnRewardsStrings = collections.defaultdict(lambda:{'iNumNeg':0, 'iNumPos':0});
    for (iFrom, iTo), dPosNeg in dConnRewardsIndexes.items():
        sFrom = dIndexToPredList[iFrom][0].GetObject();
        sTo = dIndexToPredList[iTo][0].GetObject();
        dConnRewardsStrings[(sFrom, sTo)]['iNumNeg'] += dPosNeg['iNumNeg'];
        dConnRewardsStrings[(sFrom, sTo)]['iNumPos'] += dPosNeg['iNumPos'];
    return dConnRewardsStrings;
Esempio n. 3
0
def get_proxy_settings(config=None, conn=None):
    r"""
    Return proxy settings as a ProxySettings object

    The caller must specify either config or conn.

    Arguments:
     - `config`: A osdlyrics.config.Config object, this object is used to retrive
                 proxy settings. If it is not set, the caller MUST set conn to a
                 valid D-Bus connection to create a Config object
     - `conn`: A D-Bus connection object, this is used when `config` is not
               specified.
    """
    if config is None and conn is None:
        raise ValueError('Either config or conn must be specified')
    if config is None:
        config = config.Config(conn)
    proxy_type = config.get_string('Download/proxy')
    if proxy_type.lower() == 'no':
        return ProxySettings(protocol='no')
    if proxy_type.lower() == 'manual':
        protocol = config.get_string('Download/proxy-type')
        host = config.get_string('Download/proxy-host')
        port = config.get_int('Download/proxy-port')
        username = config.get_string('Download/proxy-username')
        passwd = config.get_string('Download/proxy-passwd')
        return ProxySettings(protocol=protocol, host=host, port=port,
                            username=username, password=passwd)
    if proxy_type.lower() == 'system':
        return detect_system_proxy()
def CalcConnFileFScore():
    print "Calcing FScore for:", config.get_string('CONN_FILE');
    setConnTups = predicate.ReadConnectionsFileToTupSet();
    setGoldConns = LoadGoldStringConnSet();

    if config.get_bool('ANALYZE_ON_HARD'):
        lEasy = data.file_to_obj(config.get_string('EASY_CONNECTIONS_LIST_FILE'));

    iTruePos = 0;
    iFalsePos = 0;
    for sFrom, sTo in setConnTups:
        if config.get_bool('ANALYZE_ON_HARD'):
            if sTo in lEasy:
                continue;

        if (sFrom, sTo) in setGoldConns:
            iTruePos += 1;
        else:
            iFalsePos += 1;

    iFalseNeg = len(setGoldConns)-iTruePos;
    if config.get_bool('ANALYZE_ON_HARD'):
        iFalseNeg = len(setGoldConns)-iTruePos-len(lEasy);
        
    iTrueNeg = 0;
    fPrecision = float(iTruePos)/float(iTruePos+iFalsePos) if iTruePos > 0 else 0;
    fRecall = float(iTruePos)/float(iTruePos+iFalseNeg) if iTruePos > 0 else 0;
    fScore = 2*fPrecision*fRecall/(fPrecision+fRecall) if (fPrecision*fRecall) > 0 else 0;
    print "TP:", iTruePos, "FP:", iFalsePos, "TN:", iTrueNeg, "FN:", iFalseNeg;
    print "Precision:", fPrecision;
    print "Recall:", fRecall;
    print "FScore:", fScore;
def ReadConnectionsFileToTupSet():
    dIndexToPred = PredDictFileToPredDict(config.get_string('PRED_DICT_FILE'), lambda x:x.iIndex);
    setConnTups = set();
    for sLine in open(config.get_string('CONN_FILE')):
        sLine = sLine.strip();
        lSplit = sLine.split('|');
        setConnTups.add((dIndexToPred[int(lSplit[1])].GetObject(), dIndexToPred[int(lSplit[2])].GetObject())); 
    return setConnTups;
Esempio n. 6
0
    def __init__(self):
        exchange_name = config.get_string('grid', 'name')
        symbol = config.get_string('grid', 'symbol')
        super(Grid, self).__init__(exchange_name, symbol)
        self.base_line = config.get_float('grid', 'base_line')  # 当前价格基准线
        self.one_hand = config.get_float('grid', 'one_hand')  # 一手买多少

        logging.info("交易所:%s" % exchange_name)
        logging.info("交易对:%s" % symbol)
        logging.info("基线:%f" % self.base_line)
        logging.info("一格:%f" % self.one_hand)
def Train(lSamples, j = 1, bSuppress = False):
    sTrainFile = config.get_string('SVM_TRAIN');
    sModelFile = config.get_string('SVM_MODEL');

    Sample.WriteSvmFile(lSamples, sTrainFile);
    if config.get_bool('USE_SVM_PERF'):
        # version used for good svm results
        iRetVal = PrintAndRun("../../bin/svm_perf_learn -c 10 -w 3 -l 1 -b 0 " + sTrainFile + " " + "model.svm", bSuppress = bSuppress);
        #iRetVal = PrintAndRun("../../bin/svm_perf_learn -c 1 -w 3 -l 1 -b 0 " + sTrainFile + " " + "model.svm");
    else:
        iRetVal = PrintAndRun("../../bin/svm_learn -c 10 -b 0 -m 1000 -j " + str(j) + ' ' + sTrainFile + " " + "model.svm", bSuppress = bSuppress);
def WriteFirst30SvmConnectionsFile(lGranularSamples):
    assert config.get_bool('SPLIT_BY_FIRST_30');
    lTrainGranular, lTestGranular = SplitTrainTest(lGranularSamples);

    lTestCollapsed, dFeatureWeights = TrainAndTestSvm(lTrainGranular, lTestGranular);
    fScore, fPrec, fRecall = AnalyzePredsSimple(lTestCollapsed);
    Sample.CollapsedSample.WriteConnections(lTestCollapsed, config.get_string('FIRST_30_SVM_CONNECTIONS_FILE'), 
                                            bAppend=False, bWritePredictions = True, bPosOnly = True);
    # note that this one is train on train and test on train (yes those words are correct)
    lTrainCollapsed, dFeatureWeights = TrainAndTestSvm(lTrainGranular, lTrainGranular);
    fScore, fPrec, fRecall = AnalyzePredsSimple(lTrainCollapsed);
    Sample.CollapsedSample.WriteConnections(lTrainCollapsed, config.get_string('FIRST_30_SVM_CONNECTIONS_FILE'), 
                                                    bAppend=True, bWritePredictions = True, bPosOnly = True);
def ReadSentencesFromTextFile():
    sSentenceFile = config.get_string('SENTENCE_FILE');
    sOldSentenceFile = config.get_string('OLD_SENTENCE_FILE');
    sDepFile = config.get_string('DEPENDANCY_FILE');
    
    lSentences = ReadSentencesFromTextFileSimple(sSentenceFile);

    if sDepFile != '':
        Sentence.AddDepFeatures(lSentences, sDepFile);
    if sOldSentenceFile != '':
        lOldSentences = ReadSentencesFromTextFileSimple(sOldSentenceFile);
        Sentence.AddOldSentenceFeatures(lSentences, lOldSentences);

    return lSentences;
Esempio n. 10
0
def Test(lSamples, bSuppress = False):
    sTestFile = config.get_string('SVM_TEST');
    sModelFile = config.get_string('SVM_MODEL');
    sPredFile = config.get_string('SVM_PRED');

    Sample.WriteSvmFile(lSamples, sTestFile);
    if config.get_bool('USE_SVM_PERF'):
        iRetVal = PrintAndRun("../../bin/svm_perf_classify " + sTestFile + " " + sModelFile + " " + sPredFile, bSuppress = bSuppress);
    else:
        iRetVal = PrintAndRun("../../bin/svm_classify " + sTestFile + " " + sModelFile + " " + sPredFile, bSuppress = bSuppress);
    sPredLines = open(sPredFile).readlines();
    lPreds  = map(lambda x:float(x), sPredLines);
    assert (len(lPreds) == len(lSamples));
    for pred, sample in zip(lPreds, lSamples):
        sample.fPred = float(pred);
def LoadPredStringSet():
    lPreds = PredDictFileToPredList(config.get_string('PRED_DICT_FILE'));
    setPreds = set();
    for pred in lPreds:
        setPreds.add(pred.GetObject());
    print "NumPreds:", len(setPreds);
    return setPreds;
def LoadGoldIndexesConnSet():
    setGoldStringConns = LoadGoldStringConnSet();
    dObjToPredList = predicate.PredDictFileToPredListDict(config.get_string('PRED_DICT_FILE'), lambda x:x.GetObject());
    setGoldIndexConns = set();
    for sFrom, sTo in setGoldStringConns:
        for predFrom in dObjToPredList[sFrom]:
            for predTo in dObjToPredList[sTo]:
                setGoldIndexConns.add((predFrom.iIndex,predTo.iIndex));
    return setGoldIndexConns;
def GenAllGranularSamplesFromList(lSentences, sLogFileName):
    sSentenceLogFile = config.get_string('SENTENCE_LOG_FILE');
    fLog = open(sSentenceLogFile, 'w');
    lSamples = [];
    iNumLoopy = 0;
    for sentence in lSentences:
        iCurNumLoopy, lCurSamples = sentence.GenAllGranularSamples(fLog);
        lSamples.extend(lCurSamples);
        iNumLoopy += iCurNumLoopy;

    if iNumLoopy > 0:
        print "NUM LOOPY:", iNumLoopy;
    assert iNumLoopy < config.get_int('NUM_ALLOWED_LOOPY'), 'Too Many Loopy: ' + str(iNumLoopy) + ' NonLoopy: ' + str(len(lSamples));

    sGoldDepFile = config.get_string('GOLD_DEP_FILE');
    if sGoldDepFile != '':
        dGoldDeps = data.file_to_obj_with_comments(sGoldDepFile);
        # add the gold dep info
        for sample in lSamples:
            if (sample.pddlconn.sPddlTo in dGoldDeps) and (sample.pddlconn.sPddlFrom in dGoldDeps[sample.pddlconn.sPddlTo]):
                sample.bGoldPos = True;

    sPredDictFile = config.get_string('PRED_DICT_FILE');
    if sPredDictFile != '':
        lPredicates = predicate.PredDictFileToPredList(sPredDictFile);
        dObjToPredList = collections.defaultdict(lambda:[]);
        for predCur in lPredicates:
            dObjToPredList[predCur.GetObject()].append(predCur);
        for sample in lSamples:
            sample.pddlconn.lFromPreds = dObjToPredList[sample.pddlconn.sPddlFrom];
            sample.pddlconn.lToPreds = dObjToPredList[sample.pddlconn.sPddlTo];
    else:
        assert False;
    #prune the unecessary features
    dFeatureCounts = collections.defaultdict(lambda:0);
    for sample in lSamples:
        for iFeature in sample.features.GetFeatureIndexList():
            dFeatureCounts[iFeature] += 1;
    iMinFeatureCount = config.get_int('MIN_FEATURE_OCCURANCE_COUNT');
    for sample in lSamples:
        for iFeature in sample.features.GetFeatureIndexList():
            if dFeatureCounts[iFeature] < iMinFeatureCount:
                sample.features.RemoveFeature(iFeature);
    return lSamples;
def LoadAllFullRewardsFiles():
    sRewardsDir = config.get_string('FULL_REWARDS_LOG_DIR');
    lRewards = [];
    print "Loading 200 Files From:", sRewardsDir;
    for iFileNum in range(config.get_int('REWARDS_MIN_ITER'), config.get_int('REWARDS_MAX_ITER')):
        sFile = sRewardsDir + '/predictions.log.' + str(iFileNum);
        lRewards.extend(LoadSingleFullRewardsFile(sFile));
    print "Done Loading";
    print "NumFF:", Reward.ComputeNumFfsFromList(lRewards);
    sys.exit(-1);
    return lRewards;
def LoadGoldStringConnSet():
    sGoldDepFile = config.get_string('GOLD_DEP_FILE');
    assert(sGoldDepFile != '');
    dGoldDeps = data.file_to_obj_with_comments(sGoldDepFile);
    setGoldConns = set();
    for sTo, dFrom in dGoldDeps.items():
        for sFrom in dFrom:
            if sFrom == 'num':
                continue;
            setGoldConns.add((sFrom, sTo));
    return setGoldConns;
    iNumGold = len(setGoldConns);
def WriteBadPredCounts(dFalsePosCounts, dFalseNegCounts, dTruePosCounts, dTotalCounts):
    if config.get_string('FALSE_POS_COUNTS_FILE') != '':
        WriteCountsFile(dFalsePosCounts, dTotalCounts, config.get_string('FALSE_POS_COUNTS_FILE'));
    if config.get_string('FALSE_NEG_COUNTS_FILE') != '':
        WriteCountsFile(dFalseNegCounts, dTotalCounts, config.get_string('FALSE_NEG_COUNTS_FILE'));
    if config.get_string('TRUE_POS_COUNTS_FILE') != '':
        WriteCountsFile(dTruePosCounts, dTotalCounts, config.get_string('TRUE_POS_COUNTS_FILE'));
def Run():
    if config.get_bool('CALC_CONN_FILE_FSCORE'):
        CalcConnFileFScore();
        return;
    elif config.get_bool('CALC_EASY_HARD_CONNECTIONS'):
        CalcEasyHardConnections();
        return;
    elif config.get_bool('LOAD_FULL_REWARDS'):
        LoadFullRewards();
        return;


    

    lSentences = Sentence.ReadSentencesFromTextFile();
    lGranularSamples = Sentence.GenAllGranularSamplesFromList(lSentences, 'sentences.log');

    if config.get_bool('CALC_ALL_TEXT_FSCORE'):
        CalcAllTextFScore(lGranularSamples);
    elif config.get_string('GRANULAR_SAMPLE_FILE') != '':
        Sample.GranularSample.WriteList(lGranularSamples, config.get_string('GRANULAR_SAMPLE_FILE'));
    elif config.get_string('SENTENCES_AND_FEATURES_FILE') != '':
        Sample.GranularSample.WriteDebugFromList(lGranularSamples, config.get_string('SENTENCES_AND_FEATURES_FILE'));
    elif config.get_string('SVM_CONNECTIONS_FILE') != '':
        WriteSvmConnectionsFile(lGranularSamples);
    elif config.get_string('FIRST_30_SVM_CONNECTIONS_FILE') != '':
        WriteFirst30SvmConnectionsFile(lGranularSamples);
    elif config.get_string('COLLAPSED_MANUAL_TEXT_CONNECTIONS_FILE'):
        lCollapsed = Sample.CollapseSamples(lGranularSamples);
        Sample.CollapsedSample.WriteConnections(lCollapsed, config.get_string('COLLAPSED_MANUAL_TEXT_CONNECTIONS_FILE'), bPosOnly = True);
    elif config.get_string('COLLAPSED_ALL_TEXT_CONNECTIONS_FILE'):
        lCollapsed = Sample.CollapseSamples(lGranularSamples);
        Sample.CollapsedSample.WriteConnections(lCollapsed, config.get_string('COLLAPSED_ALL_TEXT_CONNECTIONS_FILE'), bPosOnly = False);
    elif config.get_bool('TRAIN_ON_REWARD_EVAL_ON_GOLD'):
        TrainOnRewardEvalOnGold(lGranularSamples);
    else:
        Evaluate(lGranularSamples);
def TrainOnRewardEvalOnGold(lGranularSamples):
    #lGranularSamples = lGranularSamples[:100];
    assert(config.get_bool('COLLAPSE_FIRST'));
    dConnRewards = LoadRewardsDict();
    fNegMultiplier = PrintDebugInfo(dConnRewards);
    #add the reward data to the samples themselves
    lCollapsedSamples = Sample.CollapseSamples(lGranularSamples);
    lNewSamples = [];
    for sample in lCollapsedSamples:
        dRewards = dConnRewards[sample.pddlconn.sPddlFrom, sample.pddlconn.sPddlTo];
        if dRewards['iNumPos'] > 0:
            for iIter in range(dRewards['iNumPos']):
                sampleNew = copy.copy(sample);
                sampleNew._bPos = True;
                lNewSamples.append(sampleNew);
        else:
            for iIter in range(int(math.ceil(dRewards['iNumNeg']*fNegMultiplier))):
                sampleNew = copy.copy(sample);
                sampleNew._bPos = False;
                lNewSamples.append(sampleNew);
    lCollapsedSamples = lNewSamples;
    lFScores = [];
    lPrecisions = [];
    lRecalls = [];

    lTrainCollapsed, lTestCollapsed = SplitTrainTest(lCollapsedSamples);
    svm.Train(lTrainCollapsed);
    svm.Test(lTestCollapsed);
    # remove the duplicates
    setAlreadySeen = set();
    lTestNoDups = [];
    for sample in lTestCollapsed:
        tKey = (sample.pddlconn.sPddlFrom, sample.pddlconn.sPddlTo);
        if tKey not in setAlreadySeen:
            setAlreadySeen.add(tKey);
            lTestNoDups.append(sample);

    fScore, fPrec, fRecall = AnalyzePredsSimple(lTestNoDups);
    Sample.CollapsedSample.WriteConnections(lTestNoDups, config.get_string('SVM_REWARD_CONNECTIONS_FILE'), 
                                            bAppend=False, bWritePredictions = True, bPosOnly = True);
    fOut = open('debug.txt', 'w');
    for sample in lTestCollapsed:
        print >> fOut, "Sample:", sample.pddlconn.sPddlFrom, sample.pddlconn.sPddlTo, sample.fPred;

    print "Precision: ", fPrec
    print "Recall: ", fRecall
    print "F-Score: ", fScore;
def LoadFullRewards():
    dConnRewards = reward.LoadFullRewardsDict();
    #print "Len:", len(dConnRewards);
    #for (sFrom, sTo), cr in dConnRewards.items():
    #    print sFrom, sTo, "Pos:", cr.iNumPos, "NE:", cr.iNumEarlierNeg, "NR:", cr.iNumNoReachNeg;
    #lGranularSamples = lGranularSamples[:100];
    assert(config.get_bool('COLLAPSE_FIRST'));
    #add the reward data to the samples themselves
    lSentences = Sentence.ReadSentencesFromTextFile();
    lGranularSamples = Sentence.GenAllGranularSamplesFromList(lSentences, 'sentences.log');
    lCollapsedSamples = Sample.CollapseSamples(lGranularSamples);
    setEasy = set(data.file_to_obj(config.get_string('EASY_CONNECTIONS_LIST_FILE')));
    lTrainCollapsed = filter(lambda sample: sample.pddlconn.sPddlTo in setEasy, lCollapsedSamples);
    lTestCollapsed = filter(lambda sample: sample.pddlconn.sPddlTo not in setEasy, lCollapsedSamples);
    
    lTrainingSamples = GenerateTrainingSamplesFromRewards(dConnRewards, lTrainCollapsed);
    if config.get_bool('SVM'):
        svm.Train(lTrainingSamples);
        svm.Test(lTestCollapsed);
    elif config.get_bool('LOG_LINEAR'):
        log_linear.TrainAndTestLogLinear(lTrainingSamples, lTestCollapsed);
    else:
        assert False;
    # remove the duplicates
    setAlreadySeen = set();
    lTestNoDups = [];
    for sample in lTestCollapsed:
        tKey = (sample.pddlconn.sPddlFrom, sample.pddlconn.sPddlTo);
        if tKey not in setAlreadySeen:
            setAlreadySeen.add(tKey);
            lTestNoDups.append(sample);

    fScore, fPrec, fRecall = AnalyzePredsSimple(lTestNoDups);
    #Sample.CollapsedSample.WriteConnections(lTestNoDups, config.get_string('SVM_REWARD_CONNECTIONS_FILE'), 
    #                                        bAppend=False, bWritePredictions = True, bPosOnly = True);
    #fOut = open('debug.txt', 'w');
    #for sample in lTestCollapsed:
    #    print >> fOut, "Sample:", sample.pddlconn.sPddlFrom, sample.pddlconn.sPddlTo, sample.fPred;

    print "Precision: ", fPrec
    print "Recall: ", fRecall
    print "F-Score: ", fScore;
def CalcAllTextFScore(lGranularSamples):
    lCollapsedSamples = Sample.CollapseSamples(lGranularSamples);
    lSorted = data.file_to_obj(config.get_string('SORTED_CONNECTIONS_LIST_FILE'));
    lSorted.reverse();
    lPos = [0 for i in range(len(lSorted))];
    lNeg = [0 for i in range(len(lSorted))];
    iPosTot = 0;
    iNegTot = 0;
    for sample in lCollapsedSamples:
        if sample.bPos:
            iPosTot += 1;
        else:
            iNegTot += 1;
        for i in range(len(lSorted)):
            if sample.pddlconn.sPddlTo != lSorted[i]:
                continue;
            if sample.bPos:
                lPos[i] += 1;
            else:
                lNeg[i] += 1;
    for i in range(len(lSorted)):
        fPrecision = float(lPos[i])/float(lPos[i] + lNeg[i]) if (lPos[i] + lNeg[i]) != 0 else 0;
        print lSorted[i], fPrecision;
    print "Overall Precision:", float(iPosTot)/float(iNegTot);
Esempio n. 21
0
# coding=utf-8

# 通知功能

import requests

import config

_DING_NOTIFY_URL = 'https://oapi.dingtalk.com/robot/send?access_token=' \
                   + config.get_string('notify', 'ding_token')


def notify_by_dingding(msg):
    """
    使用钉钉发送通知消息
    :return:
    """
    send_obj = {"msgtype": 'text', 'text': {'content': msg}}
    requests.post(_DING_NOTIFY_URL, json=send_obj)


if __name__ == '__main__':
    notify_by_dingding('币价涨了')
def AnalyzePredsSimple(lSamples):
    if config.get_bool('FORCE_SINGLE_DIR'):
        dSamples = {};
        for sample in lSamples:
            tKey = (sample.pddlconn.sPddlFrom, sample.pddlconn.sPddlTo);
            assert(tKey not in dSamples);
            dSamples[tKey] = sample;

    iNumTotal = 0;
    iNumCorrect = 0;
    iTruePos = 0;
    iFalsePos = 0;
    iTrueNeg = 0;
    iFalseNeg = 0;
    iThres = 0;
    if config.get_bool('SVM'):
        fThres = config.get_int('SVM_THRESHOLD');
    elif config.get_bool('LOG_LINEAR'):
        fThres = 0.5
    else:
        assert False;

    if config.get_bool('CALC_FSCORE_ON_GOLD'):
        setGoldStringConns = LoadGoldStringConnSet()
        iNumGold = len(setGoldStringConns);

    if config.get_bool('ANALYZE_ON_HARD'):
        lEasy = data.file_to_obj(config.get_string('EASY_CONNECTIONS_LIST_FILE'));
    fPredMin = sys.float_info.max;
    fPredMax = -sys.float_info.max;
    for sample in lSamples:
        if config.get_bool('ANALYZE_ON_HARD'):
            if sample.pddlconn.sPddlTo in lEasy:
                continue;

        if config.get_bool('TRAIN_ON_REWARD_EVAL_ON_GOLD'):
            bActual = sample.GetGoldPos(bIgnoreDir = config.get_bool('IGNORE_DIR_FOR_EVAL'));
        else:
            bActual = sample.GetPos(bIgnoreDir = config.get_bool('IGNORE_DIR_FOR_EVAL'));
        if config.get_bool('FORCE_SINGLE_DIR'):
            fPred = sample.fPred;
            tReverseKey = (sample.pddlconn.sPddlTo, sample.pddlconn.sPddlFrom);
            fReversePred = dSamples[tReverseKey].fPred if tReverseKey in dSamples else -sys.maxint;
            bNormalPred = (float(sample.fPred) > fThres);
            bPred = ((float(sample.fPred) > fThres) and (float(fPred) >= float(fReversePred)));
            if tReverseKey not in dSamples:
                print "FORCE-MISSING";
            elif (bNormalPred == bActual) and (bPred != bActual):
                print "FORCE-BAD:", sample.pddlconn.sPddlFrom, sample.pddlconn.sPddlTo, fPred, fReversePred;
            elif  (bNormalPred != bActual) and (bPred == bActual):
                print "FORCE-GOOD:", sample.pddlconn.sPddlFrom, sample.pddlconn.sPddlTo, fPred, fReversePred;
            else:
                print "FORCE-NEITHER:", sample.pddlconn.sPddlFrom, sample.pddlconn.sPddlTo, fPred, fReversePred;
        else:
            bPred = sample.GetPredPos(bIgnoreDir = config.get_bool('IGNORE_DIR_FOR_EVAL'));
        fPredMin = min(fPredMin, sample.fPred);
        fPredMax = max(fPredMax, sample.fPred);

        iNumTotal += 1;
        if bPred == bActual:
            iNumCorrect += 1;
        if bPred:
            if bActual:
                iTruePos += 1;
            else:
                iFalsePos += 1;
        else:
            if bActual:
                iFalseNeg += 1;
            else:
                iTrueNeg += 1;

    if config.get_bool('CALC_FSCORE_ON_GOLD'):
        iFalseNeg = iNumGold - iTruePos;
        if config.get_bool('ANALYZE_ON_HARD'):
            iFalseNeg = iNumGold - iTruePos - len(lEasy);

    fPrecision = float(iTruePos)/float(iTruePos+iFalsePos) if iTruePos > 0 else 0;
    fRecall = float(iTruePos)/float(iTruePos+iFalseNeg) if iTruePos > 0 else 0;
    fScore = 2*fPrecision*fRecall/(fPrecision+fRecall) if (fPrecision*fRecall) > 0 else 0;
    print "FPred: min:", fPredMin, "max:", fPredMax;
    print "FScore:", fScore, fPrecision, fRecall;
    print "Frac Correct:", float(iNumCorrect)/float(iNumTotal), iNumCorrect, iNumTotal;
    print "TP:", iTruePos, "FP:", iFalsePos, "TN:", iTrueNeg, "FN:", iFalseNeg;
    print "FracPos:", float(iTruePos+iFalsePos)/float(iTrueNeg+iFalseNeg+iTruePos+iFalsePos);
    return fScore, fPrecision, fRecall;
Esempio n. 23
0
    disp.print("Bat: %.2fV" % power.read_battery_voltage(),
               posy=60,
               fg=color.WHITE)
    disp.update()


last_rx_time = 0
disp = display.open()
v_old = 0
pause = 1

interrupt.set_callback(interrupt.BLE, ble_callback)
interrupt.enable_callback(interrupt.BLE)

try:
    vib_mode = int(config.get_string("exno_vib_mode"))
except:
    pass

try:
    led_mode = int(config.get_string("exno_led_mode"))
except:
    pass

disp.clear()
disp.print(" Exp Notif", posy=0, fg=color.WHITE)
disp.print("  Logger", posy=20, fg=color.WHITE)
disp.print("           ", posy=40, fg=color.WHITE)
disp.print("   BL On ->", posy=60, fg=color.WHITE)
disp.update()