Tối ưu hoá danh mục thông qua LLM

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

def load_google_news_before(query: str, before_date: datetime.date, num_results: int = 30):
    """
    Query Google News via LangChain’s Google Serper API Wrapper, filtering articles
    so that only those published before the given date are returned.
    """
    cd_min = convert_date_to_str(before_date - datetime.timedelta(days=90))
    cd_max = convert_date_to_str(before_date)
    tbs = f"cdr:1,cd_min:{cd_min},cd_max:{cd_max}"
    search = GoogleSerperAPIWrapper(type="news", tbs=tbs, gl="vn",hl='vi',k=num_results)
    results = search.results(query)
    return results

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

## Sử dụng pydantic để ép model trả về dạng dữ liệu như mong muốn
class Sentiment(BaseModel):
    sentiment: str = Field(default=None, description="The financial market sentiment of all news", enum=["bearish", "bullish", "neutral"])
    explanation: str = Field(default=None, description="The short explanation about the chosen sentiment ")
    catalyst: List[str] = Field(default=None, description="The catalyst based on all news")
    risk_factor: List[str] = Field(default=None, description="The risk factor based on all news")

def extract_key_info(stock , date):
    """
    Extract key information from a news article.
    """
    nest_asyncio.apply()
    query = f"đầu tư cổ phiếu {stock}"
    # For example, retrieve articles published before January 1, 2025.
    cutoff_date = date
    articles = load_google_news_before(query, cutoff_date, num_results=15)
    links = pd.DataFrame(articles['news'])['link'].to_list()
    ## drop the link from https://etime.danviet.vn
    links = [link for link in links if 'danviet.vn' not in link] ## skip for danviet.vn as it block the request
    loader = WebBaseLoader(links, continue_on_failure=True)

    loader.requests_per_second = 0.5
    docs = loader.aload()
    ls = []
    for doc in docs:
        ls.append(doc.page_content.replace('\n\n', '').replace('\n', ' '))

    llm = ChatOpenAI(model='gpt-4o-mini')

    prompt = """
    You're a senior analyst. You are analyzing stock {stock}
    Your tasks are: 
    - Analyze the sentiment of the given news
    - Explain the sentiment in few words
    - Identify the key catalysts or drivers
    - Identify the risk factors

    {document}

    Requirement
    - Be specific and concise
    - Do not make up information or make assumption
    - Do not use external source
    """.format(stock = stock,document=ls)

    response = llm.with_structured_output(Sentiment).invoke(prompt)
    return response
    
    
date = datetime.date(2024, 1, 1)
extract_key_info('HPG', date)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

prompt = """
Create a portfolio with the following stocks: {stocks}

Objective:
- Use the technical signal, market sentiment and catalysts to assign weight to each stock for a long-only portfolio
- The portfolio aim to invest in the stock with the highest potential return

Constraints:
- The portfolio should be well diversified
- You can invest in each stock with a maximum of 0.5 of the portfolio
- You do not need to invest in all stocks, but you must invest in at least 4 stocks. Only select the most promising stocks.
- There is no leverage & short selling
- The holding period is 3 months (1 quarter)
- The weight should be a float number between 0 and 1
- The sum of all weights should be 1

Workflow:
1. Analyze information first. 
2. Based on the catalysts, identify the stocks that are likely to perform well.
3. Assess the sentiment of the news to confirm the potential of the selected stocks.
4. Use the technical signal to further confirm the potential of the stocks.
5. Finally, use the past 3 months' risk-return data to identify overbought or hyped stocks to avoid allocating too much capital to them. However, if the catalyst is highly promising, you may still allocate funds to it if you believe it has significant potential.
6. Assign weights to each stock based on the potential return driven by the catalyst.
7. Allocate more weight to stocks where the catalyst is more likely to occur and has a higher magnitude.
8. Be confident in assigning higher weights to stocks with better catalysts and sentiment.
9. **Think carefully; do not simply split the weights equally.**

Technical signal: simple EMA50-200 crossover, 1 for bullish, 0 for bearish
{ta_signal}

Past 3 risk return
{risk_return}

News sentiment (0 for bearish, 1 for bullish, 2 for neutral) & Catalysts
{sentiment}

Correlation between stocks
{correlation}

Your previous portfolio
{past_portfolios}

Your previous return: {last_period_return}

Output
- A list with weight for every stock. The weight must correspond to the oder {stocks}. For stock that not invest, simple return 0 for the weight
- A detailed explanation of the rationale behind the portfolio allocation
"""

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

