Skip to content

Commit c25b552

Browse files
timothypratleytimothypratley
authored
Merge pull request #78 from W-Edward/main
Rolling Regressions in Clojure for Real-Time Alpha and Beta Monitoring
2 parents a576174 + c5c9ac1 commit c25b552

6 files changed

Lines changed: 299 additions & 2 deletions

File tree

‎site/db.edn‎

Lines changed: 20 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -103,7 +103,21 @@
103103
{:id :kloimhardt
104104
:name "Markus Agwin Kloimwieder"
105105
:url "https://github.com/kloimhardt"
106-
:affiliation [:scicloj]}]
106+
:affiliation [:scicloj]}
107+
{:id :edwardaw
108+
:name "Edward Widjaja"
109+
:url "https://github.com/W-Edward"
110+
:image "https://avatars.githubusercontent.com/u/36920869?v=4"
111+
:email "edwardaw@connect.hku.hk"
112+
:affiliation [:cim]
113+
:links [{:icon "github" :href "https://github.com/emil0r"}]}
114+
{:id :mattb
115+
:name "Matthias Buehlmaier"
116+
:affiliation [:cim]
117+
}
118+
{:id :tanvi
119+
:name "Tanvi Nagar"
120+
:affiliation [:cim] }]
107121

108122
:affiliation
109123
[{:id :clojure.core
@@ -121,7 +135,11 @@
121135
:url "https://hummi.app"}
122136
{:id :techascent
123137
:name "TechAscent"
124-
:url "https://techascent.com"}]
138+
:url "https://techascent.com"}
139+
{:id :hku_cim
140+
:name "cim"
141+
:url "https://cim.hkubs.hku.hk/"
142+
}]
125143

