Example #1
0
def evalFold(arg):
    train_index, test_index = arg
    
    SS = StrategyScheduler()
    SS.fit(X[train_index], ys[train_index], yNames)
    
    success_count = 0
    for i in test_index:
        success, score = SSS.eval_schedule('%s#%s' % (XNames[i], SS.predict(X[i])))
        if success:
            success_count += 1
            
    print 'Current: %i / %i' % (success_count, len(test_index))
    return (success_count, len(test_index))
Example #2
0
from StrategyScheduler import StrategyScheduler
from MLiP_eval import StrategyScheduleScore

if __name__ == '__main__':
    trainFile = 'orig/MLiP_train' 
    testFile = 'orig/MLiP_train'
    mySchedule = 'My_MLiP_train_example_schedule'
    
    SS = StrategyScheduler()
    SS.fit_file(trainFile)
    
    X, XNames = StrategyScheduler.read(testFile, False)
    N,M = X.shape
    
    # Create schedules
    with open(mySchedule,'w') as OS:
        for i in range(N):
            schedule = SS.predict(X[i])
            OS.write('%s#%s\n' % (XNames[i], schedule))

    # Evaluate schedule 
    Eval = StrategyScheduleScore(testFile)
    solved, score = Eval.eval_schedules(mySchedule)
    print 'Solved: %s %%' % solved                    
    print 'Score: %s %%  (%s / %s)' % (round(100*score/Eval.bestScore,4),score,Eval.bestScore)
Example #3
0
    SS = StrategyScheduler()
    SS.fit(X[train_index], ys[train_index], yNames)
    
    success_count = 0
    for i in test_index:
        success, score = SSS.eval_schedule('%s#%s' % (XNames[i], SS.predict(X[i])))
        if success:
            success_count += 1
            
    print 'Current: %i / %i' % (success_count, len(test_index))
    return (success_count, len(test_index))

if __name__ == '__main__':
    trainFile = 'orig/MLiP_train' 
    
    SSS = StrategyScheduleScore(trainFile)
    X, ys, XNames, yNames = StrategyScheduler.read(trainFile)
    N,M = X.shape
    
    kf = skcv.KFold(n=N, n_folds=N-1)
    
    success_count = 0
    total_count = 0
    
    pool = Pool()
    for success_sub, total_sub in pool.map(evalFold, kf):
        success_count += success_sub
        total_count += total_sub
    
    print 'Solved: %s %%' % round(100.0 * success_count / total_count, 2)
from StrategyScheduler import StrategyScheduler
from MLiP_eval import StrategyScheduleScore

if __name__ == '__main__':
    trainFile = 'orig/MLiP_train'
    
    X, ys, XNames, yNames = StrategyScheduler.read(trainFile)
    
    SS = StrategyScheduler()
    SS.fit(X, ys, yNames)
    
    SS.analyze(X, ys)