Combining Fundamental and Technical Analysis via Qlib Quant#

1.1 Financial Statements#

1. Income Statement: Outlines revenue, expenses, and net income. Useful for understanding profitability and operational efficiency.
2. Balance Sheet: Summarizes assets, liabilities, and shareholders’ equity. Offers insight into a company’s financial stability and leverage.
3. Cash Flow Statement: Tracks the flow of cash in and out of the business, highlighting liquidity and solvency.

1.2 Key Ratios#

Fundamental analysis employs various ratios derived from financial statements to gauge a company’s performance. Examples include:

1.3 Qualitative Factors#

Beyond numerical data, fundamental analysis also considers qualitative elements such as industry competition, management quality, and macroeconomic influences. Though these factors are less tangible, they can greatly impact long-term prospects.

By incorporating fundamental analysis, you develop a strong understanding of a company’s value proposition. However, raw fundamentals alone may not illuminate shorter-term market inefficiencies. That’s where technical analysis steps in.

2.1 Price Trends#

The simplest elements of technical analysis are trend lines and moving averages. By plotting price data over various time horizons, you can observe whether a stock is trending upward, downward, or sideways. Key tools include:

• Simple Moving Average (SMA)
• Exponential Moving Average (EMA)
• Bollinger Bands
• Support and Resistance Levels

2.2 Momentum and Volatility Indicators#

Technical analysts often use momentum indicators, such as the Relative Strength Index (RSI) and Moving Average Convergence Divergence (MACD), to identify potential overbought or oversold conditions. Volatility measures, like the Average True Range (ATR), help gauge market fluctuations and set appropriate risk controls.

2.3 Patterns and Volume Analysis#

Candlestick patterns (e.g., doji, hammer, engulfing patterns) and volume breakouts provide additional context. For example, a surge in volume accompanying a price breakout could signal strong momentum and confirm a potential trend shift.

Technical analysis can be powerful in timing trades and reacting to market sentiment. However, relying on price-driven signals alone may neglect the deeper, long-term strengths (or weaknesses) of a company’s fundamentals. A blend of these approaches often yields the most robust strategies.

5.1 Ingesting Market Data#

After installing and initializing Qlib, you can use Qlib’s built-in data structures to query historical price data:

1
from qlib.data import D
2

3
# Example: query daily data for a sample stock
4
df_price = D.features(
5
    instruments='SH600519',
6
    fields=['$close', '$volume'],
7
    start_time='2019-01-01',
8
    end_time='2020-12-31'
9
)
10
print(df_price.head())

This code fetches the closing price and volume for the instrument SH600519 (Kweichow Moutai in China’s A-share market) between 2019 and 2020.

5.2 Incorporating Fundamental Data#

Fundamental datasets are not directly included in Qlib’s default installation. You’ll need to process and store your own data, aligning it with market data. A typical approach involves:

1. Collecting Fundamentals: Use APIs from financial data providers (e.g., Yahoo Finance, Quandl, Bloomberg, S&P Global) or official filings.
2. Standardizing Tickers: Ensure tickers match the naming convention in Qlib’s data provider.
3. Aligning Dates: Decide on the granularity you wish to use (e.g., quarterly fundamentals aligned with monthly or weekly bars).
4. Import/Storage: Place the preprocessed fundamental data into a format that Qlib can reference.

Although direct integration requires additional scripts, Qlib can reference external CSV files or databases, enabling you to merge fundamental features with Qlib’s built-in technical factors.

5.3 Factor Construction Workflow#

Once both price and fundamental data are ingested, you can create custom data pipelines. Qlib’s factor library includes technical indicators such as MA, RSI, dedicated price transformations, and more. For fundamental data, you may define custom factors in Python, referencing your stored fundamental fields.

6.1 Simple Example of Factor Definition#

Below is a conceptual outline of how you can define a new factor that combines fundamental metrics (like EPS) and technical indicators (like the 30-day SMA of closing price). We’ll call it HybridFactor:

1
import pandas as pd
2

3
def hybrid_factor(fundamentals_df, price_df):
4
    """
5
    Combine fundamental data with a technical indicator.
6

7
    :param fundamentals_df: DataFrame with columns [‘EPS’] for each instrument and date
8
    :param price_df: DataFrame with columns [‘$close’] for each instrument and date
9
    :return: DataFrame with the combined factor for each instrument and date
10
    """
11
    # Compute 30-day simple moving average of price
12
    sma_30 = price_df['$close'].rolling(window=30).mean()
13

14
    # Standardize or normalize the fundamental metric
15
    eps_norm = (fundamentals_df['EPS'] - fundamentals_df['EPS'].mean()) / fundamentals_df['EPS'].std()
16

17
    # Combine
18
    combined_factor = sma_30 * eps_norm  # or some other formula
19

20
    return combined_factor

Your actual logic may be more complex—this code is for illustration, omitting data alignment steps. Integrating these insights in Qlib typically requires creating a factor function or class that can be integrated into Qlib’s workflow.

6.2 Handling Nulls and Data Alignment#

Financial data often comes with missing values and mismatched dates. Be prepared to handle:\

• Holidays and weekends: Stock markets are closed on specific days, resulting in missing rows.
• Non-overlapping accounting periods: Fundamentals release quarterly, possibly leaving gaps in monthly or daily data.

Best practices include forward-filling or backward-filling fundamental data until updated figures become available, while using standard daily data for prices.

6.3 Setting up a Qlib Workflow#

In Qlib, a typical workflow integrates factor definitions into a pipeline where each factor is computed sequentially. You can store intermediate results and feed them to a model. By defining your fundamental-based factors and technical-based factors as separate modules, you can apply them individually or in combination.

7.1 Example Strategy Description#

