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()
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")
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")
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")
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)
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
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()
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)
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)
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)
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()
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..")
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"]
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
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"]
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()
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
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
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)