Пример #1
0
 def _set_params(self):        
     rootd = f.get_json_data(self.prgname)
     ml = f.get_json_data("ml_params")
     pf = rootd["play_fields"]
     tp = rootd["train_player"]
     self.pf_table = pf["table"]
     self.pf_capacity = pf["capacity"]
     self.pf_unit_size = pf["unit_size"]
     self.pf_max_dist_num = pf["max_dist_num"]
     self.pf_min_size = pf["min_size"]
     self.trade_mode = tp["trade_mode"]
     self.train_count = tp["train_count"]
     self.tp_table = tp["table"]
     self.tp_template = tp["table_template"]
     self.play_style = tp["play_style"]
     self.startd = tp["startd"]
     self.endd = tp["endd"]
     self.expected_trade_period = tp["expected_trade_period"]
 
     self.parameter = ml["parameter"]
     self.thread_num = ml["thread_num"]
     self.elite_num = ml["elite_num"]
 
     self.gene_template = f.get_json_data(self.play_style)
     self.default_list, self.default_geneid = self._create_default_list()
     self.range_list = self._create_range_list()
Пример #2
0
def prepare(meigaras=[]):
    f.log("Starting preparation")
    rootd = f.get_json_data("prepare")
    
    # Setup
    d = rootd["create_tables"]
    if d["enabled"] == 1:
        f.log("Creating tables")
        tables = d["names"]
        for t in tables:
            tbl.create_table(t)
    
    # Import kabuka data
    d = rootd["import_kabuka"]
    if d["enabled"] == 1:
        f.log("Importing kabuka")
        kdb.import_kabuka(d["start"], d["end"])
    
    # Init tables
    d = rootd["init_tables"]
    if d["enabled"] == 1:
        f.log("Initializing tables")
        tbl.init_eigyobi()
        tbl.init_meigaras()
    
    # Update Daw table
    d = rootd["update_dow"]
    if d["enabled"] == 1:
        f.log("Updating DOW table")
        learn("dow", meigaras)
    
    f.log("Finished preparation")
Пример #3
0
def train_bydate(cnt=100):
    json = f.get_json_data("ml_train_tf")
    span = json["span"]
    
    term_len = json["term_len"]
    dup_len = json["dup_len"]
    
    train_startd = span[0]
    train_endd = span[1]
    
    starti = 0
    eigyobis = dtf.get_eigyobis(train_startd, train_endd)
    while starti+term_len <= len(eigyobis):
        tmp_endd = eigyobis[starti+term_len]
        f.log("Training nikkei 225")
        train225(eigyobis[starti], tmp_endd)
        
        
        f.log("Training from %s to %s" % (eigyobis[starti], tmp_endd))
        multi_training(eigyobis[starti], tmp_endd, get_meigaras(cnt, tmp_endd))
        
        predict_starti = starti+term_len+1
        if predict_starti < len(eigyobis):
            predict_endi = predict_starti + term_len
            if predict_endi >= len(eigyobis):
                predict_endi = len(eigyobis)-1
            
            tmp_endd = eigyobis[predict_endi]
            f.log("Making prediction from %s to %s" % (eigyobis[predict_starti], tmp_endd))
            multi_predict2db(eigyobis[starti], tmp_endd, get_meigaras(cnt, tmp_endd, term_len))
        
        starti += term_len - dup_len
        
    f.log("Finished")
Пример #4
0
def learn2(prgname, meigaras=[]):
    f.log("Starting learning")
    rootd = f.get_json_data(prgname)
    
    pf = get_element("play_fields", rootd)
    
    # Generate PlayField Data
    if pf["enabled"] == 1:
        mpf.create_pf2(prgname, meigaras)

    # Generate PlayField Data
    if pf["enabled"] == 1:
        mpf.create_pf(prgname, meigaras)

    # Train Players
    tp = get_element("train_player", rootd)
    if tp == None:
        return
    if tp["enabled"] == 1:
        startd = tp["startd"]
        endd = tp["endd"]
        tm = TraderMemory(meigaras, startd, endd)
        #mtp.train(prgname, tm)
        trn = Training(prgname, tm)
        trn.train()
    
    f.log("Finished learning")