1. Universe: A chosen set of stocks (e.g., the largest 300 stocks by market cap).
2. Factor 1 (Fundamental): Quarterly EPS growth rate (EPS_Growth).
3. Factor 2 (Technical): 14-day RSI (RSI_14).
4. Signal:
   • Rank stocks by EPS_Growth in descending order.
   • Filter out stocks with RSI_14 > 70 (potentially overbought).
   • Build a portfolio with the top 10 stocks from the remaining list.

Let’s walk through how you might implement this in Qlib, assuming you have a DataFrame of fundamental data and Qlib’s standard price/technical pipelines.

7.2 Preparing the Data#

Below is a high-level example. Note that you’ll need properly aligned fundamental data. For demonstration, we’ll assume you have a DataFrame fund_df with columns [‘symbol’, ‘date’, ‘EPS_Growth’] and that your Qlib environment is already initialized.

1
import qlib
2
from qlib.data import D
3
import pandas as pd
4

5
# Initialize Qlib
6
qlib.init(provider_uri='~/.qlib/qlib_data/cn_data')
7

8
# Load fundamental data (for example, from CSV or a database)
9
fund_df = pd.read_csv('fundamental_data.csv', parse_dates=['date'])
10
# Ensure appropriate alignment with Qlib’s instrument naming if necessary

7.3 Technical Indicator Calculation#

Now, we fetch the 14-day RSI. Qlib already supports computing RSI directly:

1
from qlib.contrib.data.handler import Alpha158
2

3
# Alpha158 is an example data handler that calculates many factors including RSI
4
# For demonstration, we only focus on RSI output here
5

6
instruments = ['SH600519', 'SZ000001', ...]  # example instruments
7

8
# Set a date range
9
start_date = '2020-01-01'
10
end_date = '2021-01-01'
11

12
# Prepare a data handler
13
data_handler = Alpha158(instruments=instruments, start_time=start_date, end_time=end_date, fit_start_time=start_date, fit_end_time=end_date)
14

15
# The data handler allows you to fetch computed features
16
data = data_handler.fetch(features=["RSI_14"])
17
rsi_df = data["RSI_14"].reset_index()

You can then merge rsi_df with your fundamental data frames on [‘symbol’, ‘date’]. You’ll likely take care of missing dates or use a date-filling strategy to ensure alignment.

7.4 Signal Generation#

Finally, generating signals involves filtering and ranking:

1
# Merge the fundamental and RSI DataFrames
2
signal_df = pd.merge(fund_df, rsi_df, on=['instrument', 'datetime'], how='inner')
3

4
# Filter out overbought stocks (RSI > 70)
5
signal_df = signal_df[signal_df['RSI_14'] <= 70]
6

7
# Rank by EPS_Growth descending
8
signal_df['rank'] = signal_df.groupby('datetime')['EPS_Growth'].rank(method='first', ascending=False)
9

10
# Select top 10 for each day
11
top_picks = signal_df[signal_df['rank'] <= 10]

This DataFrame top_picks now contains, for each date, the top 10 stocks that pass the fundamental filter (EPS_Growth) and the technical screen (RSI < 70). You can use this as the foundation for your portfolio construction.

7.5 Backtesting#

Qlib provides backtesting modules to evaluate your strategy performance. By defining an execution model, cost assumptions, and a rebalancing schedule, you can run a historical simulation to gauge risk and reward characteristics.

While this is a simplified example, it demonstrates the workflow of combining fundamental and technical indicators. In practice, you’d incorporate more robust factor definitions, risk controls, and portfolio optimization routines.

8.1 Factor Engineering and Selection#

1. Composite Factors: Combine multiple fundamental metrics (e.g., ROE, Debt-to-Equity, P/E) into a single factor using weighting, PCA, or other dimension-reduction techniques.
2. Factor Neutralization: Mitigate biases (e.g., industry, market-cap) by neutralizing factors relative to known risk exposures.

8.2 Data Frequency and Market Microstructure Enhancements#

• High-Frequency Data: If your strategy benefits from intraday patterns, Qlib’s minute-level data can be used for advanced short-term signals.
• Tick Data: For ultra-high-frequency users, consider storing and analyzing tick-level order book data, though this requires custom ingestion.

8.3 Predictive Modeling with Machine Learning#

Qlib integrates well with popular ML frameworks like scikit-learn, LightGBM, and PyTorch. You can create complex models (e.g., gradient boosting, neural networks) that predict future returns based on both fundamental and technical features. Common steps include:

1. Feature Engineering: Construct YOY comparisons for fundamentals, advanced technical indicators, sentiment, or alternative data.
2. Model Training: Split data into training, validation, and test sets. Evaluate performance on out-of-sample periods.
3. Hyperparameter Tuning: Use Bayesian optimization or cross-validation to refine model settings.
4. Ensemble Methods: Combine multiple models (fundamentals-driven, trend-driven, or factor-based) for more robust predictions.

8.4 Risk Management and Portfolio Optimization#

Professional strategies place significant emphasis on risk control. Qlib is compatible with external libraries that provide advanced optimization algorithms (e.g., Mean-Variance, Black-Litterman). Some key elements include:

1. Position Sizing: Adjust allocations based on signal confidence or volatility forecasts.
2. Stop-Losses: Employ dynamic rules tied to drawdowns or volatility spikes.
3. Beta Hedging: Hedge systematic risk using index futures or options.

8.5 Automated Pipeline and Workflow#

By building reusable modules in Qlib, you can create fully automated pipelines:

1. Data Update: Download and preprocess new fundamental and market data.
2. Factor Computation: Recompute or update factors daily or quarterly.
3. Predictive Modeling: Retrain or refresh your machine learning models as new data arrives.
4. Portfolio Construction: Generate signals and rebalance your portfolio on a scheduled basis.