Add Pro C++ Multithreading, PyTorch LSTM, and Performance Metrics

Author: shreejitverma

04_machine_learning_and_ai/deep_learning/lstm_price_prediction.ipynb

@@ -0,0 +1,115 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Time Series Forecasting with LSTM (PyTorch)\n",
+    "\n",
+    "Long Short-Term Memory (LSTM) networks are a type of Recurrent Neural Network (RNN) capable of learning order dependence in sequence prediction problems.\n",
+    "\n",
+    "**Objective:** Predict the next value in a sine wave (proxy for a cyclical asset pattern).\n",
+    "\n",
+    "**Steps:**\n",
+    "1.  Generate synthetic data.\n",
+    "2.  Preprocess sequences (Sliding Window).\n",
+    "3.  Build LSTM model in PyTorch.\n",
+    "4.  Train and Evaluate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# 1. Generate Data\n",
+    "t = np.linspace(0, 100, 1000)\n",
+    "data = np.sin(t)\n",
+    "\n",
+    "# 2. Sliding Window (Lookback)\n",
+    "def create_sequences(data, seq_length):\n",
+    "    xs = []\n",
+    "    ys = []\n",
+    "    for i in range(len(data)-seq_length-1):\n",
+    "        x = data[i:(i+seq_length)]\n",
+    "        y = data[i+seq_length]\n",
+    "        xs.append(x)\n",
+    "        ys.append(y)\n",
+    "    return np.array(xs), np.array(ys)\n",
+    "\n",
+    "seq_length = 20\n",
+    "X, y = create_sequences(data, seq_length)\n",
+    "\n",
+    "# Convert to Tensor\n",
+    "X_train = torch.from_numpy(X).float().unsqueeze(2) # (Batch, Seq, Feature)\n",
+    "y_train = torch.from_numpy(y).float()\n",
+    "\n",
+    "# 3. LSTM Model\n",
+    "class LSTMModel(nn.Module):\n",
+    "    def __init__(self, input_size=1, hidden_layer_size=50, output_size=1):\n",
+    "        super().__init__()\n",
+    "        self.hidden_layer_size = hidden_layer_size\n",
+    "        self.lstm = nn.LSTM(input_size, hidden_layer_size)\n",
+    "        self.linear = nn.Linear(hidden_layer_size, output_size)\n",
+    "\n",
+    "    def forward(self, input_seq):\n",
+    "        lstm_out, _ = self.lstm(input_seq.view(len(input_seq), 1, -1))\n",
+    "        predictions = self.linear(lstm_out.view(len(input_seq), -1))\n",
+    "        return predictions[-1]\n",
+    "\n",
+    "model = LSTMModel()\n",
+    "loss_function = nn.MSELoss()\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
+    "\n",
+    "# 4. Train Loop\n",
+    "epochs = 10\n",
+    "print(\"Training...\")\n",
+    "for i in range(epochs):\n",
+    "    for seq, labels in zip(X_train, y_train):\n",
+    "        optimizer.zero_grad()\n",
+    "        y_pred = model(seq)\n",
+    "        single_loss = loss_function(y_pred, labels.unsqueeze(0))\n",
+    "        single_loss.backward()\n",
+    "        optimizer.step()\n",
+    "    if i % 2 == 0:\n",
+    "        print(f'Epoch: {i} Loss: {single_loss.item():.5f}')\n",
+    "\n",
+    "print(\"Training Complete.\")\n",
+    "\n",
+    "# 5. Prediction (Validation)\n",
+    "model.eval()\n",
+    "test_seq = X_train[0]\n",
+    "with torch.no_grad():\n",
+    "    pred = model(test_seq)\n",
+    "    print(f\"Target: {y_train[0].item():.4f}, Predicted: {pred.item():.4f}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

05_algorithmic_trading/backtesting_frameworks/performance_metrics.py