class PortfolioOptimizationResult(BaseModel):
    """
    A class to represent the result of portfolio optimization.
    """
    stock_weight: List[float] = Field(
        default=None,
        description="A list containing the weight for all stocks in the portfolio."
    )
    explanation: str = Field(
        default=None,
        description="A detailed explanation of the rationale behind the portfolio allocation."
    )
    
def llm_optimizer(date, stocks = ['FPT', 'HPG', 'MWG', 'REE', 'VCB', 'VNM'], past_portfolios = None, last_period_return = None):
    results = run_in_parallel(stocks, date)
    
    llm = ChatOpenAI(model='gpt-4o')
    ta_signal = ta_compare[:date].iloc[-1]
    
    start_sample = date - datetime.timedelta(days=30*3) ## 3 months
    sample_rets = rets[start_sample:date]
    risk_return = ((1+sample_rets).product()-1).to_frame()
    risk_return.columns = ['past_3m_rets']
    risk_return['past_3m_volatility'] = sample_rets.std()
    risk_return['past_3m_sharpe_ratio'] = sample_rets.mean()/risk_return['past_3m_volatility']
    risk_return = risk_return.round(4)
    
    correlation = sample_rets.corr().round(4)   
    
    chatprompt = prompt.format(ta_signal=ta_signal, sentiment=results, risk_return=risk_return, stocks=stocks, correlation=correlation, past_portfolios=past_portfolios, last_period_return=last_period_return)
    optimizer = llm.with_structured_output(PortfolioOptimizationResult).invoke(chatprompt)
    
    weight = pd.DataFrame(optimizer.stock_weight, index=stocks, columns=['weights'])
    weight = weight/weight.sum() ## make sure the sum of weight is 1
    retionale = optimizer.explanation
    return weight, retionale
    
weight, expla = llm_optimizer(datetime.date(2024, 6, 1)) ## this takes around 35 seconds

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

## backtest the strategy - >=35s for 1 loop -> 4 years = 4*4*35s >= 560s ~ 9.3 minutes
## create a function that takes the weights and returns the portfolio returns
def backtest_strategy(weights, returns):
    """
    Backtest the strategy
    """
    port_rets =  returns @ weights
    port_rets.rename(columns={'weights':'rets'}, inplace=True)
    return port_rets

date_idx = pd.date_range('2020-12-31', '2024-12-31', freq='QE')

llm_rets = pd.DataFrame()
llm_retionale = {}
llm_weights = {}
for date in date_idx[:-1]:
    i = 0
    start_sample = date - pd.DateOffset(years=3)
    end_sample = date
    start_out_sample = date+ pd.DateOffset(days=1)
    end_out_sample = date + pd.DateOffset(months=3)
    
    ## data for the sample period
    sample_data = rets[start_sample:end_sample]
    out_sample = rets[start_out_sample:end_out_sample]
    
    # run the optimizer
    if i >=1:
        past_port = pd.DataFrame(llm_weights[previous_date.strftime("%Y-%m-%d")])
        w, explanation = llm_optimizer(date, past_portfolios=past_port, last_period_return= past_return)
    else:
        w, explanation = llm_optimizer(date)
        
    llm_retionale[date.strftime("%Y-%m-%d")] = explanation
    llm_weights[date.strftime("%Y-%m-%d")] = w.to_dict()["weights"]
    
    # run the backtest
    llm_backtest = backtest_strategy(w, out_sample)
    llm_rets = pd.concat([llm_rets, llm_backtest], axis=0)
    
    i+=1
    previous_date = date
    past_return = (1+llm_backtest).product()-1