sdevpy 1.0.2__tar.gz → 1.0.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sdevpy
-Version: 1.0.2
+Version: 1.0.4
 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
@@ -13,11 +13,11 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pandas
 Requires-Dist: pyperclip
-Requires-Dist: py_vollib
 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.4}/pyproject.toml

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

sdevpy-1.0.4/src/sdevpy/__init__.py

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

{sdevpy-1.0.2 → sdevpy-1.0.4}/src/sdevpy/analytics/bachelier.py

@@ -12,6 +12,21 @@ def price(expiry, strike, is_call, fwd, vol):
     return stdev * (wd * norm.cdf(wd) + norm.pdf(d))
 
 
+def price_straddles(expiries, strikes, fwd, vols):
+    expiries_ = np.asarray(expiries).reshape(-1, 1)
+    prices = []
+    for i, expiry in enumerate(expiries_):
+        k_prices = []
+        for j, k in enumerate(strikes[i]):
+            iv = vols[i, j]
+            call_price = price(expiry, k, True, fwd, iv)
+            put_price = price(expiry, k, False, fwd, iv)
+            k_prices.append(call_price[0] + put_price[0])
+        prices.append(k_prices)
+
+    return np.asarray(prices)
+
+
 def implied_vol(expiry, strike, is_call, fwd, fwd_price):
     """ P. Jaeckel's method in "Implied Normal Volatility", 6th Jun. 2017 """
     m = fwd - strike

{sdevpy-1.0.2 → sdevpy-1.0.4}/src/sdevpy/analytics/black.py

@@ -2,7 +2,8 @@
 import numpy as np
 import scipy.stats
 from scipy.optimize import minimize_scalar
-import py_vollib.black.implied_volatility as jaeckel
+# import py_vollib.black.implied_volatility as jaeckel
+from sdevpy.thirdparty.py_vollib.black import implied_volatility as jaeckel
 import tensorflow as tf
 import tensorflow_probability as tfp
 from sdevpy import settings

{sdevpy-1.0.2 → sdevpy-1.0.4}/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.4/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.4}/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.4}/src/sdevpy/maths/optimization.py

@@ -66,7 +66,7 @@ class SciPyOptimizer(Optimizer):
             popsize = self.kwargs.get('popsize', 15)
             strategy = self.kwargs.get('strategy', 'best1bin')
             recombination = self.kwargs.get('recombination', 0.7)
-            mutation = self.kwargs.get('mutation', (0.5, 1.0))
+            mutation = self.kwargs.get('mutation', (0.5, 1.0)) # ToDo: parameter not used
             result = opt.differential_evolution(f, x0=x0, args=args, bounds=bounds, atol=atol,
                                                 popsize=popsize, strategy=strategy,
                                                 recombination=recombination)
@@ -88,16 +88,20 @@ class MultiOptimizer(Optimizer):
 
     def minimize(self, f, x0=None, args=(), bounds=None):
         result = None
+        nfev = 0
         for i, optimizer in enumerate(self.optimizers_):
             print("Trying optimization using " + self.methods_[i] + ": ", end='')
             result = optimizer.minimize(f, x0, args, bounds)
+            nfev = nfev + result.nfev
             if result.fun < self.mtol_:
-                print("SUCCESS!")
+                print("Good enough!")
                 break
+            elif i < len(self.methods_) - 1:
+                print("Continuing")
             else:
-                print("FAILURE")
+                print("Stopping")
         
-        return result
+        return result, nfev
 
 
 if __name__ == "__main__":

{sdevpy-1.0.2 → sdevpy-1.0.4}/src/sdevpy/projects/stovol/stovolgen.py

@@ -10,13 +10,13 @@ from sdevpy.tools.timer import Stopwatch
 
 
 # ################ Runtime configuration ##########################################################
-# MODEL_TYPE = "SABR"
-MODEL_TYPE = "McSABR"
+MODEL_TYPE = "SABR"
+# MODEL_TYPE = "McSABR"
 # MODEL_TYPE = "FbSABR"
 # MODEL_TYPE = "McZABR"
 # MODEL_TYPE = "McHeston"
 SHIFT = 0.03
-NUM_SAMPLES = 35 * 1000
+NUM_SAMPLES = 35 * 100
 # The 4 parameters below are only relevant for models whose reference is calculated by MC
 NUM_EXPIRIES = 10
 NUM_STRIKES = 5

{sdevpy-1.0.2 → sdevpy-1.0.4}/src/sdevpy/projects/stovol/stovolplot.py

@@ -8,7 +8,8 @@ from sdevpy.tools import clipboard
 
 
 def plot_transform_surface(expiries, strikes, are_calls, fwd, ref_prices, mod_prices, title_,
-                           transform='ShiftedBlackScholes'):
+                           transform='ShiftedBlackScholes', ref_name='Reference',
+                           mod_name='Model'):
     """ Calculate quantities to display for the surface and display them in charts. Transformed
         quantities available are: Price, ShiftedBlackScholes (3%) and Bachelier (normal vols). """
     # Transform prices
