sdevpy 0.9.0__tar.gz → 1.0.0__tar.gz

{sdevpy-0.9.0/src/sdevpy.egg-info → sdevpy-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sdevpy
-Version: 0.9.0
+Version: 1.0.0
 Summary: Python package for Machine Learning in Finance
 Author-email: Sebastien Gurrieri <sebgur@gmail.com>
 Project-URL: Git page, https://github.com/sebgur/SDev.Python

{sdevpy-0.9.0 → sdevpy-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdevpy"
-version = "0.9.0"
+version = "1.0.0"
 authors = [
   { name="Sebastien Gurrieri", email="sebgur@gmail.com" },
 ]
@@ -18,7 +18,7 @@ classifiers = [
 ]
 dependencies = [
 	"pandas","pyperclip","py_vollib","numpy","tensorflow",
-  "scikit-learn"
+  "scikit-learn", "tensorflow_probability"
 ]
 
 [project.urls]

sdevpy-1.0.0/src/sdevpy/__init__.py

@@ -0,0 +1 @@
+__version__ = '1.0.0'

{sdevpy-0.9.0 → sdevpy-1.0.0}/src/sdevpy/analytics/black.py

@@ -3,9 +3,13 @@ import numpy as np
 import scipy.stats
 from scipy.optimize import minimize_scalar
 import py_vollib.black.implied_volatility as jaeckel
+import tensorflow as tf
+import tensorflow_probability as tfp
+from sdevpy import settings
 
 N = scipy.stats.norm.cdf
 # Ninv = scipy.stats.norm.ppf
+tf_N = tfp.distributions.Normal(0.0, 1.0)
 
 
 def price(expiry, strike, is_call, fwd, vol):
@@ -40,6 +44,48 @@ def implied_vol(expiry, strike, is_call, fwd, fwd_price):
 
     return res.x
 
+
+def price_and_greeks(expiry, strike, spot, vol, rate, div):
+    """ Calculate call PV and sensitivities by AAD on Black-Scholes CF """
+    tf_spot = tf.convert_to_tensor(spot, dtype='float32')
+    tf_vol = tf.convert_to_tensor(vol)
+    tf_time = tf.convert_to_tensor(expiry, dtype='float32')
+    tf_rate = tf.convert_to_tensor(rate, dtype='float32')
+    tf_div = tf.constant(div)
+
+    with tf.GradientTape(persistent=True) as tape:
+        tape.watch([tf_spot, tf_vol, tf_time, tf_rate])
+        with tf.GradientTape(persistent=True) as tape2nd:
+            tape2nd.watch([tf_spot, tf_vol])
+
+            fwd = tf_spot * tf.math.exp((tf_rate - tf_div) * tf_time)
+            stdev = tf_vol * tf.math.sqrt(tf_time)
+            d1 = tf.math.log(fwd / strike) / stdev + 0.5 * stdev
+            d2 = d1 - stdev
+            df = tf.math.exp(-tf_rate * tf_time)
+            pv = df * (fwd * tf_N.cdf(d1) - strike * tf_N.cdf(d2))
+
+        # Calculate delta and vega
+        g_delta = tape2nd.gradient(pv, tf_spot)
+        g_vega = tape2nd.gradient(pv, tf_vol)
+
+    delta = tape.gradient(pv, tf_spot)
+    gamma = tape.gradient(g_delta, tf_spot)
+    vega = tape.gradient(pv, tf_vol)
+    theta = tape.gradient(pv, tf_time)
+    dv01 = tape.gradient(pv, tf_rate)
+    volga = tape.gradient(g_vega, tf_vol)
+    vanna = tape.gradient(g_delta, tf_vol)
+
+    # Scale
+    vega = vega.numpy() * settings.VEGA_SCALING
+    theta = -theta.numpy() * settings.THETA_SCALING
+    dv01 = dv01.numpy() * settings.DV01_SCALING
+    volga = volga.numpy() * settings.VOLGA_SCALING
+    vanna = vanna.numpy() * settings.VANNA_SCALING
+
+    return [pv.numpy(), delta.numpy(), gamma.numpy(), vega, theta, dv01, volga, vanna]
+
 # def performance(spot_vol, repo_rate, div_rate, expiry, strike, fixings):
 #     shape = spot_vol.shape
 #     num_underlyings = int(shape[0] / 2)

{sdevpy-0.9.0 → sdevpy-1.0.0}/src/sdevpy/machinelearning/datasets.py

@@ -59,6 +59,11 @@ def clip_dataframe(df, size):
         return df
     else:
         return df.iloc[range(0, size)]
+    
+def shuffle_dataframe(df, frac=1):
+    """ Shuffle dataframe """
+    df = df.sample(frac=frac)
+    return df
 
 
 if __name__ == "__main__":

sdevpy-1.0.0/src/sdevpy/montecarlo/smoothers.py

@@ -0,0 +1,48 @@
+""" Payoff smoothers for numerical methods """
+import numpy as np
+import tensorflow as tf
+# import scipy.stats
+# import tensorflow_probability as tfp
+
+
+# Smoothing parameters (for the max function)
+SMOOTH_VOL = 0.40
+SMOOTH_TIME = 10.0 / 365.0
+SMOOTH_STDEV = SMOOTH_VOL * np.sqrt(SMOOTH_TIME)
+
+
+# Numpy versions (non-AAD)
+# N = scipy.stats.norm
+
+def approx_cdf(x):
+    """ Simple approximation of CDF """
+    return 1.0 / (1.0 + np.exp(-x / 0.5879))
+
+
+def smooth_call(spot, strike):
+    """ Smoothing of call payoff """
+    d1 = np.log(spot / strike) / SMOOTH_STDEV + 0.5 * SMOOTH_STDEV
+    d2 = d1 - SMOOTH_STDEV
+    n1 = approx_cdf(d1)
+    n2 = approx_cdf(d2)
+    return spot * n1 - 0.5 * strike * (n1 + n2)  # Average
+    # return spot * N.cdf(d1) - strike * N.cdf(d2)  # BS, overestimates
+    # return (spot - strike) * N.cdf(d1)  # Underestimates
+
+
+# Tensorflow versions (AAD)
+# tf_N = tfp.distributions.Normal(0.0, 1.0)
+
+def tf_approx_cdf(x):
+    """ Simple approximation of CDF """
+    return 1.0 / (1.0 + tf.math.exp(-x / 0.5879))
+
+def tf_smooth_call(spot, strike):
+    """ Smoothing of call payoff """
+    d1 = tf.math.log(spot / strike) / SMOOTH_STDEV + 0.5 * SMOOTH_STDEV
+    d2 = d1 - SMOOTH_STDEV
+    n1 = tf_approx_cdf(d1)
+    n2 = tf_approx_cdf(d2)
+    return spot * n1 - 0.5 * strike * (n1 + n2)  # Average
+    # return spot * tf_N.cdf(d1) - strike * tf_N.cdf(d2)  # BS, overestimates
+    # return (spot - strike) * tf_N.cdf(d1)  # Underestimates

sdevpy-1.0.0/src/sdevpy/projects/aad/aad_mc.py

@@ -0,0 +1,281 @@
+""" Calculate PV and Greeks of a call option on a single Black-Scholes underlying. We compare
+    standard MC with Greeks obtained by bump and reprice vs AAD MC vs Closed-Form. """
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+from sdevpy.montecarlo import smoothers
+from sdevpy import settings
+from sdevpy.analytics import black
+from sdevpy.tools.timer import Stopwatch
+
+# ################ Runtime configuration ##########################################################
+# Parameters
+EXPIRY = 2
+SPOT = 100.0
+VOL = 0.20
+RATE = 0.04
+DIV = 0.01
+STRIKE = 100.0
+
+# Bumps for differentials
+SPOT_BUMP = 0.01  # Percentage of spot
+VOL_BUMP = 0.01  # Percentage of vol
+TIME_BUMP = 1.0 / 365.0
+RATE_BUMP = 1.0 / 10000.0  # In bps
+
+# Scalings
+VEGA_SCL = settings.VEGA_SCALING
+THETA_SCL = settings.THETA_SCALING
+DV01_SCL = settings.DV01_SCALING
+VOLGA_SCL = settings.VOLGA_SCALING
+VANNA_SCL = settings.VANNA_SCALING
+
+# Random generator seed
+SEED = 42
+
+# Use smoother in standard MC (always used in AAD)
+USE_SMOOTHER_STD = False
+
+# ################ Helper functions ###############################################################
+def print_val(values_, is_pv_vector=False):
+    """ Simple screen printing of valuation results """
+    if is_pv_vector:
+        print(f"PV: {values_[0][0]:,.4f}")
+    else:
+        print(f"PV: {values_[0]:,.4f}")
+    print(f"Delta: {values_[1]:,.4f}")
+    print(f"Gamma: {values_[2]:,.4f}")
+    print(f"Vega: {values_[3]:,.4f}")
+    print(f"Theta: {values_[4]:,.4f}")
+    print(f"DV01: {values_[5]:,.4f}")
+    print(f"Volga: {values_[6]:,.4f}")
+    print(f"Vanna: {values_[7]:,.4f}")
+
+# ################ Standard Monte-Carlo #########################################################
+# Standard simulator
+def simulate_std(spot_, vol_, time_, rate_, gaussians):
+    """ Standard MC simulation for PV """
+    # Calculate deterministic forward
+    fwd = spot_ * np.exp((rate_ - DIV) * time_)
+
+    # Calculate final spot paths
+    stdev = vol_ * np.sqrt(time_)
+    future_spot = fwd * np.exp(-0.5 * stdev * stdev + stdev * gaussians)
+
+    # Calculate discounted payoff
+    df = np.exp(-rate_ * time_)
+    if USE_SMOOTHER_STD:
+        payoff = df * smoothers.smooth_call(future_spot, STRIKE)  # Use smoothing
+    else:
+        payoff = df * np.maximum(future_spot - STRIKE, 0)
+
+    # Reduce
+    pv = np.mean(payoff, axis=0)
+
+    return pv
+
+# Sensitivities by bumps
+def calculate_std(spot_, vol_, time_, rate_, num_mc):
+    """ Calculate PV and sensitivities by bumps on MC """
+    rng = np.random.RandomState(SEED)
+    # Calculate gaussians only once
+    gaussians = rng.normal(0.0, 1.0, (num_mc, 1))
+
+    pv = simulate_std(spot_, vol_, EXPIRY, rate_, gaussians)
+
+    # Delta-Gamma
+    spot_u = spot_ * (1.0 + SPOT_BUMP)
+    pv_spot_up = simulate_std(spot_u, vol_, time_, rate_, gaussians)
+
+    spot_d = spot_ * (1.0 - SPOT_BUMP)
+    pv_spot_down = simulate_std(spot_d, vol_, time_, rate_, gaussians)
+
+    # Vega-Volga
+    vol_u = vol_ * (1.0 + VOL_BUMP)
+    pv_vol_up = simulate_std(spot_, vol_u, time_, rate_, gaussians)
+
+    vol_d = vol_ * (1.0 - VOL_BUMP)
+    pv_vol_down = simulate_std(spot_, vol_d, time_, rate_, gaussians)
+
+    # Theta
+    pv_expiry_down = simulate_std(spot_, vol_, time_ - TIME_BUMP, rate_, gaussians)
+
+    # DV01
+    pv_rate_up = simulate_std(spot_, vol_, time_, rate_ + RATE_BUMP, gaussians)
+    pv_rate_down = simulate_std(spot_, vol_, time_, rate_ - RATE_BUMP, gaussians)
+
+    # Vanna
+    pv_uu = simulate_std(spot_u, vol_u, time_, rate_, gaussians)
+    pv_ud = simulate_std(spot_u, vol_d, time_, rate_, gaussians)
+    pv_du = simulate_std(spot_d, vol_u, time_, rate_, gaussians)
+    pv_dd = simulate_std(spot_d, vol_d, time_, rate_, gaussians)
+
+    # FDM
+    delta = (pv_spot_up - pv_spot_down) / (2.0 * SPOT_BUMP * spot_)
+    gamma = (pv_spot_up + pv_spot_down - 2.0 * pv) / np.power(SPOT_BUMP * spot_, 2)
+    vega = (pv_vol_up - pv_vol_down) / (2.0 * VOL_BUMP * vol_) * VEGA_SCL
+    theta = (pv_expiry_down - pv) / TIME_BUMP * THETA_SCL
+    dv01 = (pv_rate_up - pv_rate_down) / (2.0 * RATE_BUMP) * DV01_SCL
+    volga_size = np.power(VOL_BUMP * vol_, 2)
+    volga = (pv_vol_up + pv_vol_down - 2.0 * pv) / volga_size * VOLGA_SCL
+    vanna_size = 4.0 * SPOT_BUMP * spot_ * VOL_BUMP * vol_
+    vanna = (pv_uu - pv_ud - pv_du + pv_dd) / vanna_size * VANNA_SCL
+
+    return [pv, delta, gamma, vega, theta, dv01, volga, vanna]
+
+# Test bumps
+NUM_MC = 100 * 1000
+print(f">> Running {NUM_MC:,} Standard MC Simulations")
+values = calculate_std(SPOT, VOL, EXPIRY, RATE, NUM_MC)
+print_val([v[0] for v in values])
+
+# ################ AAD Monte-Carlo ###############################################################
+# AAD 2nd order simulator with smoothing
+def calculate_aad(spot_, vol_, time_, rate_, num_mc):
+    """ Calculate PV and sensitivities by AAD MC """
+    rng = np.random.RandomState(SEED)
+    gaussians = rng.normal(0.0, 1.0, (num_mc, 1))
+
+    tf_spot = tf.convert_to_tensor(spot_, dtype='float32')
+    tf_vol = tf.convert_to_tensor(vol_)
+    tf_time = tf.convert_to_tensor(time_, dtype='float32')
+    tf_rate = tf.convert_to_tensor(rate_, dtype='float32')
+    tf_div = tf.constant(DIV)
+
+    with tf.GradientTape(persistent=True) as tape:
+        tape.watch([tf_spot, tf_vol, tf_time, tf_rate])
+        with tf.GradientTape(persistent=True) as tape2nd:
+            tape2nd.watch([tf_spot, tf_vol])
+
+            # Calculate deterministic forward
+            fwd = tf_spot * tf.math.exp((tf_rate - tf_div) * tf_time)
+
+            # Calculate final spot paths
+            stdev = tf_vol * tf.math.sqrt(tf_time)
+            future_spot = fwd * tf.math.exp(-0.5 * stdev * stdev + stdev * gaussians)
+
+            # Calculate discounted payoff
+            df = tf.math.exp(-tf_rate * tf_time)
+            payoff = df * smoothers.tf_smooth_call(future_spot, STRIKE)
+
+            # Reduce
+            pv = tf.reduce_mean(payoff, axis=0)
+
+        # Calculate delta and vega
+        g_delta = tape2nd.gradient(pv, tf_spot)
+        g_vega = tape2nd.gradient(pv, tf_vol)
+
+    delta = tape.gradient(pv, tf_spot)
+    gamma = tape.gradient(g_delta, tf_spot)
+    vega = tape.gradient(pv, tf_vol)
+    theta = tape.gradient(pv, tf_time)
+    dv01 = tape.gradient(pv, tf_rate)
+    volga = tape.gradient(g_vega, tf_vol)
+    vanna = tape.gradient(g_delta, tf_vol)
+
+    # Scale
+    vega = vega.numpy() * VEGA_SCL
+    theta = -theta.numpy() * THETA_SCL
+    dv01 = dv01.numpy() * DV01_SCL
+    volga = volga.numpy() * VOLGA_SCL
+    vanna = vanna.numpy() * VANNA_SCL
+
+    return [pv.numpy(), delta.numpy(), gamma.numpy(), vega, theta, dv01, volga, vanna]
+
+# Test AAD with smoothing
+NUM_MC = 100 * 1000
+print(f">> Running {NUM_MC:,} AAD MC Simulations")
+values = calculate_aad(SPOT, VOL, EXPIRY, RATE, NUM_MC)
+
+print_val(values, is_pv_vector=True)
+
+############# Test against CF #####################################################################
+# Calculate with closed-form
+print(">> Calculating closed-form (CF)")
+values = black.price_and_greeks(EXPIRY, STRIKE, SPOT, VOL, RATE, DIV)
+print_val(values)
+
+######### Numerical Tests #########################################################################
+# Ladder tests
+NUM_POINTS = 100  # Number of loops/points in the charts
+MIN_S = 20.0
+MAX_S = 200.0
+NUM_MC = 10 * 1000  # Number of simulations
+spots = np.linspace(MIN_S, MAX_S, NUM_POINTS, dtype='double')  # spot ladder
+print(f">> Calculating {NUM_POINTS:,} points with {NUM_MC:,} simulations over spot range " +
+      f"[{MIN_S:,}, {MAX_S:,}]")
+
+# Vectorize for broadcasting
+vols = np.ones(NUM_POINTS, dtype='float32') * VOL
+times = np.ones(NUM_POINTS, dtype='float32') * EXPIRY
+rates = np.ones(NUM_POINTS, dtype='float32') * RATE
+
+# Bump method
+print("> Calculating with bumps...")
+print(f"Number of simulations: {NUM_MC:,}")
+timer_bmp = Stopwatch("Bump-MC")
+timer_bmp.trigger()
+results_bmp = calculate_std(spots, vols, times, rates, NUM_MC)
+timer_bmp.stop()
+
+# AAD
+print("Calculating with AAD...")
+print(f"Number of simulations: {NUM_MC:,}")
+timer_aad = Stopwatch("AAD-MC")
+timer_aad.trigger()
+results_aad = calculate_aad(spots, vols, times, rates, NUM_MC)
+timer_aad.stop()
+
+# AD closed-form
+print("Calculating with closed-form...")
+timer_cf = Stopwatch("CF")
+timer_cf.trigger()
+results_adcf = black.price_and_greeks(times, STRIKE, spots, vols, rates, DIV)
+timer_cf.stop()
+
+print("Calculation complete!")
+timer_bmp.print()
+timer_aad.print()
+timer_cf.print()
+
+#### Charts
+results_bmp = np.array(results_bmp)
+results_aad = np.array(results_aad)
+results_adcf = np.array(results_adcf)
+
+# Select viewing range
+VIEW_MIN = MIN_S  # Choose larger to zoom in
+VIEW_MAX = MAX_S  # Choose smaller to zoom in
+
+view_range = [i for i in range(NUM_POINTS) if spots[i] >= VIEW_MIN and spots[i] <= VIEW_MAX]
+start = view_range[0]
+end = view_range[-1]
+
+def plot_value(plt_idx, name, result_idx, legend_location):
+    """ Plot 3-way comparison between standard MC, AAD MC and closed-form """
+    plt.subplot(4, 2, plt_idx)
+    plt.title(name)
+    plt.xlabel('Spot')
+    plt.plot(spots[start:end], results_bmp[result_idx][start:end], 'green', alpha=0.7,
+             label='Bump-MC')
+    plt.plot(spots[start:end], results_adcf[result_idx][start:end], color='blue', alpha=0.8,
+             label='CF')
+    plt.plot(spots[start:end], results_aad[result_idx][start:end], color='red',
+             label='AAD-MC')
+    plt.legend(loc=legend_location)
+
+# Plot results
+plt.ioff()
+plt.figure(figsize=(15, 16))
+plt.subplots_adjust(hspace=0.40, wspace=0.20)
+
+plot_value(1, "PV", 0, 'upper left')
+plot_value(2, "Delta", 1, 'upper left')
+plot_value(3, "Vega", 3, 'upper right')
+plot_value(4, "Gamma", 2, 'upper right')
+plot_value(5, "Volga", 6, 'upper left')
+plot_value(6, "Vanna", 7, 'upper right')
+plot_value(7, "Theta", 4, 'upper right')
+plot_value(8, "DV01", 5, 'lower right')
+
+plt.show()

{sdevpy-0.9.0 → sdevpy-1.0.0}/src/sdevpy/settings.py

@@ -4,6 +4,12 @@ import os
 # Global variables
 WORKFOLDER = r"C:\temp\sdevpy"
 
+VEGA_SCALING = 0.01  # Vega shown for 1% absolute moves
+THETA_SCALING = 1.0 / 365.0  # Theta shown for 1d moves
+DV01_SCALING = 1.0 / 10000.0  # DV01 shown for 1bp moves
+VOLGA_SCALING = VEGA_SCALING**2
+VANNA_SCALING = VEGA_SCALING
+
 # Disable debug warnings in tensorflow
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
 

{sdevpy-0.9.0 → sdevpy-1.0.0}/src/sdevpy/test.py

@@ -4,10 +4,12 @@
 # import scipy.stats as sp
 # import json
 # import matplotlib.pyplot as plt
-import requests, zipfile
-import io
+# import requests, zipfile
+# import io
 import pandas as pd
-from io import BytesIO
+# from io import BytesIO
+
+
 
 # URL = 'https://drive.google.com/file/d/10dKi82fW2arlKnOahNv9i5igfiydwMnc/view?usp=sharing'
 

{sdevpy-0.9.0 → sdevpy-1.0.0}/src/sdevpy/volsurfacegen/mchestongenerator.py

@@ -108,9 +108,7 @@ class McHestonGenerator(SmileGenerator):
 
         return prices
 
-    def retrieve_datasets(self, data_file, shuffle=False):
-        data_df = SmileGenerator.from_file(data_file, shuffle)
-
+    def retrieve_datasets_no_shuffle(self, data_df):
         # Retrieve suitable data
         t = data_df.Ttm
         strike = data_df.K
@@ -128,7 +126,7 @@ class McHestonGenerator(SmileGenerator):
         y_set = np.asarray(nvol)
         y_set = np.reshape(y_set, (num_samples, 1))
 
-        return x_set, y_set, data_df
+        return x_set, y_set
 
     def price_surface_mod(self, model, expiries, strikes, are_calls, fwd, parameters):
         # Retrieve parameters

{sdevpy-0.9.0 → sdevpy-1.0.0}/src/sdevpy/volsurfacegen/mczabrgenerator.py

@@ -108,9 +108,7 @@ class McZabrGenerator(SmileGenerator):
 
         return prices
 
-    def retrieve_datasets(self, data_file, shuffle=False):
-        data_df = SmileGenerator.from_file(data_file, shuffle)
-
+    def retrieve_datasets_no_shuffle(self, data_df):
         # Retrieve suitable data
         t = data_df.Ttm
         strike = data_df.K
@@ -128,7 +126,7 @@ class McZabrGenerator(SmileGenerator):
         y_set = np.asarray(nvol)
         y_set = np.reshape(y_set, (num_samples, 1))
 
-        return x_set, y_set, data_df
+        return x_set, y_set
 
     def price_surface_mod(self, model, expiries, strikes, are_calls, fwd, parameters):
         # Retrieve parameters

{sdevpy-0.9.0 → sdevpy-1.0.0}/src/sdevpy/volsurfacegen/sabrgenerator.py

@@ -109,9 +109,7 @@ class SabrGenerator(SmileGenerator):
 
         return np.asarray(prices)
 
-    def retrieve_datasets(self, data_file, shuffle=False):
-        data_df = SmileGenerator.from_file(data_file, shuffle)
-
+    def retrieve_datasets_no_shuffle(self, data_df):
         # Retrieve suitable data
         t = data_df.Ttm
         strike = data_df.K
@@ -128,7 +126,8 @@ class SabrGenerator(SmileGenerator):
         y_set = np.asarray(nvol)
         y_set = np.reshape(y_set, (num_samples, 1))
 
-        return x_set, y_set, data_df
+        return x_set, y_set
+
 
     def price_surface_mod(self, model, expiries, strikes, are_calls, fwd, parameters):
         # Retrieve parameters

{sdevpy-0.9.0 → sdevpy-1.0.0}/src/sdevpy/volsurfacegen/smilegenerator.py

@@ -4,14 +4,12 @@ import numpy as np
 import pandas as pd
 import scipy.stats as sp
 from sdevpy.analytics import bachelier
-# from sdevpy.analytics import black
+from sdevpy.machinelearning import datasets
 
 
 class SmileGenerator(ABC):
     """ Base class for smile generation """
     def __init__(self, shift=0.0, num_expiries=15, num_strikes=10, seed=42):
-        # self.num_curve_parameters = 0
-        # self.num_vol_parameters = 0
         self.is_call = False  # Use put options by default
         self.shift = shift
         self.num_strikes = num_strikes
@@ -28,13 +26,22 @@ class SmileGenerator(ABC):
     def price(self, expiries, strikes, are_calls, fwd, parameters):
         """ Calculate option price under the specified model and its parameters """
 
-    @abstractmethod
     def retrieve_datasets(self, data_file, shuffle=False):
         """ Retrieve dataset stored in tsv file """
+        data_df = SmileGenerator.from_file(data_file, shuffle)
+        x_set, y_set = self.retrieve_datasets_from_df(data_df, False)
+        return x_set, y_set, data_df
+
+    def retrieve_datasets_from_df(self, data_df, shuffle=False):
+        """ Retrieve dataset from dataframe """
+        if shuffle:
+            data_df = datasets.shuffle_dataframe(data_df)
+
+        return self.retrieve_datasets_no_shuffle(data_df)
 
-    # @abstractmethod
-    # def price_surface_ref(self, expiries, strikes, are_calls, fwd, parameters):
-    #     """ Calculate a surface of prices for given parameters using the generating model """
+    @abstractmethod
+    def retrieve_datasets_no_shuffle(self, data_df):
+        """ Retrieve dataset from dataframe without shuffling """
 
     def price_surface_ref(self, expiries, strikes, are_calls, fwd, parameters):
         """ Calculate a surface of prices for given parameters using the generating model """
@@ -65,10 +72,6 @@ class SmileGenerator(ABC):
 
         return strikes
 
-    # def num_parameters(self):
-    #     """ Total number of parameters (curve + vol) """
-    #     return self.num_curve_parameters + self.num_vol_parameters
-
     def to_nvol(self, data_df, cleanse=True, min_vol=0.0001, max_vol=0.1):
         """ Calculate normal implied vol and remove errors. Further remove points that are not
             in the given min/max range """
@@ -92,20 +95,6 @@ class SmileGenerator(ABC):
             except (Exception,):
                 nvol.append(-9999)
 
-        # Add test on Shifted BS
-        # shift = 0.03
-        # bsvol = []
-        # for i in range(num_samples):
-        #     if i % num_print == 0:
-        #         print(f"Converting to lognormal vol, batch {int(i/num_print)+1:,} out of
-        #                   {num_batches:,}")
-        #     try:
-        #         bsvol.append(black.implied_vol(t[i], strike[i] + shift, self.is_call,
-        #                    fwd[i] + shift, price[i]))
-        #     except (Exception,):
-        #         bsvol.append(-9999)
-
-
         np.seterr(divide='warn')  # Set back to warning
 
         data_df['NVol'] = nvol
@@ -115,8 +104,6 @@ class SmileGenerator(ABC):
         if cleanse:
             data_df = data_df.drop(data_df[data_df.NVol > max_vol].index)
             data_df = data_df.drop(data_df[data_df.NVol < min_vol].index)
-            # data_df = data_df.drop(data_df[data_df.BSVol < 0.01].index)
-            # data_df = data_df.drop(data_df[data_df.BSVol > 0.99].index)
 
         return data_df
 

{sdevpy-0.9.0 → sdevpy-1.0.0/src/sdevpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sdevpy
-Version: 0.9.0
+Version: 1.0.0
 Summary: Python package for Machine Learning in Finance
 Author-email: Sebastien Gurrieri <sebgur@gmail.com>
 Project-URL: Git page, https://github.com/sebgur/SDev.Python

{sdevpy-0.9.0 → sdevpy-1.0.0}/src/sdevpy.egg-info/SOURCES.txt

@@ -25,7 +25,9 @@ src/sdevpy/maths/interpolations.py
 src/sdevpy/maths/metrics.py
 src/sdevpy/maths/optimization.py
 src/sdevpy/maths/rand.py
+src/sdevpy/montecarlo/smoothers.py
 src/sdevpy/projects/datafiles.py
+src/sdevpy/projects/aad/aad_mc.py
 src/sdevpy/projects/stovol/stovolgen.py
 src/sdevpy/projects/stovol/stovolplot.py
 src/sdevpy/projects/stovol/stovoltrain.py

{sdevpy-0.9.0 → sdevpy-1.0.0}/src/sdevpy.egg-info/requires.txt

@@ -4,3 +4,4 @@ py_vollib
 numpy
 tensorflow
 scikit-learn
+tensorflow_probability

sdevpy-0.9.0/src/sdevpy/__init__.py

@@ -1 +0,0 @@
-__version__ = '0.9.0'