sf-quant 0.2.2__tar.gz → 0.2.4__tar.gz

{sf_quant-0.2.2 → sf_quant-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sf-quant
-Version: 0.2.2
+Version: 0.2.4
 Summary: Python package for Silver Fund quant team research and trading tools.
 Author-email: Andrew Hall <andrewmartinhall2@gmail.com>
 Requires-Python: <3.14,>=3.11

{sf_quant-0.2.2 → sf_quant-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sf-quant"
-version = "0.2.2"
+version = "0.2.4"
 description = "Python package for Silver Fund quant team research and trading tools."
 readme = "README.md"
 requires-python = ">=3.11,<3.14"

{sf_quant-0.2.2 → sf_quant-0.2.4}/src/sf_quant/backtester/dynamic_parallel.py

@@ -17,8 +17,8 @@ def _construct_portfolio(
     constraints: list[Constraint],
     gamma: float,
     target_active_risk: float | None = None,
-    benchmark_df: pl.DataFrame | None = None,
     progress_bar: tqdm_ray.tqdm | None = None,
+    active_weights: bool = False
 ):
     """
     Construct a single optimized portfolio for a given date.
@@ -39,10 +39,11 @@ def _construct_portfolio(
         Risk aversion parameter.
     target_active_risk : float, optional
         Target active risk for gamma calibration.
-    benchmark_df : pl.DataFrame, optional
-        Benchmark weights data with columns 'date', 'barrid', 'benchmark_weight'.
     progress_bar : tqdm_ray.tqdm, optional
         Ray-based progress bar for tracking completion.
+    active_weights : bool
+        Flag indicating how to treat output weights of optimizer. False (default)
+        means that we subtract of benchmark weights before computing active risk.
 
     Returns
     -------
@@ -59,17 +60,14 @@ def _construct_portfolio(
         else None
     )
 
-    benchmark_weights = None
-    if benchmark_df is not None:
-        # Get benchmark weights for portfolio barrids on this date
-        bmk_subset = benchmark_df.filter(pl.col("date").eq(date_))
-        # Join with portfolio to ensure alignment
-        aligned = (
-            pl.DataFrame({"barrid": barrids})
-            .join(bmk_subset[["barrid", "benchmark_weight"]], on="barrid", how="left")
-            .fill_null(0.0)
-        )
-        benchmark_weights = aligned["benchmark_weight"].to_numpy()
+    benchmark_weights = (
+        subset["benchmark_weight"].to_numpy()
+        if "benchmark_weight" in subset.columns
+        else None
+    )
+
+    if benchmark_weights is None and active_weights is False:
+        raise ValueError("Benchmark weights must be provided if active_weights flag is False (default).")
 
     (
         factor_exposures,
@@ -88,6 +86,7 @@ def _construct_portfolio(
         betas=betas,
         target_active_risk=target_active_risk,
         benchmark_weights=benchmark_weights,
+        active_weights=active_weights
     )
 
     portfolio = portfolio.with_columns(pl.lit(date_).alias("date")).select(
@@ -106,6 +105,7 @@ def dynamic_backtest_parallel(
     initial_gamma: float = 100,
     target_active_risk: float = 0.05,
     n_cpus: int | None = None,
+    active_weights: bool = False
 ) -> pl.DataFrame:
     """
     Run a parallelized backtest of portfolio optimization using Ray.
@@ -137,6 +137,9 @@ def dynamic_backtest_parallel(
     n_cpus : int, optional
         Number of CPUs to allocate to Ray. If ``None``, defaults to
         ``os.cpu_count()`` but is capped at the number of unique dates.
+    active_weights : bool
+        Flag indicating how to treat output weights of optimizer. False (default)
+        means that we subtract of benchmark weights before computing active risk.
 
     Returns
     -------
@@ -171,23 +174,30 @@ def dynamic_backtest_parallel(
     >>> import datetime as dt
     >>> start = dt.date(2024, 1, 1)
     >>> end = dt.date(2024, 1, 10)
-    >>> columns = ['date', 'barrid']
+    >>> benchmark_weights = sfd.load_benchmark(start, end).rename({'weight': 'benchmark_weight'})
     >>> data = (
     ...     sfd.load_assets(
     ...         start=start,
     ...         end=end,
     ...         in_universe=True,
-    ...         columns=columns
+    ...         columns=['date', 'barrid']
     ...     )
     ...     .with_columns(
     ...         pl.lit(0).alias('alpha')
     ...     )
+    ...     .join(
+    ...         other=benchmark_weights,
+    ...         on=['date', 'barrid'],
+    ...         how='left'
+    ...     )
     ... )
-    >>> constraints = [sfo.FullInvestment()]
+    >>> constraints = [sfo.FullInvestment(), sfo.LongOnly()]
     >>> weights = sfb.dynamic_backtest_parallel(
     ...     data=data,
     ...     constraints=constraints,
     ...     initial_gamma=100,
+    ...     target_active_risk=0.05,
+    ...     active_weights=False
     ... )
     shape: (5, 5)
     ┌────────────┬─────────┬───────────┬───────┬──────────────┐
@@ -205,10 +215,6 @@ def dynamic_backtest_parallel(
     # Get dates
     dates = data["date"].unique().sort().to_list()
 
-    start_date = dates[0]
-    end_date = dates[-1]
-    benchmark_df = load_benchmark(start_date, end_date).rename({"weight": "benchmark_weight"})
-
     # Set up ray
     n_cpus = n_cpus or os.cpu_count()
     n_cpus = min(len(dates), n_cpus)
@@ -230,8 +236,8 @@ def dynamic_backtest_parallel(
             constraints=constraints,
             gamma=initial_gamma,
             target_active_risk=target_active_risk,
-            benchmark_df=benchmark_df,
             progress_bar=progress_bar,
+            active_weights=active_weights
         )
         for date_ in dates
     ]

{sf_quant-0.2.2 → sf_quant-0.2.4}/src/sf_quant/optimizer/optimizers.py

@@ -108,6 +108,7 @@ def dynamic_mve_optimizer(
     betas: np.ndarray | None = None,
     target_active_risk: float | None = None,
     benchmark_weights: np.ndarray | None = None,
+    active_weights: bool = False
 ) -> pl.DataFrame:
     """
     Mean-variance optimizer with optional active risk calibration.
@@ -143,6 +144,9 @@ def dynamic_mve_optimizer(
     benchmark_weights : np.ndarray, optional
         Benchmark portfolio weights of shape (n_assets,), required if
         ``target_active_risk`` is specified.
+    active_weights : bool
+        Flag indicating how to treat output weights of optimizer. False (default)
+        means that we subtract of benchmark weights before computing active risk.
 
     Returns
     -------
@@ -204,6 +208,7 @@ def dynamic_mve_optimizer(
         constraints=constructed_constraints,
         target_active_risk=target_active_risk,
         initial_gamma=initial_gamma,
+        active_weights=active_weights
     )
 
     optimal_weights = _quadratic_program(
@@ -281,34 +286,6 @@ def _quadratic_program(
 
     return weights.value
 
-def _active_quadratic_program(
-    alphas: np.ndarray,
-    factor_exposures: np.ndarray,
-    factor_covariance: np.ndarray,
-    specific_risk: np.ndarray,
-    gamma: float,
-    constraints: list[cp.Constraint],
-    benchmark_weights: np.ndarray,
-) -> np.ndarray:
-    n_assets = len(alphas)
-    weights = cp.Variable(n_assets)
-    constraints = [constraint(weights) for constraint in constraints]
-
-    portfolio_return = weights.T @ alphas
-
-    active_w = weights - benchmark_weights
-    factor_loadings = factor_exposures.T @ active_w
-    factor_variance = cp.quad_form(factor_loadings, factor_covariance)
-    specific_variance = cp.sum(cp.multiply(specific_risk, cp.square(active_w)))
-    active_variance = factor_variance + specific_variance
-
-    objective = cp.Maximize(portfolio_return - 0.5 * gamma * active_variance)
-
-    problem = cp.Problem(objective, constraints)
-    problem.solve(solver="OSQP")
-
-    return weights.value
-
 def _calibrate_gamma(
     alphas: np.ndarray,
     factor_exposures: np.ndarray,
@@ -320,6 +297,7 @@ def _calibrate_gamma(
     initial_gamma: float = 100.0,
     error: float = 0.005,
     max_iterations: int = 5,
+    active_weights: bool = False
 ):
     """
     Calibrate gamma to hit a target annualized active risk.
@@ -350,13 +328,15 @@ def _calibrate_gamma(
         Convergence tolerance. Default 0.005 (0.5%).
     max_iterations : int
         Maximum number of iterations. Default 5.
+    active_weights : bool
+        Flag indicating how to treat output weights of optimizer. False (default)
+        means that we subtract of benchmark weights before computing active risk.
 
     Returns
     -------
     float
         Calibrated gamma.
     """
-    n_assets = len(alphas)
     gamma = initial_gamma
     active_risk = float('inf')
     iterations = 1
@@ -364,10 +344,15 @@ def _calibrate_gamma(
 
     while abs(active_risk - target_active_risk) > error and iterations <= max_iterations:
         # Solve the optimization
-        weights = _active_quadratic_program(alphas, factor_exposures, factor_covariance, specific_risk, gamma, constraints, benchmark_weights)
+        weights = _quadratic_program(alphas, factor_exposures, factor_covariance, specific_risk, gamma, constraints)
   
+        # Compute active weights if active_weights flag is False
+        if not active_weights:
+            active_w = weights - benchmark_weights
+        else:
+            active_w = weights
+
         # Compute active risk using factor model
-        active_w = weights - benchmark_weights
         active_factor_loadings = factor_exposures.T @ active_w
         active_factor_var = active_factor_loadings @ factor_covariance @ active_factor_loadings
         active_specific_var = np.sum(specific_risk * np.square(active_w))

{sf_quant-0.2.2 → sf_quant-0.2.4}/uv.lock

@@ -1654,7 +1654,7 @@ wheels = [
 
 [[package]]
 name = "sf-quant"
-version = "0.2.0"
+version = "0.2.4"
 source = { editable = "." }
 dependencies = [
     { name = "cvxpy" },