Esempio n. 1
0
 def word_distance(cls, token_list, sentence_list):
     token_pairs = list(combinations(token_list, size=2))
     ret = {}
     for sentence in sentence_list:
         for a, b in token_pairs:
             dist_a = cls.locate_word(a, sentence)
             if dist_a < 0:
                 continue
             dist_b = cls.locate_word(b, sentence)
             if dist_b < 0:
                 continue
             if dist_a > dist_b:
                 dist = dist_a - dist_b
             else:
                 dist = dist_b - dist_a
             #logging.info((a,b,dist ))
             if a not in ret:
                 ret[a] = {}
             if b not in ret[a]:
                 ret[a][b] = []
             if b not in ret:
                 ret[b] = {}
             if a not in ret[b]:
                 ret[b][a] = []
             ret[a][b].append(dist)
             ret[b][a].append(dist)
     return ret
Esempio n. 2
0
 def getStocks(cls, stock_list):
     minimum_portfolio_size = len(stock_list) - 2
     count = len(stock_list) - 1
     while count > minimum_portfolio_size:
         data = EXTRACT.load(stock_list)
         stock_list = sorted(data.keys())
         for subset in combinations(stock_list, count):
             logging.info((len(subset), sorted(subset)))
             yield data, sorted(subset)
         stock_list = TRANSFORM_STOCK.truncate(stock_list, count)
         count = len(stock_list) - 1
Esempio n. 3
0
    def stocks(cls, data):
        stock_list, minimum_portfolio_size = cls.validate(data)
        if len(stock_list) == 0:
            return
        if len(stock_list) <= 3:
            yield stock_list
            return

        yield stock_list
        count = len(stock_list) - 1
        while count > minimum_portfolio_size:
            for subset in combinations(stock_list, count):
                yield sorted(subset)
            stock_list = cls.reduceRisk(data, count)
            count = len(stock_list) - 1
            if count < 3:
                break
Esempio n. 4
0
 def stocks(self, data) :
     ret = data.drop(labels=self.columns_drop,errors='ignore')
     stock_list, minimum_portfolio_size = TRANSFORM.validate(ret)
     if len(stock_list) == 0 :
        return
     if len(stock_list) <= 3 :
        yield stock_list
        return
     yield stock_list
     count = len(stock_list)-1
     while count > minimum_portfolio_size :
         for subset in combinations(stock_list,count) :
             yield sorted(subset)
         stock_list = BACKGROUND.reduceRisk(ret,count)
         count = len(stock_list)-1
         if count < 3 :
            break
Esempio n. 5
0
def main(file_list, stock_list):
    stock_list = init(*ini_list)
    name, spy_data = prep(*file_list)

    annual = MonteCarlo.YEAR()

    stock_data = pd.DataFrame()
    stock_data[name] = spy_data['Adj Close']

    max_sharp, min_vol = annual([name], stock_data)
    logging.info(max_sharp)
    logging.info(min_vol)

    stock_name = []
    for name, stock in read(file_list, stock_list):
        stock_name.append(name)
        stock_data[name] = stock['Adj Close']
    for subset in combinations(stock_name):
        logging.info(subset)
        max_sharp, min_vol = annual(subset, stock_data)
        logging.info(max_sharp)
        logging.info(min_vol)