Merge pull request #3 from aleCombi/Greek_Gradients

Greek gradients

Author: aleCombi

Project.toml

@@ -26,6 +26,7 @@ SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462"
 SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
 [compat]
@@ -51,6 +52,7 @@ SciMLBase = "2.77.2"
 SpecialFunctions = "2.5.0"
 StaticArrays = "1.9.13"
 Statistics = "1.11.1"
+Test = "1.11.0"
 Zygote = "0.6.76"
 julia = "1.11"
 

examples/Project.toml

@@ -2,10 +2,12 @@
 Accessors = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697"
 BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
 Bessels = "0e736298-9ec6-45e8-9647-e4fc86a2fe38"
+DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
 DataInterpolations = "82cc6244-b520-54b8-b5a6-8a565e85f1d0"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
 DifferentialEquations = "0c46a032-eb83-5123-abaf-570d42b7fbaa"
 Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
+ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 Hedgehog2 = "7f16798b-0e18-40de-98af-932948254698"
 Integrals = "de52edbc-65ea-441a-8357-d3a637375a31"
 NonlinearSolve = "8913a72c-1f9b-4ce2-8d82-65094dcecaec"
@@ -17,3 +19,4 @@ Revise = "295af30f-e4ad-537b-8983-00126c2a3abe"
 Roots = "f2b01f46-fcfa-551c-844a-d8ac1e96c665"
 SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

examples/comparisons/euro.jl

@@ -0,0 +1,49 @@
+using Revise, Hedgehog2, BenchmarkTools, Dates
+using Accessors
+import Accessors: @optic
+using Test
+using DataFrames
+
+include("run_model_comparison.jl")
+
+# ------------------------------
+# Define payoff and pricing problem
+# ------------------------------
+strike = 1.0
+expiry = Date(2020, 1, 2)
+underlying = Hedgehog2.Forward()
+euro_payoff = VanillaOption(strike, expiry, European(), Put(), underlying)
+
+reference_date = Date(2020, 1, 1)
+rate = 0.03
+spot = 1.0
+sigma = 1.0
+market_inputs = BlackScholesInputs(reference_date, rate, spot, sigma)
+euro_pricing_prob = PricingProblem(euro_payoff, market_inputs)
+
+# ------------------------------
+# Define pricing methods
+# ------------------------------
+bs_method = BlackScholesAnalytic()
+crr_method = CoxRossRubinsteinMethod(800)
+
+# ------------------------------
+# Define lenses for Greeks
+# ------------------------------
+vol_lens = VolLens(1, 1)
+spot_lens = @optic _.market_inputs.spot
+rate_lens = ZeroRateSpineLens(1)
+lenses = (spot_lens, vol_lens, rate_lens)
+
+# ------------------------------
+# Run comparison table
+# ------------------------------
+df = run_model_comparison_table(
+    euro_pricing_prob,
+    [bs_method, crr_method],
+    lenses;
+    ad_method = ForwardAD(),
+    fd_method = FiniteDifference(1e-4),
+    analytic_method = AnalyticGreek(),
+)
+println(df)

examples/comparisons/run_model_comparison.jl