Пример #5
0
    def __init__(self, prgname, meigaras=[]):
        '''
        Constructor
        '''
        rootd = f.get_json_data(prgname)
        d = rootd["play_fields"]
        self.chart_prg = d["prg_name"]
        self.ml_algorithm = d["ml_algorithm"]
        startd = d["startd"]
        endd = d["endd"]
        self.table_name = d["table"]
        #self.sd_table = d["sd_table"]
        self.meigaras = meigaras
        self.startd = startd
        self.endd = endd

        tbl.create_table_from_tmpl("pf", [self.table_name])
            
        #if self.sd_table != "":
        #    tbl.create_table_from_tmpl("sd", [self.sd_table])
        
        #self.kabuka_generator = kf.g_get_kabuka(meigaras, startd, endd)

        classifier = None
        if self.ml_algorithm == "mini_batch_kmeans":
            self.classifier = kmeans.KMeans(self.chart_prg, meigaras)
Пример #6
0
    def __init__(self, kls):
        self.kls = kls
        ts = f.get_json_data("ts_default")
        self.init_amount = ts["init_amount"]

        self.balance = self.init_amount
        self.stocks = {}
        self.deposit = 0
Пример #7
0
def _set_params(prgname):
    global pf_table
    global pf_capacity
    global pf_unit_size
    global pf_max_dist_num
    global pf_min_size
    global trade_mode
    global train_count
    global tp_table
    global tp_template
    global default_list
    global default_geneid
    global gene_template
    global range_list
    global play_style
    global parameter
    global thread_num
    global elite_num
    global startd
    global endd
    
    rootd = f.get_json_data(prgname)
    ml = f.get_json_data("ml_params")
    pf = rootd["play_fields"]
    tp = rootd["train_player"]
    pf_table = pf["table"]
    pf_capacity = pf["capacity"]
    pf_unit_size = pf["unit_size"]
    pf_max_dist_num = pf["max_dist_num"]
    pf_min_size = pf["min_size"]
    trade_mode = tp["trade_mode"]
    train_count = tp["train_count"]
    tp_table = tp["table"]
    tp_template = tp["table_template"]
    play_style = tp["play_style"]
    startd = tp["startd"]
    endd = tp["endd"]

    parameter = ml["parameter"]
    thread_num = ml["thread_num"]
    elite_num = ml["elite_num"]

    gene_template = f.get_json_data(play_style)
    default_list, default_geneid = _create_default_list()
    range_list = _create_range_list()
Пример #8
0
def learn_line(prgname, meigaras=[]):
    f.log("Starting learning")
    rootd = f.get_json_data(prgname)
    
    pf = get_element("play_fields", rootd)
    
    # Generate PlayField Data
    if pf["enabled"] == 1:
        mpf.create_pf2(prgname, meigaras)
Пример #9
0
 def set_default_params(self):
     params = f.get_json_data("ps_line_trade")
     geneid = ""
     for k in params["keys"]:
         d = params[k]["default"]
         if geneid == "":
             geneid = str(d)
         else:
             geneid = "%s-%d" % (geneid, d)
     
     self.set_gene(geneid)
Пример #10
0
def train_bymeigara(code):
    json = f.get_json_data("ml_train_tf")
    span = json["span"]
    term_len = json["term_len"]
    dup_len = json["dup_len"]
    
    startd = span[0]
    endd = span[1]
    
    tfl = TfLearning("DAILY", [code])
    tfl.run(startd, endd)
Пример #11
0
 def _set_params(self):
     rootd = f.get_json_data(self.prgname)
     ml = f.get_json_data("ml_params")
     pf = rootd["play_fields"]
     tp = rootd["train_player"]
     self.pf_table = pf["table"]
     self.pf_capacity = pf["capacity"]
     self.pf_min_size = pf["min_size"]
     self.train_count = tp["train_count"]
     self.tp_table = tp["table"]
     self.tp_template = "tp2"
     self.play_style = tp["play_style"]
     self.periods = tp["periods"]
 
 
     self.parameter = ml["parameter"]
     self.thread_num = ml["thread_num"]
     self.elite_num = ml["elite_num"]
 
     self.gene_template = f.get_json_data(self.play_style)
     self.default_list, self.default_geneid = self._create_default_list()
     self.range_list = self._create_range_list()