@@ -0,0 +1,68 @@
+import numpy as np
+import pandas as pd
+
+class PerformanceMetrics:
+    """
+    Library for calculating Strategy Performance Metrics.
+    """
+    
+    @staticmethod
+    def calculate_returns(prices):
+        """Calculates simple percent returns."""
+        return prices.pct_change().dropna()
+
+    @staticmethod
+    def sharpe_ratio(returns, risk_free_rate=0.0, periods_per_year=252):
+        """
+        Sharpe Ratio = (Mean Return - Risk Free) / Std Dev
+        """
+        excess_returns = returns - risk_free_rate / periods_per_year
+        if returns.std() == 0:
+            return 0.0
+        return np.sqrt(periods_per_year) * excess_returns.mean() / returns.std()
+
+    @staticmethod
+    def sortino_ratio(returns, risk_free_rate=0.0, periods_per_year=252):
+        """
+        Sortino Ratio = (Mean Return - Risk Free) / Downside Deviation
+        """
+        excess_returns = returns - risk_free_rate / periods_per_year
+        downside_returns = returns[returns < 0]
+        
+        downside_std = downside_returns.std()
+        if downside_std == 0:
+            return 0.0
+            
+        return np.sqrt(periods_per_year) * excess_returns.mean() / downside_std
+
+    @staticmethod
+    def max_drawdown(prices):
+        """
+        Calculates Maximum Drawdown (Peak to Valley).
+        """
+        cumulative = (1 + prices.pct_change().dropna()).cumprod()
+        peak = cumulative.cummax()
+        drawdown = (cumulative - peak) / peak
+        return drawdown.min()
+
+    @staticmethod
+    def calmar_ratio(returns, prices, periods_per_year=252):
+        """
+        Calmar Ratio = Annualized Return / Max Drawdown
+        """
+        max_dd = abs(PerformanceMetrics.max_drawdown(prices))
+        if max_dd == 0:
+            return 0.0
+            
+        annual_return = returns.mean() * periods_per_year
+        return annual_return / max_dd
+
+if __name__ == "__main__":
+    # Test Data
+    prices = pd.Series([100, 102, 104, 103, 105, 108, 101, 103], name="Price")
+    returns = PerformanceMetrics.calculate_returns(prices)
+    
+    print(f"Sharpe Ratio:   {PerformanceMetrics.sharpe_ratio(returns):.4f}")
+    print(f"Sortino Ratio:  {PerformanceMetrics.sortino_ratio(returns):.4f}")
+    print(f"Max Drawdown:   {PerformanceMetrics.max_drawdown(prices):.4f}")
+    print(f"Calmar Ratio:   {PerformanceMetrics.calmar_ratio(returns, prices):.4f}")

06_quantitative_development/cpp_low_latency/examples/multithreaded_monte_carlo.cpp