@@ -0,0 +1,148 @@
+using DelimitedFiles
+using DataFrames
+using Hedgehog2
+
+function run_model_comparison_table(
+    prob::PricingProblem,
+    models::Vector{Hedgehog2.AbstractPricingMethod},
+    lenses::Tuple;
+    ad_method::Hedgehog2.GreekMethod = ForwardAD(),
+    fd_method::Hedgehog2.GreekMethod = FiniteDifference(1e-3),
+    analytic_method::Union{Nothing, Hedgehog2.GreekMethod} = nothing,
+)
+
+    results = Dict{String, Any}()
+    rows = Vector{NamedTuple}()
+
+    for model in models
+        model_name = string(typeof(model).name.name)
+
+        # Price
+        price_time = @belapsed Hedgehog2.solve($prob, $model)
+        sol = Hedgehog2.solve(prob, model)
+        price = sol.price
+
+        # Batch Greeks (AD & FD)
+        batch_prob = BatchGreekProblem(prob, lenses)
+        ad_time = @belapsed solve($batch_prob, $ad_method, $model)
+        fd_time = @belapsed solve($batch_prob, $fd_method, $model)
+        greeks_ad = solve(batch_prob, ad_method, model)
+        greeks_fd = solve(batch_prob, fd_method, model)
+
+        # Attempt full AnalyticGreek batch solve
+        greeks_analytic = Dict{Any, Union{Float64, Missing}}()
+        if analytic_method !== nothing
+            try
+                greeks_full = solve(batch_prob, analytic_method, model)
+                for lens in lenses
+                    greeks_analytic[lens] = greeks_full[lens]
+                end
+            catch
+                # Fallback to individual lens-based attempts
+                for lens in lenses
+                    try
+                        single_prob = BatchGreekProblem(prob, (lens,))
+                        val = solve(single_prob, analytic_method, model)[lens]
+                        greeks_analytic[lens] = val
+                    catch
+                        greeks_analytic[lens] = missing
+                    end
+                end
+            end
+        else
+            for lens in lenses
+                greeks_analytic[lens] = missing
+            end
+        end
+
+        results[model_name] = (
+            price=price,
+            price_time=price_time,
+            greeks_ad=greeks_ad,
+            ad_time=ad_time,
+            greeks_fd=greeks_fd,
+            fd_time=fd_time,
+            greeks_analytic=greeks_analytic,
+        )
+    end
+
+    baseline = first(models)
+    baseline_name = string(typeof(baseline).name.name)
+
+    for lens in lenses
+        for (name, data) in results
+            ad_val = data.greeks_ad[lens]
+            fd_val = data.greeks_fd[lens]
+            analytic_val = data.greeks_analytic[lens]
+            price = data.price
+            ad_time = data.ad_time / length(lenses)
+            fd_time = data.fd_time / length(lenses)
+            price_time = data.price_time
+
+            push!(rows, (
+                greek = string(lens),
+                model = name,
+                metric = "value",
+                ad_value = ad_val,
+                fd_value = fd_val,
+                analytic_value = analytic_val,
+                price = price,
+                ad_us = ad_time * 1e6,
+                fd_us = fd_time * 1e6,
+                price_us = price_time * 1e6,
+            ))
+        end
+
+        baseline_data = results[baseline_name]
+        
+        for (name, data) in results
+            if name == baseline_name
+                continue
+            end
+
+            ad_diff  = data.greeks_ad[lens] - baseline_data.greeks_ad[lens]
+            fd_diff  = data.greeks_fd[lens] - baseline_data.greeks_fd[lens]
+            price_diff = data.price - baseline_data.price
+            ad_time_diff = (data.ad_time / length(lenses) - baseline_data.ad_time / length(lenses)) * 1e6
+            fd_time_diff = (data.fd_time / length(lenses) - baseline_data.fd_time / length(lenses)) * 1e6
+            price_time_diff = (data.price_time - baseline_data.price_time) * 1e6
+
+            a1 = data.greeks_analytic[lens]
+            a0 = baseline_data.greeks_analytic[lens]
+            analytic_diff = (!ismissing(a1) && !ismissing(a0)) ? a1 - a0 : missing
+
+            push!(rows, (
+                greek = string(lens),
+                model = "Δ " * name,
+                metric = "diff",
+                ad_value = ad_diff,
+                fd_value = fd_diff,
+                analytic_value = analytic_diff,
+                price = price_diff,
+                ad_us = ad_time_diff,
+                fd_us = fd_time_diff,
+                price_us = price_time_diff,
+            ))
+
+            add_separator!(rows)
+        end
+    end
+
+    return DataFrame(rows)
+end
+
+function add_separator!(rows)
+    # Add a separator row to visually split groups when displayed
+    push!(rows, (
+        greek = "────────────────────────",
+        model = "",
+        metric = "",
+        ad_value = missing,
+        fd_value = missing,
+        analytic_value = missing,
+        price = missing,
+        ad_us = missing,
+        fd_us = missing,
+        price_us = missing,
+    ))
+end

examples/polished_examples/american_options.jl

@@ -20,43 +20,49 @@ method_analytic = BlackScholesAnalytic()
 method_carr_madan = CarrMadan(1.0, 16.0, LognormalDynamics())
 
 # -- Solve for prices