Пример #12
0
def create_pf(prgname, meigaras=[]):
    f.log("Start creating Play Fields..")
    
    params = f.get_json_data("ml_params")
    rootd = f.get_json_data(prgname)
    r = params["num_of_meigaras_per_octproc"]
    d = rootd["play_fields"]
    jsonpath = "%s/%s.json" % (JSON_DIR, prgname)
    startd = d["startd"]
    endd = d["endd"]
    table_name = d["table"]
    tmpl = d["table_template"]
    
    if len(meigaras) == 0:
        meigaras = kf.get_meigaras()
    
    if tmpl != "":
        tbl.create_table_from_tmpl(tmpl, [table_name])
    
    i = 0
    while i < len(meigaras):
        f.log("Processing from %d to %d.." % (i,i+r-1))
        submeigaras = meigaras[i:i+r]
        outfile = "%s/%s_data.csv" % (TMP_DIR, prgname)
        
        f.log("Outputting file " + outfile)
        kf.kabuka2csv(outfile, "w", submeigaras, startd, endd)
        oc = octave.get_octave()
        
        f.log("Making %s data(octave)" % (prgname))
        f.log("oc.ml_kabuka(\'%s\',\'%s\')" % (jsonpath, outfile))
        impfile = oc.ml_kabuka(jsonpath, outfile)
        
        f.log("Importing from file %s to table %s" % (impfile, table_name))
        tbl.imp_csv2table(impfile, "trade.%s" % table_name)
        i += r
        
    f.log("Finished creating Play Fields..")
Пример #13
0
 def __init__(self, prgname, trade_strategy, trade_mode):
     '''
     Constructor
     '''
     self.prgname = prgname
     rootd = f.get_json_data(trade_strategy)        
     self.tp_table = "tp_%s" % prgname
     self.pf_table = "pf_%s" % prgname
     self.trade_mode = trade_mode
     self.min_points = rootd["min_points"]
     self.min_cnt = rootd["min_field_cnt"]
     self.top_fieldid_num = rootd["top_fieldid_num"]
     self.price_moving_rate_limit = rootd["price_moving_rate_limit"]
     self.use_dow = rootd["use_dow"]
     self.volsize_limit = rootd["volsize_limit"]
Пример #14
0
def get_meigaras(cnt, datestr, diagdays=20):
    json = f.get_json_data("ml_train_tf")
    must_meigaras = json["must_meigaras"]
    
    meigaras = kf.get_goodmeigaras(datestr=datestr, cnt=cnt, diagdays=diagdays)
    for m_code in must_meigaras:
        include_flg = False
        for code in meigaras:
            if str(code) == str(m_code):
                include_flg = True
                break
        if include_flg == False:
            meigaras.append(m_code)
    
    return meigaras
Пример #15
0
 def __init__(self, prgname, trade_strategy):
     '''
     Constructor
     '''
     self.prgname = prgname
     rootd = f.get_json_data(trade_strategy)        
     self.tp_table = "tp_%s" % prgname
     if prgname.endswith("_default"):
         self.pf_table = "pf_%s" % prgname.replace("_default", "")
     else:
         self.pf_table = "pf_%s" % prgname
     self.min_score = rootd["min_score"]
     self.min_cnt = rootd["min_field_cnt"]
     self.top_fieldid_num = rootd["top_fieldid_num"]
     self.price_moving_rate_limit = rootd["price_moving_rate_limit"]
     self.volsize_limit = rootd["volsize_limit"]
Пример #16
0
 def __init__(self, meigaras=[]):
     self.meigaras = meigaras
     ts = f.get_json_data("ts_default")
     self.init_amount = ts["init_amount"]
     self.one_cycle_period = ts["one_cycle_period"]
     self.division = ts["division"]
     self.max_trade_amount_rate = ts["max_trade_amount_rate"]
     self.min_points = ts["min_points"]
     self.min_field_cnt = ts["min_field_cnt"]
     self.startd = ts["startd"]
     self.endd = ts["endd"]
     self.prgnames = ts["prgnames"]
     
     self.stocks = {}
     self.traders = {}
     self.relative_date_idx = 0
     
     self.tm = TraderMemory(meigaras, self.startd, self.endd)
     self.account = Account(self.tm)
     self._get_lms()
Пример #17
0
 def __init__(self, meigaras=[], trade_mode="BOTH", logfile="", tf_load_dir=""):
     self.meigaras = meigaras
     ts = f.get_json_data("ts_default")
     self.init_amount = ts["init_amount"]
     self.one_cycle_period = ts["one_cycle_period"]
     self.division = ts["division"]
     self.max_trade_amount_rate = ts["max_trade_amount_rate"]
     self.min_score = ts["min_score"]
     self.min_field_cnt = ts["min_field_cnt"]
     self.startd = ts["startd"]
     self.endd = ts["endd"]
     self.prgnames = ts["prgnames"]
     
     self.stocks = {}
     self.traders = {}
     self.relative_date_idx = 0
     self.balance = self.init_amount
     self.loan = 0
     self.date = self.startd
     #self._get_lms()
     self.trade_mode = trade_mode