@@ -0,0 +1,77 @@
+#include <iostream>
+#include <vector>
+#include <cmath>
+#include <random>
+#include <thread>
+#include <future>
+#include <chrono>
+
+/**
+ * Multithreaded Monte Carlo Option Pricer.
+ * 
+ * Demonstrates:
+ * 1. Parallel execution using std::async (Task-based parallelism).
+ * 2. Thread-local Random Number Generation (avoiding locking contention).
+ * 3. Numerical integration for derivatives pricing.
+ */
+
+// Function to generate Gaussian noise (Box-Muller transform or std::normal_distribution)
+// We use a thread-local generator for performance.
+double calculate_payoff_sum(int num_sims, double S, double K, double r, double v, double T) {
+    // Thread-local random number engine
+    static thread_local std::mt19937 generator(std::hash<std::thread::id>{}(std::this_thread::get_id()));
+    std::normal_distribution<double> distribution(0.0, 1.0);
+
+    double payoff_sum = 0.0;
+    double drift = (r - 0.5 * v * v) * T;
+    double vol_sqrt_T = v * std::sqrt(T);
+
+    for (int i = 0; i < num_sims; ++i) {
+        double Z = distribution(generator);
+        double S_T = S * std::exp(drift + vol_sqrt_T * Z);
+        payoff_sum += std::max(S_T - K, 0.0); // Call Option Payoff
+    }
+    return payoff_sum;
+}
+
+int main() {
+    // Option Parameters
+    double S = 100.0;  // Spot Price
+    double K = 100.0;  // Strike Price
+    double r = 0.05;   // Risk-free Rate
+    double v = 0.2;    // Volatility
+    double T = 1.0;    // Time to Maturity (1 year)
+    
+    int total_sims = 10'000'000;
+    int num_threads = std::thread::hardware_concurrency();
+    int sims_per_thread = total_sims / num_threads;
+
+    std::cout << "Pricing Call Option (S=" << S << ", K=" << K << ")...\n";
+    std::cout << "Simulations: " << total_sims << " | Threads: " << num_threads << "\n";
+
+    auto start_time = std::chrono::high_resolution_clock::now();
+
+    // Launch tasks
+    std::vector<std::future<double>> futures;
+    for (int i = 0; i < num_threads; ++i) {
+        futures.push_back(std::async(std::launch::async, calculate_payoff_sum, sims_per_thread, S, K, r, v, T));
+    }
+
+    // Aggregate results
+    double total_payoff = 0.0;
+    for (auto& f : futures) {
+        total_payoff += f.get();
+    }
+
+    double price = (total_payoff / total_sims) * std::exp(-r * T);
+
+    auto end_time = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = end_time - start_time;
+
+    std::cout << "------------------------------------------------\n";
+    std::cout << "Call Price: " << price << "\n";
+    std::cout << "Time Taken: " << elapsed.count() << " seconds\n";
+    std::cout << "Sims/Sec:   " << total_sims / elapsed.count() << "\n";
+
+    return 0;
+}

README.md

@@ -33,15 +33,16 @@ We have curated specialized resources that target the specific requirements of H
 
 ### ⚡ Low Latency & Systems
 *   **C++ Mastery:** [Order Matching Engine](./06_quantitative_development/cpp_low_latency/examples/order_matching_engine.cpp), [Lock-Free Queue](./06_quantitative_development/cpp_low_latency/examples/lock_free_spsc_queue.cpp), & [Memory Pool](./06_quantitative_development/cpp_low_latency/examples/memory_pool.cpp).
+*   **Concurrency:** [Multithreaded Monte Carlo](./06_quantitative_development/cpp_low_latency/examples/multithreaded_monte_carlo.cpp) (std::async, std::future).
 *   **Template Metaprogramming:** [Compile-Time Greeks](./06_quantitative_development/cpp_low_latency/examples/compile_time_greeks.cpp) (C++20 `consteval` LUTs).
-*   **Market Data:** [ITCH Feed Handler](./06_quantitative_development/data_engineering/market_data/itch_parser_mock.py).
 *   **Architecture:** [HFT Infrastructure](./06_quantitative_development/system_design/architecture_notes/hft_architecture.md).
 
 ### 🧠 Interview Mastery
 *   **The Roadmap:** [8-Week Study Plan](./07_interview_preparation/study_roadmap.md).
 *   **Quant Strategies:** [Avellaneda-Stoikov Market Making](./05_algorithmic_trading/strategies/market_microstructure/avellaneda_stoikov_mm.py) & [Pairs Trading](./05_algorithmic_trading/strategies/systematic_strategies/pairs_trading_stat_arb.ipynb).
+*   **AI/ML:** [LSTM Time Series Forecasting](./04_machine_learning_and_ai/deep_learning/lstm_price_prediction.ipynb) (PyTorch).
+*   **Backtesting:** [Performance Metrics Library](./05_algorithmic_trading/backtesting_frameworks/performance_metrics.py) (Sharpe, Sortino, Drawdown).
 *   **Jane Street Guide:** [Probability & Betting](./07_interview_preparation/company_insights/jane_street_guide.md).
-*   **Quant Math:** [Green Book Companion](./01_foundations/mathematics/probability/quant_probability_guide.md).
 
 ---