126144
:topic
127145
[{:id :core

‎src/finance/portfolio_analysis/alpha_beta_regression.clj‎

Lines changed: 279 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,279 @@
1+
^{:kindly/hide-code true ; don't render this code to the HTML document
2+
:clay {:title "Rolling Regressions in Clojure for Real-Time Alpha and Beta Monitoring"
3+
:quarto {:author [:edwardaw :tanvi :mattb]
4+
:type :post
5+
:date "2025-09-16"
6+
:category :finance
7+
:tags [:metadata :civitas :cim :finance :portfolio]}}}
8+
9+
(ns finance.portfolio-analysis.alpha-beta-regression
10+
(:require [libpython-clj2.python :refer [py. py.. py.-] :as py]
11+
[tablecloth.api :as tc]
12+
[java-time :as jt]
13+
[tablecloth.column.api :as tcc]
14+
[fastmath.ml.regression :as reg]))
15+
16+
;; ---
17+
18+
;; ## 1. Abstract
19+
20+
;; This blog post presents a functional, reproducible implementation of rolling regression in Clojure to estimate
21+
;; time-varying alpha(α) and beta(β) for student-managed portfolios at the Centre for Investment Management (CIM), The University of Hong Kong.
22+
;; Unlike traditional CAPM tests based on passive index data, our analysis uses actual(synthetic) trades executed by junior portfolio managers-
23+
;; undergraduate students who manage simulated equity portfolios over multiple semesters.
24+
25+
;; ---
26+
27+
;; ## 2. Data and Methodology
28+
29+
;; ### 2.1. Data Sources
30+
31+
;; We use hypothetical trade data from student portfolio managers at the Centre for Investment Management, including:
32+
33+
;; ● Trade dates, tickers, shares, prices
34+
;; ● Portfolio valuations over time(monthly rebalancing)
35+
;; ● Cash flows and position weights
36+
;; ● Returns are computed at the portfolio level, aggregated monthly from individual holdings.
37+
;; ● Benchmark: S&P 500 total return index
38+
;; ● Excess returns are calculated for both portfolios and the market.
39+
;; ● The risk free rate is omitted from analysis for ease of understanding concepts since it does not affect the final results presented in this proposal
40+
41+
;; ### 2.2. Rolling Market Model
42+
43+
;; For each student portfolio, we estimate the CAPM regression over a rolling 12- or 24-month window:
44+
45+
;; Using ordinary least squares(OLS), we obtain a time series of:
46+
47+
;; ● Alpha(α): time-varying abnormal return(skill or luck?)
48+
;; ● Beta(β): evolving sensitivity to market movements(risk awareness?)
49+
;; ● Windows slide forward monthly, producing a dynamic view of performance.
50+
51+
;; ---
52+
53+
;; ## 3. Implementation in Clojure
54+
55+
;; The full analysis pipeline is implemented in Clojure, designed for clarity, reuse, and integration into
56+
;; teaching workflows. Below are some core libraries that were used in the project.
57+
58+
;; ### Core Libraries
59+
60+
;; ● generateme/fastmath: for OLS regression and statistical operations
61+
;; ● scicloj/tablecloth: for data preparation and transformation
62+
;; ● clj-python/libpython-clj: to fetch price data using the yfinance library in Python
63+
;; ● org.clojure/data.csv: for inputting securities for analysis
64+
;; ● org.clojure/clojure.data.json: to parse JSON strings
65+
66+
;; ### Code Preview
67+
68+
^{:kindly/hide-code true}
69+
^:kind/code
70+
(def stock-data
71+
[["2022-09-01" 14.1885330018 13.9169254303]
72+
["2022-09-02" 14.0796907453 13.6273431778]
73+
["2022-09-06" 13.7112209556 13.4456043243]
74+
["2022-09-07" 13.5474882899 13.6983156204]
75+
["2022-09-08" 13.4436062056 13.9739990234]
76+
["2022-09-09" 14.1408088859 14.3705463409]
77+
["2022-09-12" 14.3525677558 14.4884119034]
78+
["2022-09-13" 13.7862151343 13.1159820557]
79+
["2022-09-14" 13.2388419174 13.1129865646]
80+
["2022-09-15" 13.0001152655 12.9142131805]
81+
["2022-09-16" 12.7274264037 13.1829051971]
82+
["2022-09-19" 12.9971186755 13.3666954041]
83+
["2022-09-20" 13.1998874975 13.1609315872]
84+
["2022-09-21" 13.1978908111 13.2458353043]
85+
["2022-09-22" 13.0550504041 12.5466327667]
86+
["2022-09-23" 12.4057942741 12.5016841888]
87+
["2022-09-26" 12.4767137378 12.2140140533]
88+
["2022-09-27" 12.4926960686 12.3988037109]
89+
["2022-09-28" 12.3958072082 12.7214345932]
90+
["2022-09-29" 12.4337640638 12.2060251236]
91+
["2022-09-30" 12.0731767255 12.1251173019]])
92+
93+
^{:kindly/hide-code true}
94+
^:kind/code
95+
(def market-data
96+
[["2022-09-01" 3936.7299804688 3966.8500976562]
97+
["2022-09-02" 3994.6599121094 3924.2600097656]
98+
["2022-09-06" 3930.8898925781 3908.1899414062]
99+
["2022-09-07" 3909.4299316406 3979.8701171875]
100+
["2022-09-08" 3959.9399414062 4006.1799316406]
101+
["2022-09-09" 4022.9399414062 4067.3601074219]
102+
["2022-09-12" 4083.669921875 4110.41015625]
103+
["2022-09-13" 4037.1201171875 3932.6899414062]
104+
["2022-09-14" 3940.7299804688 3946.0100097656]
105+
["2022-09-15" 3932.4099121094 3901.3500976562]
106+
["2022-09-16" 3880.9499511719 3873.330078125]
107+
["2022-09-19" 3849.9099121094 3899.8898925781]
108+
["2022-09-20" 3875.2299804688 3855.9299316406]
109+
["2022-09-21" 3871.3999023438 3789.9299316406]
110+
["2022-09-22" 3782.3601074219 3757.9899902344]
111+
["2022-09-23" 3727.1398925781 3693.2299804688]
112+
["2022-09-26" 3682.7199707031 3655.0400390625]
113+
["2022-09-27" 3686.4399414062 3647.2900390625]
114+
["2022-09-28" 3651.9399414062 3719.0400390625]
115+
["2022-09-29" 3687.0100097656 3640.4699707031]
116+
["2022-09-30" 3633.4799804688 3585.6201171875]])
117+
118+
;; The below function uses a simple Python script (with the help of clj-python to integrate Python with Clojure) to fetch open and closing prices for NVIDIA stocks and the S&P 500 Index from Yahoo Finance.
119+
120+
;; ```clojure
121+
;; (def get-python-data
122+
;; (py/run-simple-string
123+
;; "from datetime import datetime, timedelta
124+
;; import yfinance as yf
125+
;;
126+
;; # Both are already in USD
127+
;;
128+
;; nvidia_data = yf.download('NVDA', start='2022-09-01', end='2025-09-01')
129+
;; snp_data = stock_data = yf.download('^GSPC', start='2022-09-01', end='2025-09-01')
130+
;;
131+
;; nvidia_data.reset_index(inplace=True)
132+
;; snp_data.reset_index(inplace=True)
133+
;;
134+
;; nvidia_data['Date'] = nvidia_data['Date'].dt.strftime('%Y-%m-%d')
135+
;; snp_data['Date'] = snp_data['Date'].dt.strftime('%Y-%m-%d')
136+
;;
137+
;; stock_data = nvidia_data[['Date', 'Open', 'Close']].to_json(orient = 'values')
138+
;; market_data = snp_data[['Date', 'Open', 'Close']].to_json(orient = 'values')"))
139+
;; ```
140+
141+
;; We can then obtain data as follows:
142+
143+
;; ```clojure
144+
;; (def stock-data (json/read-str (:stock_data (:globals get-python-data))))
145+
;; ```
146+
147+
stock-data
148+
149+
;; ```clojure
150+
;; (def market-data (json/read-str (:market_data (:globals get-python-data))))
151+
;; ```
152+
153+
market-data
154+
155+
;; <br> Using the scicloj/tablecloth library, we transform our data, obtaining the stock and market closing prices and their dates.<br>
156+
157+
(def stock-ds (tc/dataset stock-data {:column-names [:date :open :close]}))
158+
159+
(def stock-dates (:date stock-ds))
160+
stock-dates
161+
162+
(def stock-prices (:close stock-ds))
163+
stock-prices
164+
165+
166+
(def market-ds (tc/dataset market-data {:column-names [:date :open :close]}))
167+
(def market-dates (:date market-ds))
168+
(def market-prices (:close market-ds))
169+
170+
;; We continue with creating functions to calculate arithmetic returns, and calculating the day-by-day returns for the stock and the market.
171+
172+
(defn jt-parse-date [date-str]
173+
(jt/local-date "yyyy-MM-dd" date-str))
174+
175+
(defn jt-compare-dates [date-str1 date-str2]
176+
(let [date1 (jt-parse-date date-str1)
177+
date2 (jt-parse-date date-str2)]
178+
(jt/before? date1 date2)))
179+
180+
(defn sort-map-by-date [map]
181+
(into (sorted-map-by jt-compare-dates) map))
182+
183+
(defn calculate-returns-with-corresponding-date [prices dates]
184+
(let [price-changes (map #(double (/ (second %) (first %))) (partition 2 1 prices))
185+
arithmetic-returns (mapv #(- % 1.0) price-changes)
186+
log-returns (mapv #(Math/log %) price-changes)
187+
cumulative-log-return (reduce + log-returns)]
188+
{:cumulative-return cumulative-log-return
189+
:arithmetic-returns (into (sorted-map-by jt-compare-dates) (zipmap (rest dates) arithmetic-returns))
190+
:log-returns (sort-map-by-date (zipmap (rest dates) log-returns))}))
191+
192+
(def stock-returns (vals (:arithmetic-returns (calculate-returns-with-corresponding-date (vec stock-prices) (vec stock-dates)))))
193+
(tcc/column stock-returns)
194+
(def market-returns (vals (:arithmetic-returns (calculate-returns-with-corresponding-date (vec market-prices) (vec market-dates)))))
195+
(tcc/column market-returns)
196+
197+
;; Now, this is where we implement our rolling market model, where we regress NVDA stock returns on the market returns using a rolling window to obtain sets of alpha and beta.
198+
;; To achieve this, we utilize the generateme/fastmath library to implement our very own rolling window regression function.
199+
200+
(defn calculate-regression [stock-returns market-returns]
201+
(reg/lm
202+
stock-returns
203+
(map vector market-returns)))
204+
205+
(defn rolling-capm-regression [complete-stock-returns complete-market-returns window-size]
206+
(let [stock-windows (partition window-size 1 complete-stock-returns)
207+
market-windows (partition window-size 1 complete-market-returns)
208+
rolling-regression (map calculate-regression stock-windows market-windows)
209+
alpha-seq (map :intercept rolling-regression)
210+
beta-seq (map :beta rolling-regression)]
211+
212+
{:alpha alpha-seq
213+
:beta beta-seq}))
214+
215+
;; Finally, we use these functions to obtain our sets of alpha and beta. Note that the size of the window is 252 to represent the number of trading days in a year.
216+
217+
(def model (rolling-capm-regression stock-returns market-returns 252))
218+
219+
;; ---
220+
221+
;; # 4. Results
222+
223+
;; We present time-series plots of alpha and beta for multiple student portfolios across two academic years. While stock prices
224+
;; reflect market consensus, alpha and beta decompose returns into risk-adjusted components, revealing whether performance was due to systematic market exposure(beta) or true outperformance(alpha). This provides deeper insight than price alone, enabling informed evaluation of risk, skill, and value creation.
225+
226+
;; ![Time-series plot of alpha over time for NVDA (Nvidia)](./figures/rolling-alpha.png)
227+
228+
;; The above charts show the alpha over time for NVDA(Nvidia) and the historical alpha tracking can help inform future trades.
229+
;; A close-up analysis of alpha reveals some interesting observations, for example:
230+
231+
;; ● The declining trend in NVIDIA’s(NVDA) alpha relative to the S&P 500, as observed from October 2023 to July 2025, reflects a significant shift in the stock’s market performance dynamics.
232+
;; ● Initially exhibiting strong positive alpha-indicative of substantial outperformance over the broader market-NVDA’s excess return diminished steadily over time, converging toward zero by mid-2025.
233+
;; ● This erosion of alpha can be attributed to a combination of factors, including the normalization of AI-driven valuation premiums, increased competitive pressures from semiconductor peers, and a broader market environment characterized by robust S&P 500 performance that reduced NVDA’s relative advantage.
234+
235+
;; ![Time-series plot of beta over time for NVDA (Nvidia)](./figures/rolling-beta.png)
236+
237+
;; Similarly, the above charts reveals some trends regarding the beta of the NVDA(Nvidia) stock:
238+
239+
;; ● The time series of NVIDIA’s(NVDA) beta relative to the S&P 500 reveals a significant evolution in the stock’s sensitivity to market movements over the period from October 2023 to August 2025.
240+
;; ● Initially, NVDA exhibited a beta around 2.0, indicating that it was approximately twice as volatile as the broader market. Over the course of 2024, beta steadily increased, peaking near 2.9 in early 2025, reflecting heightened market exposure and amplified price swings during periods of strong investor enthusiasm for AI-driven growth.
241+
;; ● This elevated beta suggests that NVDA was behaving as a high-risk, high-reward asset, with returns highly correlated to-and often magnified by-market trends. However, beginning in April 2025, beta experienced a sharp decline, falling to 1.985 by August 2025, signaling a reduction in its volatility relative to the market. This decrease may reflect a combination of factors: valuation corrections, reduced speculative positioning, and a shift toward more stable, earnings-driven investment behavior.
242+
243+
;; Hence, a portfolio manager when looking at the historical performance of NVDA, will be able to evaluate if the trade is adding value to
244+
;; their portfolio. A stock with a rising alpha and lower beta is a good sign for investment, since it presents a higher return for a lower level of risk. An evaluation of single stocks comprising a portfolio will give a good visual analysis of the stocks risk and return and the overall portfolio. A similar analysis can be conducted at the portfolio level as well to understand the portfolio manager’s performance- alpha creation against the market similar to an AMC tracking a fund’s performance.
245+
246+
;; ---
247+
248+
;; ## 5. Discussion
249+
250+
;; ### 5.1. Toward Reflective Portfolio Management
251+
252+
;; Rolling alpha and beta are not just statistics-they are mirrors. They allow students to:
253+
;; ● See the consequences of their strategies
254+
;; ● Distinguish luck from skill
255+
;; ● Adjust risk in response to market regimes
256+
257+
;; ### 5.2. From Classroom to Portfolio Level
258+
259+
;; This system has direct real-world applicability:
260+
;; ● Can be scaled to real fund management with minimal changes
261+
;; ● Provides a template for risk dashboards in small asset managers
262+
;; ● Integrates with automated compliance or alerting(e.g., “beta increased by 30% this month”)
263+
264+
;; ---
265+
266+
;; ## 6. Conclusion
267+
268+
;; By turning student trades into living data, we move beyond theory to reflective practice. And by building in Clojure, we ensure that the system is not a black box—but an open book. In simple words we can decipher, the best financial models don’t just describe the world—they help people learn from it.
269+
270+
;; ---
271+
272+
;; ## 7. Future Work
273+
274+
;; ● Expand to multi-factor rolling models(e.g., FF3: market, size, value)
275+
;; ● Build a web dashboard using ClojureScript(Reagent) for real-time feedback and interactivity
276+
;; ● Implement automated alerts(e.g., “your beta has exceeded 1.5”)
277+
;; ● Add peer benchmarking: compare alpha trajectories across students
278+
;; ● Integrate with portfolio optimization tools for next-step recommendations
279+
;; ● Use the pipeline as a capstone module in investment management courses

‎src/finance/portfolio_analysis/figures/portfolio-value.png‎

53.5 KB
Loading

‎src/finance/portfolio_analysis/figures/rolling-alpha.png‎

53.6 KB
Loading

‎src/finance/portfolio_analysis/figures/rolling-beta.png‎

44.9 KB
Loading

‎src/finance/portfolio_analysis/figures/rolling-volatility.png‎

29.6 KB
Loading

0 commit comments

Comments
 (0)