Пример #18
0
def train_bydate(cnt=100, startd="", endd="", term_len=0, dup_len=0):
    json = f.get_json_data("ml_train_tf")
    span = json["span"]
    
    if term_len == 0:
        term_len = json["term_len"]
    if dup_len == 0:
        dup_len = json["dup_len"]
    
    if startd == "":
        startd = span[0]
    if endd == "":
        endd = span[1]
    
    eigyobis = dtf.get_eigyobis(startd, endd)
    
    
    starti = 0
    tfl = TfLearning(restore_first=True)
    while starti+term_len <= len(eigyobis):
        tmp_endd = eigyobis[starti+term_len]
        f.log("Training from %s to %s" % (eigyobis[starti], tmp_endd))
        tfl.run(eigyobis[starti], tmp_endd, tmp_endd, get_meigaras(cnt, tmp_endd))
        starti += term_len - dup_len
Пример #19
0
def gen_pf_line(startd, endd, meigaras=[]):
    if len(meigaras) == 0:
        meigaras = kf.get_meigaras()

    params = f.get_json_data("ml_params")
    rootd = f.get_json_data("ml_line")
    d = rootd["play_fields"]
    table_name = d["table"]
    y_consider_span = d["y_consider_span"]
    losscut_rate = d["losscut_rate"]
    interest_rate = d["interest_rate"] 
    tmpl = "pf2"

    if len(meigaras) == 0:
        meigaras = kf.get_meigaras()
    
    if tmpl != "":
        tbl.create_table_from_tmpl(tmpl, [table_name])

    trade_mode_str = ""
    for code in meigaras:
        mcode = []
        dl = []
        vl = []
        X = []
        y = []
        
        if DEBUG:
            print "Processing code:%s" % (code)
        kl = KabukaLines(code, startd, endd)
        lt = LineTrader(kl)
            
        kabuka = kl.get_kabuka()
        if len(kabuka) == 7:
            (indexes, dates, open, high, low, close, volume) = kabuka
        else:
            continue
        
        starti = 60
        if len(dates) <= starti+1:
            continue
        
        code_startd = dates[starti]
        code_endd = dates[-1]
        #(trade_signs, trade_signs_d_idxs) = lt.get_trade_signs(code_startd, code_endd)
        passed_d_idxs = lt.get_passed_days(code_startd, code_endd)
        if DEBUG:
            passed_dates = []
            for i in passed_d_idxs:
                passed_dates.append(dates[i])
        
        
        j = -1
        for i in passed_d_idxs:
            j+=1
            if i < starti:
                continue
            
            if lt.judge_trade_goodness(i) == False:
                continue
    
            fieldid = lt.generate_fieldid(i)
            #if need_y:
                #(trade_mode_str, interest, from_date, to_date, spent, start_price, end_price, endi) \
                #= lt.test(dates[i], dates[-1])
                #y.append(interest)
                #report.append([trade_mode_str, from_date, to_date, spent, start_price, end_price])
            datei = i
            start_price = open[datei]
            
            if start_price <= 0:
                continue
            
            min_close = min(close[datei:datei+y_consider_span])
            max_close = max(close[datei:datei+y_consider_span])
            h = max(high[datei:datei+y_consider_span])
            l = min(low[datei:datei+y_consider_span])
            
            min_close_rate = (min_close-start_price)*1.0/start_price
            max_close_rate = (max_close-start_price)*1.0/start_price
            h_rate = (h-start_price)*1.0/start_price
            l_rate = (l-start_price)*1.0/start_price
            
            sign = 0
            if max_close_rate >= interest_rate and abs(l_rate) < losscut_rate:
                sign = int(max_close_rate*100)
            if abs(min_close_rate) >= interest_rate and abs(h_rate) < losscut_rate:
                sign = int(min_close_rate*100)
                
            
            mcode.append(code)
            dl.append(dates[i])
            vl.append(np.mean(volume[i-5:i+1]))
            X.append(fieldid)
            y.append(sign)
        
            
        mcode = np.array(mcode)
        dl = np.array(dl)
        vl = np.array(vl)
        if len(dl) <= 0:
            continue
        X = np.array(X)
        y = np.array(y)
        r = np.c_[mcode, dl, X, vl, y]
        tbl.arr2table(r, table_name)