@@ -27,8 +28,8 @@ def plot_transform_surface(expiries, strikes, are_calls, fwd, ref_prices, mod_pr
     for i in range(num_rows):
         for j in range(num_cols):
             k = num_cols * i + j
-            axs[i, j].plot(strikes[k], ref_disp[k], color='blue', label='Reference')
-            axs[i, j].plot(strikes[k], mod_disp[k], color='red', label='Model')
+            axs[i, j].plot(strikes[k], ref_disp[k], color='blue', label=ref_name)
+            axs[i, j].plot(strikes[k], mod_disp[k], color='red', label=mod_name)
             axs[i, j].xaxis.set_major_formatter(mtick.PercentFormatter(xmax=1, decimals=1))
             axs[i, j].yaxis.set_major_formatter(mtick.PercentFormatter(xmax=1, decimals=0))
             axs[i, j].set_xlabel('Strike')

{sdevpy-1.0.2 → sdevpy-1.0.4}/src/sdevpy/projects/stovol/stovoltrain.py

@@ -23,8 +23,8 @@ from sdevpy.projects.stovol import stovolplot as xplt
 
 
 # ################ Runtime configuration ##########################################################
-# MODEL_TYPE = "SABR"
-MODEL_TYPE = "McSABR"
+MODEL_TYPE = "SABR"
+# MODEL_TYPE = "McSABR"
 # MODEL_TYPE = "FbSABR"
 # MODEL_TYPE = "McZABR"
 # MODEL_TYPE = "McHeston"
@@ -38,9 +38,9 @@ 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 = 500 * 1000 # Number of samples to read from sample files
+NUM_SAMPLES = 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 = 100
 BATCH_SIZE = 1000
 SHOW_VOL_CHARTS = True # Show smile section charts
 # For comparison to reference values (accuracy of reference)
@@ -141,11 +141,12 @@ print(f"> Drop-out rate: {DROP_OUT:.2f}")
 # ################ Train the model ################################################################
 if TRAIN:
     # Learning rate scheduler
-    INIT_LR = 1.0e-2
+    INIT_LR = 1.0e-3
     FINAL_LR = 1.0e-4
-    DECAY = 0.97
-    STEPS = 250
-    lr_schedule = FlooredExponentialDecay(INIT_LR, FINAL_LR, DECAY, STEPS)
+    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 = FlooredExponentialDecay(INIT_LR, FINAL_LR, DECAY, STEPS)
+    lr_schedule = FlooredExponentialDecay(NUM_SAMPLES, BATCH_SIZE, TARGET_EPOCH, INIT_LR, FINAL_LR)
 
     # Optimizer
     optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

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

@@ -15,13 +15,15 @@ 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 = 8888 # [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
+NOISE = 0.01  # Relative size of noise
 
 print(">> Set up runtime configuration")
 project_folder = os.path.join(settings.WORKFOLDER, "stovolinv")
@@ -37,8 +39,13 @@ generator = stovolfactory.set_generator(MODEL_TYPE, SHIFT, NUM_EXPIRIES, num_mc=
 
 # ################ Select training ranges #########################################################
 # SABR
-RANGES = {'Ttm': [1.0 / 12.0, 35.0], 'F': [-0.009, 0.041], 'LnVol': [0.05, 0.5],
-          'Beta': [0.1, 0.9], 'Nu': [0.1, 1.0], 'Rho': [-0.6, 0.6]}
+# RANGES = {'Ttm': [1.0 / 12.0, 6.0], 'F': [0.05, 0.06], 'LnVol': [0.20, 0.40],
+#           'Beta': [0.1, 0.9], 'Nu': [0.2, 1.0], 'Rho': [-0.5, 0.2]} # 6y
+RANGES = {'Ttm': [1.0 / 12.0, 35.0], 'F': [0.05, 0.06], 'LnVol': [0.20, 0.40],
+          'Beta': [0.1, 0.9], 'Nu': [0.2, 1.0], 'Rho': [-0.5, 0.2]} #  All times
+
+# RANGES = {'Ttm': [1.0 / 12.0, 35.0], 'F': [-0.009, 0.041], 'LnVol': [0.05, 0.5],
+#           'Beta': [0.1, 0.9], 'Nu': [0.1, 1.0], 'Rho': [-0.6, 0.6]}
 # # FBSABR
 # RANGES = {'Ttm': [1.0 / 12.0, 5.0], 'F': [-0.009, 0.041], 'LnVol': [0.05, 0.5],
 #           'Beta': [0.25, 0.75], 'Nu': [0.1, 1.0], 'Rho': [-0.6, 0.6]}
@@ -57,7 +64,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, rel_noise=NOISE)
 timer_gen.stop()
 
 timer_out = Stopwatch("File Output")

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

@@ -17,25 +17,28 @@ from sdevpy.machinelearning.callbacks import RefCallback
 from sdevpy.machinelearning import datasets
 from sdevpy.tools import filemanager
 from sdevpy.tools.timer import Stopwatch
-# from sdevpy.tools import clipboard
 from sdevpy.maths.metrics import bps_rmse, tf_bps_rmse, tf_mse, mse, tf_rmse, rmse
 from sdevpy.volsurfacegen.stovolfactory import set_generator
 from sdevpy.projects.stovol import stovolplot as xplt
+from sdevpy.analytics import bachelier
 
 
 # ################ ToDo ###########################################################################
-# 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
-# market is a rho move of +10%, do the standard optimization and the network produce a set
-# of parameters that correspond to +10% in rho?
-# Then we can create a new market that corresponds to an infinitesimal move in the generating
-# SABR parameters, and see if that translates into an expected infinitesimal move in the result.
-
-# This method should allow us to calculate the sensitivity to market by AAD. That's quite an 
-# advantage, as for the regular method we can't AAD through calibration/optimization.
-
-# Compare vegas
+# At the comparison check between model and calibration, we tried adding random noise to the normal
+# vols used for comparison, on top of their values that come from a chosen SABR model. This way the
+# vols we apply the model/calibration to are not longer exactly SABR.
+# The issue was that the model was going off track very quickly with increasing size of noise.
+# Incidentally, the optimization says "FAILURE" but this is likely to be because the tolerance is
+# very small. We should try to make the tolerance larger and see how it goes.
+
+# So the idea would be to include non-SABR points in the training dataset. This could be done by the
+# same noise technique in reverse. Generate random SABR parameters, calculate the normal vols, then
+# add noise on the normal vols, then calculate prices. But then in principle we should calibrate
+# SABR to those prices again, to lear the truly optimium SABR parameters. However, isn't it possible
+# to simply consider the original SABR (before the noise) as the likely optimum? At least, we could
+# start the optimization there. It sounds likely that over a big range of data, these original SABRs
+# could overall be near-optimum enough. Which would then avoid us the trouble of going through the
+# calibration during the training.
 # ################ Module versions ################################################################
 print("TensorFlow version: " + tf.__version__)
 # print("Keras version: " + tf.keras.__version__)
@@ -50,7 +53,7 @@ MODEL_TYPE = "SABR"
 # MODEL_TYPE = "McZABR"
 # MODEL_TYPE = "McHeston"
 # MODEL_ID = "SABR_3L_64n" # For pre-trained model ID (we can pre-train several versions)
-MODEL_ID = MODEL_TYPE # For pre-trained model ID (we can pre-train several versions)
+MODEL_ID = "SABR" # MODEL_TYPE # For pre-trained model ID (we can pre-train several versions)
 SHIFT = 0.03
 USE_TRAINED = True
 DOWNLOAD_MODELS = False # Only used when USE_TRAINED is True
@@ -59,14 +62,15 @@ TRAIN = False
 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 = 1000 * 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 = 300
 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,7 +150,8 @@ else:
     print(">> Composing new model")
     # Initialize the model
     HIDDEN_LAYERS = ['softplus', 'softplus', 'softplus']
-    NUM_NEURONS = 64
+    # NUM_NEURONS = 128
+    NUM_NEURONS = 128
     DROP_OUT = 0.0
     keras_model = compose_model(input_dim, output_dim, HIDDEN_LAYERS, NUM_NEURONS, DROP_OUT)
     topology = { 'layers': HIDDEN_LAYERS, 'neurons': NUM_NEURONS, 'dropout': 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-3#1.0e-2
+    FINAL_LR = 1.0e-4#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)
 
@@ -221,15 +227,16 @@ print(f"> RMSE on test set: {test_rmse:,.2f}")
 if SHOW_VOL_CHARTS:
     print("> Choosing a sample parameter set to display chart")
     NUM_STRIKES = 100
-    PARAMS = { 'LnVol': 0.20, 'Beta': 0.5, 'Nu': 0.55, 'Rho': -0.25, 'Gamma': 0.7, 'Kappa': 1.0,
+    PARAMS = { 'LnVol': 0.30, 'Beta': 0.5, 'Nu': 0.50, 'Rho': -0.10, 'Gamma': 0.7, 'Kappa': 1.0,
                 'Theta': 0.03, 'Xi': 0.35 }
-    FWD = 0.028
+    FWD = 0.055
 
     # Any number of expiries can be calculated, but for optimum display choose no more than 6
     if MODEL_TYPE == "FbSABR":
         EXPIRIES = np.asarray([0.25, 0.50, 1.0, 2.0, 5.0, 10.0]).reshape(-1, 1) # Only trained up to 5y
     else:
         EXPIRIES = np.asarray([0.25, 0.50, 1.0, 5.0, 10.0, 30.0]).reshape(-1, 1)
+        # EXPIRIES = np.asarray([0.25, 0.50, 1.0, 2.0, 3.0, 5.0]).reshape(-1, 1)
     NUM_EXPIRIES = EXPIRIES.shape[0]
 
     # Calculate market strikes and prices on the training spreads
@@ -239,20 +246,29 @@ 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
+    rel_noise = 0.02
+    noise_thresh = 0.9
+    mkt_vols = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, PARAMS, True,
+                                             rel_noise=rel_noise, noise_thresh=noise_thresh)
+    mkt_prices = bachelier.price_straddles(EXPIRIES, mkt_strikes, FWD, mkt_vols)
+    # 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 +304,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