-sol_analytic = Hedgehog2.solve(prob, method_analytic)
-sol_carr = Hedgehog2.solve(prob, method_carr_madan)
-
 @btime Hedgehog2.solve($prob, $method_analytic)
 @btime Hedgehog2.solve($prob, $method_carr_madan)
 
+sol_analytic = Hedgehog2.solve(prob, method_analytic)
+sol_carr = Hedgehog2.solve(prob, method_carr_madan)
+
 println("Analytic price:   ", sol_analytic.price)
 println("Carr-Madan price: ", sol_carr.price)
 
-# --- Greeks via GreekProblem
-
-# Accessors
+# --- Greeks via Accessors
 spot_lens = @optic _.market_inputs.spot
-sigma_lens = Hedgehog2.VolLens(1,1)
+sigma_lens = Hedgehog2.VolLens(1, 1)
+lenses = (sigma_lens, spot_lens)
 
-# Methods
+# -- Greek methods
 fd = FiniteDifference(1e-3)
 ad = ForwardAD()
 
 println("\n--- Greeks (Analytic Method) ---")
-delta_fd = Hedgehog2.solve(GreekProblem(prob, spot_lens), fd, method_analytic).greek
-vega_fd = Hedgehog2.solve(GreekProblem(prob, sigma_lens), fd, method_analytic).greek
-delta_ad = Hedgehog2.solve(GreekProblem(prob, spot_lens), ad, method_analytic).greek
-vega_ad = Hedgehog2.solve(GreekProblem(prob, sigma_lens), ad, method_analytic).greek
+batch_prob = BatchGreekProblem(prob, lenses)
+greeks_fd = solve(batch_prob, fd, method_analytic)
+greeks_ad = solve(batch_prob, ad, method_analytic)
 
-println("FD Delta (analytic): ", delta_fd)
-println("AD Delta (analytic): ", delta_ad)
-println("FD Vega  (analytic): ", vega_fd)
-println("AD Vega  (analytic): ", vega_ad)
+println("FD Delta (analytic): ", greeks_fd[spot_lens])
+println("AD Delta (analytic): ", greeks_ad[spot_lens])
+println("FD Vega  (analytic): ", greeks_fd[sigma_lens])
+println("AD Vega  (analytic): ", greeks_ad[sigma_lens])
 
 println("\n--- Greeks (Carr-Madan Method) ---")
-delta_fd_cm = Hedgehog2.solve(GreekProblem(prob, spot_lens), fd, method_carr_madan).greek
-vega_fd_cm = Hedgehog2.solve(GreekProblem(prob, sigma_lens), fd, method_carr_madan).greek
-delta_ad_cm = Hedgehog2.solve(GreekProblem(prob, spot_lens), ad, method_carr_madan).greek
-vega_ad_cm = Hedgehog2.solve(GreekProblem(prob, sigma_lens), ad, method_carr_madan).greek
-
-println("FD Delta (Carr-Madan): ", delta_fd_cm)
-println("AD Delta (Carr-Madan): ", delta_ad_cm)
-println("FD Vega  (Carr-Madan): ", vega_fd_cm)
-println("AD Vega  (Carr-Madan): ", vega_ad_cm)
+greeks_fd_cm = solve(batch_prob, fd, method_carr_madan)
+greeks_ad_cm = solve(batch_prob, ad, method_carr_madan)
+
+println("FD Delta (Carr-Madan): ", greeks_fd_cm[spot_lens])
+println("AD Delta (Carr-Madan): ", greeks_ad_cm[spot_lens])
+println("FD Vega  (Carr-Madan): ", greeks_fd_cm[sigma_lens])
+println("AD Vega  (Carr-Madan): ", greeks_ad_cm[sigma_lens])
+
+# -- Benchmarks
+println("\n--- Benchmarking AD Greeks ---")
+@btime solve($batch_prob, $ad, $method_carr_madan)
+
+delta_prob = GreekProblem(prob, spot_lens)
+vega_prob = GreekProblem(prob, sigma_lens)
+
+@btime solve($delta_prob, $ad, $method_carr_madan)
+@btime solve($vega_prob, $ad, $method_carr_madan)