sdevpy 1.0.2__tar.gz → 1.0.3__tar.gz

{sdevpy-1.0.2/src/sdevpy.egg-info → sdevpy-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sdevpy
-Version: 1.0.2
+Version: 1.0.3
 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
@@ -18,6 +18,7 @@ Requires-Dist: numpy
 Requires-Dist: tensorflow
 Requires-Dist: scikit-learn
 Requires-Dist: tensorflow_probability
+Requires-Dist: silence_tensorflow
 
 # SDev.Python
 

{sdevpy-1.0.2 → sdevpy-1.0.3}/pyproject.toml

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

sdevpy-1.0.3/src/sdevpy/__init__.py

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

{sdevpy-1.0.2 → sdevpy-1.0.3}/src/sdevpy/machinelearning/learningmodel.py

@@ -7,6 +7,7 @@ import tensorflow as tf
 import joblib
 import absl.logging
 from sdevpy.tools import jsonmanager
+from sdevpy.tools import filemanager
 
 class LearningModel:
     """ Wrapper class for machine learning models, including scalers, and simplifying
@@ -54,10 +55,12 @@ class LearningModel:
 
     def save(self, path):
         """ Save model and its scalers to files """
+        filemanager.check_directory(path)
         # Save keras model first. Turn dummy warning off temporarily.
         verbosity = absl.logging.get_verbosity()
         absl.logging.set_verbosity(absl.logging.ERROR)
-        self.model.save(path)
+        model_file = os.path.join(path, "model.keras")
+        self.model.save(model_file)
         absl.logging.set_verbosity(verbosity)
 
         # Save scalers
@@ -132,7 +135,8 @@ def load_learning_model(path, compile_=False):
     if os.path.exists(path) is False:
         raise RuntimeError("Model folder does not exist: " + path)
 
-    keras_model = tf.keras.models.load_model(path, compile=compile_)
+    model_file = os.path.join(path, "model.keras")
+    keras_model = tf.keras.models.load_model(model_file, compile=compile_)
 
     x_scaler_file, y_scaler_file = scaler_files(path)
     if os.path.exists(x_scaler_file) and os.path.exists(y_scaler_file):

sdevpy-1.0.3/src/sdevpy/machinelearning/learningschedules.py

@@ -0,0 +1,78 @@
+""" Custom learning schedules """
+import tensorflow as tf
+import math
+from sdevpy.tools.constants import TWO_PI
+
+# Custom learning rate scheduler, exponentially decreases between given values
+class FlooredExponentialDecay(tf.keras.optimizers.schedules.LearningRateSchedule):
+    """ Custom learning rate scheduler, exponentially decreases between given values """
+    def __init__(self, num_samples, batch_size, target_epoch, initial_lr=1e-1, final_lr=1e-4):
+        self.initial_lr = initial_lr
+        self.final_lr = final_lr
+        # self.decay = decay
+        # self.decay_steps = decay_steps
+        # A step is the usage of one gradient, i.e. for one batch. As we go through the whole sample
+        # in 1 epoch, the number of steps per epoch is given by the number of batches per epoch
+        # i.e. the formula below.
+        steps_per_epoch = num_samples / batch_size
+        percent_reached = 0.10  # Percentage of the final LR reached by the chosen epoch
+        self.decay = final_lr * percent_reached / (initial_lr - final_lr)
+        self.steps_to_target = np.float32(steps_per_epoch * target_epoch)
+
+    def __call__(self, step):
+        ratio = tf.cast(step / self.steps_to_target, tf.float32)
+        coeff = tf.pow(self.decay, ratio)
+        ampl = self.initial_lr - self.final_lr
+        return self.final_lr + ampl * coeff
+
+    # def __call__(self, step):
+    #     ratio = tf.cast(step / self.decay_steps, tf.float32)
+    #     coeff = tf.pow(self.decay, ratio)
+    #     return self.initial_lr * coeff + self.final_lr * (1.0 - coeff)
+
+    def get_config(self):
+        config = { 'initial_lr': self.initial_lr,
+                   'final_lr': self.final_lr,
+                   'decay': self.decay,
+                   'decay_steps': self.steps_to_target }
+        return config
+
+import numpy as np
+
+# Custom learning rate scheduler, cyclically exponentially decreases between given values
+class CyclicalExponentialDecay(tf.keras.optimizers.schedules.LearningRateSchedule):
+    """ Custom learning rate scheduler, cyclically exponentially decreases between given values """
+    def __init__(self, num_samples, batch_size, target_epoch, initial_lr=1e-1, final_lr=1e-4,
+                 periods=10.0):
+        # Amplitude decay
+        self.initial_lr = initial_lr
+        self.final_lr = final_lr
+        # self.period = periods
+        # A step is the usage of one gradient, i.e. for one batch. As we go through the whole sample
+        # in 1 epoch, the number of steps per epoch is given by the number of batches per epoch
+        # i.e. the formula below.
+        steps_per_epoch = num_samples / batch_size
+        percent_reached = 0.10  # Percentage of the final LR reached by the chosen epoch
+        self.decay = final_lr * percent_reached / (initial_lr - final_lr)
+        self.steps_to_target = np.float32(steps_per_epoch * target_epoch)
+
+        # Oscillations
+        self.steps_per_period = np.float32(target_epoch * steps_per_epoch / periods)
+
+    def __call__(self, step):
+        ratio = tf.cast(step / self.steps_to_target, tf.float32)
+        coeff = tf.pow(self.decay, ratio)
+        ampl = self.initial_lr - self.final_lr
+        two_pi = tf.cast(TWO_PI, tf.float32)
+        arg = tf.cast(step / self.steps_per_period, tf.float32)
+        oscillation = (2.0 + tf.math.cos(arg * two_pi)) / 2.0  # Between 0.5 and 1.5
+        ampl = ampl * oscillation
+        return self.final_lr + ampl * coeff
+
+    def get_config(self):
+        config = { 'initial_lr': self.initial_lr,
+                   'final_lr': self.final_lr,
+                   'decay': self.decay,
+                   'steps_to_target': self.steps_to_target,
+                   'steps_per_period': self.steps_per_period }
+        return config

{sdevpy-1.0.2 → sdevpy-1.0.3}/src/sdevpy/machinelearning/topology.py

@@ -20,7 +20,7 @@ def compose_model(num_inputs, num_outputs, hidden_layers, neurons, dropout=0.2):
     model = tf.keras.Sequential()
 
     # Input layer
-    model.add(tf.keras.Input(num_inputs))
+    model.add(tf.keras.Input(shape=(num_inputs,)))
 
     # Hidden layers
     for layer in hidden_layers:

{sdevpy-1.0.2 → sdevpy-1.0.3}/src/sdevpy/projects/stovolinverse/stovolinvgen.py

@@ -15,13 +15,14 @@ MODEL_TYPE = "SABR"
 # MODEL_TYPE = "McZABR"
 # MODEL_TYPE = "McHeston"
 SHIFT = 0.03
-NUM_SAMPLES = 100 * 1000
+NUM_SAMPLES = 1000 * 1000
 # The 4 parameters below are only relevant for models whose reference is calculated by MC
 NUM_EXPIRIES = 15
 NUM_MC = 100 * 1000 # 100 * 1000
 POINTS_PER_YEAR = 25 # 25
-SEED = 1357 # [1357, 8642, 1000, 8888, 4444, 2222, 1111, 4321, 1234, 42]
+SEED = 1234 # [1357, 8642, 1000, 8888, 4444, 2222, 1111, 4321, 1234, 42]
 SPREADS = [-200, -100, -75, -50, -25, -10, 0, 10, 25, 50, 75, 100, 200]
+USE_NVOL = True
 
 print(">> Set up runtime configuration")
 project_folder = os.path.join(settings.WORKFOLDER, "stovolinv")
@@ -57,7 +58,7 @@ print(">> Generate dataset")
 print(f"> Generate {NUM_SAMPLES:,} price samples")
 timer_gen = Stopwatch("Generating Samples")
 timer_gen.trigger()
-data_df = generator.generate_samples_inverse(NUM_SAMPLES, RANGES, SPREADS)
+data_df = generator.generate_samples_inverse(NUM_SAMPLES, RANGES, SPREADS, USE_NVOL)
 timer_gen.stop()
 
 timer_out = Stopwatch("File Output")

{sdevpy-1.0.2 → sdevpy-1.0.3}/src/sdevpy/projects/stovolinverse/stovolinvtrain.py

@@ -24,6 +24,9 @@ from sdevpy.projects.stovol import stovolplot as xplt
 
 
 # ################ ToDo ###########################################################################
+# Start additional script with simplified function starting from trained model only, to test
+# against classic calibration, shifting parameters, sensies, etc.
+
 # We could generate market points from SABR, then generate a new set from a slightly different
 # set of SABR parameters such as a rho move, a nu move, etc. Then re-calibrate by optimization
 # vs using the network and see if they produce expected move. For instance if the second
@@ -55,18 +58,19 @@ SHIFT = 0.03
 USE_TRAINED = True
 DOWNLOAD_MODELS = False # Only used when USE_TRAINED is True
 DOWNLOAD_DATASETS = False # Use when already created/downloaded
-TRAIN = False
+TRAIN = True
 if USE_TRAINED is False and TRAIN is False:
     raise RuntimeError("When not using pre-trained models, a new model must be trained")
 
-NUM_SAMPLES = 10 * 1000#2 * 1000 * 1000 # Number of samples to read from sample files
+NUM_SAMPLES = 200 * 1000#2 * 1000 * 1000 # Number of samples to read from sample files
 TRAIN_PERCENT = 0.90 # Proportion of dataset used for training (rest used for test)
-EPOCHS = 200
+EPOCHS = 50
 BATCH_SIZE = 1000
 SHOW_VOL_CHARTS = True # Show smile section charts
 # For comparison to reference values (accuracy of reference)
 NUM_MC = 100 * 1000 # 100 * 1000
 POINTS_PER_YEAR = 25# 25
+USE_NVOL = True
 project_folder = os.path.join(settings.WORKFOLDER, "stovolinv")
 
 print(">> Set up runtime configuration")
@@ -146,6 +150,7 @@ else:
     print(">> Composing new model")
     # Initialize the model
     HIDDEN_LAYERS = ['softplus', 'softplus', 'softplus']
+    # NUM_NEURONS = 128
     NUM_NEURONS = 64
     DROP_OUT = 0.0
     keras_model = compose_model(input_dim, output_dim, HIDDEN_LAYERS, NUM_NEURONS, DROP_OUT)
@@ -162,13 +167,14 @@ print(f"> Drop-out rate: {DROP_OUT:.2f}")
 # ################ Train the model ################################################################
 if TRAIN:
     # Learning rate scheduler
-    INIT_LR = 1.0e-2
-    FINAL_LR = 1.0e-4
-    DECAY = 0.99 # 0.97
-    STEPS = 250
-    PERIOD = 500
-    lr_schedule = CyclicalExponentialDecay(INIT_LR, FINAL_LR, DECAY, STEPS, PERIOD)
-    # lr_schedule = FlooredExponentialDecay(INIT_LR, FINAL_LR, DECAY, STEPS)
+    INIT_LR = 1.0e-2#1.0e-2
+    FINAL_LR = 1.0e-3#1.0e-4
+    TARGET_EPOCH = EPOCHS * 0.90  # Epoch by which we plan to be down to 110% of final LR
+    PERIODS = 10  # Number of oscillation periods until target epoch
+
+    # lr_schedule = CyclicalExponentialDecay(NUM_SAMPLES, BATCH_SIZE, TARGET_EPOCH, INIT_LR, FINAL_LR,
+    #                                        PERIODS)
+    lr_schedule = FlooredExponentialDecay(NUM_SAMPLES, BATCH_SIZE, TARGET_EPOCH, INIT_LR, FINAL_LR)
 
     # Optimizer
     optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)
@@ -183,7 +189,7 @@ if TRAIN:
     keras_model.compile(loss=tf_bps_rmse, optimizer=optimizer)
 
     # Callbacks
-    EPOCH_SAMPLING = 5
+    EPOCH_SAMPLING = 1
     callback = RefCallback(x_test, y_test, bps_rmse, optimizer=optimizer,
                            epoch_sampling=EPOCH_SAMPLING, x_train=x_train, y_train=y_train)
 
@@ -239,20 +245,25 @@ if SHOW_VOL_CHARTS:
     TRAINING_SPREADS = np.asarray(TRAINING_SPREADS)
     TRAINING_SPREADS = np.tile(TRAINING_SPREADS, (NUM_EXPIRIES, 1))
     mkt_strikes = TRAINING_SPREADS / 10000.0 + FWD
-    # print(mkt_strikes)
-    mkt_prices = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, PARAMS)
-    # print(mkt_prices)
+
+    # Calculate market prices and vols
+    mkt_vols = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, PARAMS, True)
+    mkt_prices = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, PARAMS, False)
 
     # Use model to get parameters at each expiry, then calculate parameters and then prices
-    mod_params, mod_prices = generator.price_straddles_mod(model, EXPIRIES, mkt_strikes, FWD,
-                                                           mkt_prices)
-    rmse_mkt_mod = bps_rmse(mkt_prices, mod_prices)
+    mod_params, mod_vols = generator.price_straddles_mod(model, EXPIRIES, mkt_strikes, FWD,
+                                                           mkt_vols, True)
+    # mod_vols = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, mod_params, True)
+
+    # mkt_prices = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, PARAMS, False)
+    rmse_mkt_mod = bps_rmse(mkt_vols, mod_vols)
     # print(mod_prices)
 
     # Calibrate prices by optimization
     weights = np.asarray([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
-    cal_params, cal_prices = generator.calibrate(EXPIRIES, mkt_strikes, FWD, mkt_prices, weights)
-    rmse_mkt_cal = bps_rmse(mkt_prices, cal_prices)
+    cal_params, cal_vols = generator.calibrate(EXPIRIES, mkt_strikes, FWD, mkt_prices, weights, True)
+    # cal_vols = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, cal_params, True)
+    rmse_mkt_cal = bps_rmse(mkt_vols, cal_vols)
     print(f"RMSE market-model: {rmse_mkt_mod:,.2f}")
     print(f"RMSE market-calibration: {rmse_mkt_cal:,.2f}")
     # print(cal_params)
@@ -288,81 +299,50 @@ if SHOW_VOL_CHARTS:
 
     # PV
     plot_spreads = TRAINING_SPREADS[0]
-    axs[0, 0].plot(plot_spreads, mkt_prices[0], color='red', label='Target')
-    axs[0, 0].plot(plot_spreads, mod_prices[0], color='blue', label='Model')
-    axs[0, 0].plot(plot_spreads, cal_prices[0], 'g--', alpha=0.8, label='Calibration')
+    axs[0, 0].plot(plot_spreads, mkt_vols[0], color='red', label='Target')
+    axs[0, 0].plot(plot_spreads, mod_vols[0], color='blue', label='Model')
+    axs[0, 0].plot(plot_spreads, cal_vols[0], 'g--', alpha=0.8, label='Calibration')
     axs[0, 0].set_xlabel('Spread')
     axs[0, 0].set_title(f"Fit vs Target at T={EXPIRIES[0]}")
     axs[0, 0].legend(loc='upper right')
 
-    axs[0, 1].plot(plot_spreads, mkt_prices[1], color='red', label='Target')
-    axs[0, 1].plot(plot_spreads, mod_prices[1], color='blue', label='Model')
-    axs[0, 1].plot(plot_spreads, cal_prices[1], 'g--', alpha=0.8, label='Calibration')
+    axs[0, 1].plot(plot_spreads, mkt_vols[1], color='red', label='Target')
+    axs[0, 1].plot(plot_spreads, mod_vols[1], color='blue', label='Model')
+    axs[0, 1].plot(plot_spreads, cal_vols[1], 'g--', alpha=0.8, label='Calibration')
     axs[0, 1].set_xlabel('Spread')
     axs[0, 1].set_title(f"Fit vs Target at T={EXPIRIES[1]}")
     axs[0, 1].legend(loc='upper right')
 
-    axs[1, 0].plot(plot_spreads, mkt_prices[2], color='red', label='Target')
-    axs[1, 0].plot(plot_spreads, mod_prices[2], color='blue', label='Model')
-    axs[1, 0].plot(plot_spreads, cal_prices[2], 'g--', alpha=0.8, label='Calibration')
+    axs[1, 0].plot(plot_spreads, mkt_vols[2], color='red', label='Target')
+    axs[1, 0].plot(plot_spreads, mod_vols[2], color='blue', label='Model')
+    axs[1, 0].plot(plot_spreads, cal_vols[2], 'g--', alpha=0.8, label='Calibration')
     axs[1, 0].set_xlabel('Spread')
     axs[1, 0].set_title(f"Fit vs Target at T={EXPIRIES[2]}")
     axs[1, 0].legend(loc='upper right')
 
-    axs[1, 1].plot(plot_spreads, mkt_prices[3], color='red', label='Target')
-    axs[1, 1].plot(plot_spreads, mod_prices[3], color='blue', label='Model')
-    axs[1, 1].plot(plot_spreads, cal_prices[3], 'g--', alpha=0.8, label='Calibration')
+    axs[1, 1].plot(plot_spreads, mkt_vols[3], color='red', label='Target')
+    axs[1, 1].plot(plot_spreads, mod_vols[3], color='blue', label='Model')
+    axs[1, 1].plot(plot_spreads, cal_vols[3], 'g--', alpha=0.8, label='Calibration')
     axs[1, 1].set_xlabel('Spread')
     axs[1, 1].set_title(f"Fit vs Target at T={EXPIRIES[3]}")
     axs[1, 1].legend(loc='upper right')
 
-    axs[2, 0].plot(plot_spreads, mkt_prices[4], color='red', label='Target')
-    axs[2, 0].plot(plot_spreads, mod_prices[4], color='blue', label='Model')
-    axs[2, 0].plot(plot_spreads, cal_prices[4], 'g--', alpha=0.8, label='Calibration')
+    axs[2, 0].plot(plot_spreads, mkt_vols[4], color='red', label='Target')
+    axs[2, 0].plot(plot_spreads, mod_vols[4], color='blue', label='Model')
+    axs[2, 0].plot(plot_spreads, cal_vols[4], 'g--', alpha=0.8, label='Calibration')
     axs[2, 0].set_xlabel('Spread')
     axs[2, 0].set_title(f"Fit vs Target at T={EXPIRIES[4]}")
     axs[2, 0].legend(loc='upper right')
 
-    axs[2, 1].plot(plot_spreads, mkt_prices[5], color='red', label='Target')
-    axs[2, 1].plot(plot_spreads, mod_prices[5], color='blue', label='Model')
-    axs[2, 1].plot(plot_spreads, cal_prices[5], 'g--', alpha=0.8, label='Calibration')
+    axs[2, 1].plot(plot_spreads, mkt_vols[5], color='red', label='Target')
+    axs[2, 1].plot(plot_spreads, mod_vols[5], color='blue', label='Model')
+    axs[2, 1].plot(plot_spreads, cal_vols[5], 'g--', alpha=0.8, label='Calibration')
     axs[2, 1].set_xlabel('Spread')
     axs[2, 1].set_title(f"Fit vs Target at T={EXPIRIES[5]}")
     axs[2, 1].legend(loc='upper right')
 
     plt.show()
 
-    # METHOD = 'Percentiles'
-    # PERCENTS = np.linspace(0.01, 0.99, num=NUM_STRIKES)
-    # PERCENTS = np.asarray([PERCENTS] * NUM_EXPIRIES)
-
-    # strikes = generator.convert_strikes(EXPIRIES, PERCENTS, FWD, PARAMS, METHOD)
-
-    # print("> Calculating chart surface with reference model")
-    # timer_ref = Stopwatch("Reference surface calculation")
-    # timer_ref.trigger()
-    # ref_prices = generator.price_straddle(EXPIRIES, strikes, FWD, PARAMS)
-    # timer_ref.stop()
-    # clipboard.export2d(ref_prices)
-    # print("> Calculating chart surface with trained model")
-    # timer_mod = Stopwatch("Model surface calculation")
-    # timer_mod.trigger()
-    # mod_prices = generator.price_surface_mod(model, EXPIRIES, strikes, ARE_CALLS, FWD, PARAMS)
-    # timer_mod.stop()
-    # print(f"> Ref-Mod RMSE(price): {bps_rmse(ref_prices, mod_prices):.2f}")
-
-    # Display timers
-    # timer_ref.print()
-    # timer_mod.print()
-
-    # Available tranforms: Price, ShiftedBlackScholes, Bachelier
-    # TITLE = f"{MODEL_TYPE} smile sections, forward={FWD*100:.2f}"#,%\n parameters={PARAMS}"
-    # TRANSFORM = "Bachelier"
-    # TRANSFORM = "Price"
-    # TRANSFORM = "ShiftedBlackScholes"
-    # xplt.plot_transform_surface(EXPIRIES, strikes, ARE_CALLS, FWD, ref_prices, mod_prices,
-    #                             TITLE, transform=TRANSFORM)
-
 # Show training history
 if TRAIN:
     hist_epochs = callback.epochs

{sdevpy-1.0.2 → sdevpy-1.0.3}/src/sdevpy/volsurfacegen/sabrgenerator.py

@@ -97,7 +97,9 @@ class SabrGenerator(SmileGenerator):
 
         return df
 
-    def generate_samples_inverse(self, num_samples, rg, spreads):
+    def generate_samples_inverse(self, num_samples, rg, spreads, use_nvol=False,
+                                 min_vol=0.0001, max_vol=0.2):
+        np.seterr(divide='raise')  # To catch errors and warnings
         shift = self.shift
 
         min_fwd = -shift - spreads[0] / 10000 + constants.BPS10
@@ -154,7 +156,7 @@ class SabrGenerator(SmileGenerator):
             params = {'LnVol': lnvol[j], 'Beta': beta[j], 'Nu': nu[j], 'Rho': rho[j]}
 
             # Calculate prices
-            price = self.price_straddles_ref(expiries, ks, fwd, params)
+            price = self.price_straddles_ref(expiries, ks, fwd, params, use_nvol)
 
             # Flatten the results
             for exp_idx, expiry in enumerate(expiries):
@@ -166,6 +168,8 @@ class SabrGenerator(SmileGenerator):
                 rhos.append(rho[j])
                 prices.append(price[exp_idx])
 
+        np.seterr(divide='warn')  # Set back to warning
+
         # Create strike headers
         strike_headers = ['K' + str(j) for j in range(num_strikes)]
 
@@ -184,6 +188,12 @@ class SabrGenerator(SmileGenerator):
         df = pd.DataFrame(data_dic)
         df.columns = columns
 
+        # Cleanse
+        if use_nvol:
+            for j in range(num_strikes):
+                df = df.drop(df[df[strike_headers[j]] > max_vol].index)
+                df = df.drop(df[df[strike_headers[j]] < min_vol].index)
+
         return df
 
     def price(self, expiries, strikes, are_calls, fwd, parameters):
@@ -201,35 +211,39 @@ class SabrGenerator(SmileGenerator):
 
         return np.asarray(prices)
 
-    def price_straddles_ref(self, expiries, strikes, fwd, parameters):
+    def price_straddles_ref(self, expiries, strikes, fwd, parameters, output_nvol=False):
         expiries_ = np.asarray(expiries).reshape(-1, 1)
         shifted_k = strikes + self.shift
         shifted_f = fwd + self.shift
         prices = []
         for i, expiry in enumerate(expiries_):
             k_prices = []
-            for j, sk in enumerate(shifted_k[i]):
-                iv = sabr.implied_vol_vec(expiry, sk, shifted_f, parameters)
-                call_price = black.price(expiry, sk, True, shifted_f, iv)
-                put_price = black.price(expiry, sk, False, shifted_f, iv)
-                k_prices.append(call_price[0] + put_price[0])
+            if output_nvol:
+                for (k, sk) in zip(strikes[i], shifted_k[i]):  # Normal vols
+                    iv = sabr.implied_vol_vec(expiry, sk, shifted_f, parameters)
+                    is_call = True
+                    price = black.price(expiry, sk, is_call, shifted_f, iv)
+                    try:
+                        n_vol = bachelier.implied_vol(expiry, k, is_call, fwd, price)[0]
+                    except (Exception,):
+                        n_vol = -9999
+                    k_prices.append(n_vol)
+            else:
+                for sk in shifted_k[i]:  # Straddle prices
+                    iv = sabr.implied_vol_vec(expiry, sk, shifted_f, parameters)
+                    call_price = black.price(expiry, sk, True, shifted_f, iv)
+                    put_price = black.price(expiry, sk, False, shifted_f, iv)
+                    k_prices.append(call_price[0] + put_price[0])
             prices.append(k_prices)
 
         return np.asarray(prices)
 
-    def price_straddles_mod(self, model, expiries, strikes, fwd, mkt_prices):
+    def price_straddles_mod(self, model, expiries, strikes, fwd, mkt_prices, output_nvol=False):
         """ Calculate straddle prices for given parameters using the learning model """
-        # print("Expiries ", expiries.shape, "\n", expiries)
-        # print("Strikes ", strikes.shape, "\n", strikes)
-        # print("FWD ", fwd)
-        # print("Mkt Prices ", mkt_prices.shape, "\n", mkt_prices)
-
         # Prepare input points for the model
         n_expiries = expiries.shape[0]
         points = np.c_[expiries, np.ones(n_expiries) * fwd]
-        # print(points)
         points = np.c_[points, mkt_prices]
-        # print(points)
 
         # Evaluation model
         params = model.predict(points)
@@ -243,13 +257,8 @@ class SabrGenerator(SmileGenerator):
         mod_prices = []
         for i, expiry in enumerate(expiries):
             expiry_ = np.asarray([expiry])
-            # print(expiry)
             strikes_ = np.asarray([strikes[i]])
-            # print(strikes_)
-            # print(mod_params[i])
-            # mod_prices_ = self.price_straddles_ref(expiry_, strikes_, fwd, src_params)
-            mod_prices_ = self.price_straddles_ref(expiry_, strikes_, fwd, mod_params[i])
-            # print(mod_prices)
+            mod_prices_ = self.price_straddles_ref(expiry_, strikes_, fwd, mod_params[i], output_nvol)
             mod_prices.append(mod_prices_[0])
 
         return mod_params, np.asarray(mod_prices)
@@ -334,7 +343,7 @@ class SabrGenerator(SmileGenerator):
 
         return x_set, y_set
 
-    def calibrate(self, expiries, strikes, fwd, mkt_prices, weights):
+    def calibrate(self, expiries, strikes, fwd, mkt_prices, weights, output_nvol=False):
         # method = 'Nelder-Mead'
         # method = "Powell"
         # method = "L-BFGS-B"
@@ -381,7 +390,7 @@ class SabrGenerator(SmileGenerator):
         for i in range(num_expiries):
             expiries_ = np.asarray([expiries[i]])
             strikes_ = np.asarray([strikes[i]])
-            cal_prices_ = self.price_straddles_ref(expiries_, strikes_, fwd, cal_params[i])
+            cal_prices_ = self.price_straddles_ref(expiries_, strikes_, fwd, cal_params[i], output_nvol)
             cal_prices.append(cal_prices_[0])
 
         return cal_params, cal_prices

{sdevpy-1.0.2 → sdevpy-1.0.3}/src/sdevpy/volsurfacegen/smilegenerator.py

@@ -137,6 +137,42 @@ class SmileGenerator(ABC):
 
         return data_df
 
+    # def to_straddle_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 """
+    #     # Calculate normal vols
+    #     np.seterr(divide='raise')  # To catch errors and warnings
+    #     n_strikes = data_df.shape[1] - 6
+    #     t = data_df.Ttm
+    #     fwd = data_df.F
+    #     # strike = data_df.K
+    #     # price = data_df.Price
+    #     nvol = []
+    #     num_samples = t.shape[0]
+    #     num_print = 10000
+    #     num_batches = int(num_samples / num_print) + 1
+    #     batch_id = 0
+    #     for i in range(num_samples):
+    #         if i % num_print == 0:
+    #             batch_id = batch_id + 1
+    #             print(f"Converting to normal vol, batch {batch_id:,} out of {num_batches:,}")
+    #         try:
+    #             nvol.append(bachelier.implied_vol(t[i], strike[i], self.is_call, fwd[i], price[i]))
+    #         except (Exception,):
+    #             nvol.append(-9999)
+
+    #     np.seterr(divide='warn')  # Set back to warning
+
+    #     data_df['NVol'] = nvol
+    #     # data_df['BSVol'] = bsvol
+
+    #     # Remove out of range
+    #     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)
+
+    #     return data_df
+
     def target_is_call(self):
         """ True if the fit target is call options, False if puts """
         return self.is_call

{sdevpy-1.0.2 → sdevpy-1.0.3/src/sdevpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sdevpy
-Version: 1.0.2
+Version: 1.0.3
 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
@@ -18,6 +18,7 @@ Requires-Dist: numpy
 Requires-Dist: tensorflow
 Requires-Dist: scikit-learn
 Requires-Dist: tensorflow_probability
+Requires-Dist: silence_tensorflow
 
 # SDev.Python
 

{sdevpy-1.0.2 → sdevpy-1.0.3}/src/sdevpy.egg-info/requires.txt

@@ -5,3 +5,4 @@ numpy
 tensorflow
 scikit-learn
 tensorflow_probability
+silence_tensorflow

sdevpy-1.0.2/src/sdevpy/__init__.py

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

sdevpy-1.0.2/src/sdevpy/machinelearning/learningschedules.py

@@ -1,54 +0,0 @@
-""" Custom learning schedules """
-import tensorflow as tf
-import math
-from sdevpy.tools.constants import TWO_PI
-
-# Custom learning rate scheduler, exponentially decreases between given values
-class FlooredExponentialDecay(tf.keras.optimizers.schedules.LearningRateSchedule):
-    """ Custom learning rate scheduler, exponentially decreases between given values """
-    def __init__(self, initial_lr=1e-1, final_lr=1e-4, decay=0.96, decay_steps=100):
-        self.initial_lr = initial_lr
-        self.final_lr = final_lr
-        self.decay = decay
-        self.decay_steps = decay_steps
-
-    def __call__(self, step):
-        ratio = tf.cast(step / self.decay_steps, tf.float32)
-        coeff = tf.pow(self.decay, ratio)
-        return self.initial_lr * coeff + self.final_lr * (1.0 - coeff)
-
-    def get_config(self):
-        config = { 'initial_lr': self.initial_lr,
-                   'final_lr': self.final_lr,
-                   'decay': self.decay,
-                   'decay_steps': self.decay_steps }
-        return config
-
-# Custom learning rate scheduler, cyclically exponentially decreases between given values
-class CyclicalExponentialDecay(tf.keras.optimizers.schedules.LearningRateSchedule):
-    """ Custom learning rate scheduler, cyclically exponentially decreases between given values """
-    def __init__(self, initial_lr=1e-1, final_lr=1e-4, decay=0.96, decay_steps=100, period=10.0):
-        self.initial_lr = initial_lr
-        self.final_lr = final_lr
-        self.decay = decay
-        self.decay_steps = decay_steps
-        self.period = period
-
-    def __call__(self, step):
-        ratio = tf.cast(step / self.decay_steps, tf.float32)
-        coeff = tf.pow(self.decay, ratio)
-        ampl = self.initial_lr - self.final_lr
-        two_pi = tf.cast(TWO_PI, tf.float32)
-        arg = tf.cast(step / self.period, tf.float32)
-        # arg = arg * two_pi
-        ampl = ampl * (1.0 + tf.math.cos(arg * two_pi)) / 2.0
-        return self.final_lr + ampl * coeff
-        # return self.initial_lr * coeff + self.final_lr * (1.0 - coeff)
-
-    def get_config(self):
-        config = { 'initial_lr': self.initial_lr,
-                   'final_lr': self.final_lr,
-                   'decay': self.decay,
-                   'decay_steps': self.decay_steps,
-                    'period': self.period }
-        return config