sdevpy 1.0.1__tar.gz → 1.0.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sdevpy
-Version: 1.0.1
+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.1 → sdevpy-1.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdevpy"
-version = "1.0.1"
+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.1 → sdevpy-1.0.3}/src/sdevpy/machinelearning/callbacks.py

@@ -8,7 +8,7 @@ from sklearn.preprocessing import MinMaxScaler
 class SDevPyCallback(keras.callbacks.Callback):
     """ SDevPy's base class for callbacks. Compared to Keras's base, it also keeps track of 
         the learning rate and displays it at each period """
-    def __init__(self, epoch_sampling=1, optimizer=None):
+    def __init__(self, epoch_sampling=1, optimizer=None, loss_function=None, x_train=None, y_train=None):
         keras.callbacks.Callback.__init__(self)
         self.x_scaler = MinMaxScaler()
         self.y_scaler = MinMaxScaler()
@@ -22,6 +22,12 @@ class SDevPyCallback(keras.callbacks.Callback):
         self.losses = []
         self.learning_rates = []
         self.sampled_epochs = []
+        # Used to calculate the loss periodically, as in reality the loss function
+        # is used on the transformed coordinates, not, as the user might expect,
+        # on the real world ones.
+        self.loss_function = loss_function
+        self.x_train = x_train
+        self.y_train = y_train
 
     def on_train_begin(self, logs=None):
         """ Display settings, reset training variables """
@@ -46,10 +52,15 @@ class SDevPyCallback(keras.callbacks.Callback):
 
     def on_epoch_end(self, epoch, logs=None):
         self.epochs.append(epoch)
+        # if self.x_train is None and self.y_train is None:
         loss = logs['loss']
-        scale = self.y_scaler.scale_[0]
-        loss = loss * scale
+        # scale = self.y_scaler.scale_[0] # This is a trick only working in 1D
+        # loss = loss * scale
+        # else:
+        #     loss = self.estimate_loss(self.x_train, self.y_train)
+
         self.losses.append(loss)
+
         if self.optimizer is not None:
             lr = self.optimizer.learning_rate.numpy()
             self.learning_rates.append(lr)
@@ -67,6 +78,17 @@ class SDevPyCallback(keras.callbacks.Callback):
         self.x_scaler = x_scaler
         self.y_scaler = y_scaler
 
+    def estimate_loss(self, x_est, y_est):
+        """ Estimate loss on test set """
+        x_scaled = self.x_scaler.transform(x_est)
+        y_scaled = self.model.predict(x_scaled, verbose=0)
+        # y_pred = self.y_scaler.inverse_transform(y_scaled)
+        y_pred = y_scaled
+        y_est_sc = self.y_scaler.transform(y_est)
+        est_loss = self.loss_function(y_est_sc, y_pred)
+        # est_loss = rmse(y_est, y_pred) * 10000
+        return est_loss
+
     # def convergence(self):
     #     """ Retrieve sampled epochs, losses and learning rates """
     #     return self.epochs, self.losses, self.learning_rates, self.sampled_epochs
@@ -75,11 +97,11 @@ class SDevPyCallback(keras.callbacks.Callback):
 class RefCallback(SDevPyCallback):
     """ Callback class that compares model predictions vs reference periodically """
     def __init__(self, x_test, y_test, loss_function, epoch_sampling=1,
-                 optimizer=None):
-        SDevPyCallback.__init__(self, epoch_sampling, optimizer)
+                 optimizer=None, x_train=None, y_train=None):
+        SDevPyCallback.__init__(self, epoch_sampling, optimizer, loss_function, x_train, y_train)
         self.x_test = x_test
         self.y_test = y_test
-        self.loss_function = loss_function
+        # self.loss_function = loss_function
         self.test_losses = []
 
     def on_train_begin(self, logs=None):
@@ -98,14 +120,14 @@ class RefCallback(SDevPyCallback):
             self.test_losses.append(test_loss)
             print(f", Test loss: {test_loss:,.2f}", end="")
 
-    def estimate_loss(self, x_est, y_est):
-        """ Estimate loss on test set """
-        x_scaled = self.x_scaler.transform(x_est)
-        y_scaled = self.model.predict(x_scaled, verbose=0)
-        y_pred = self.y_scaler.inverse_transform(y_scaled)
-        est_loss = self.loss_function(y_est, y_pred)
-        # est_loss = rmse(y_est, y_pred) * 10000
-        return est_loss
+    # def estimate_loss(self, x_est, y_est):
+    #     """ Estimate loss on test set """
+    #     x_scaled = self.x_scaler.transform(x_est)
+    #     y_scaled = self.model.predict(x_scaled, verbose=0)
+    #     y_pred = self.y_scaler.inverse_transform(y_scaled)
+    #     est_loss = self.loss_function(y_est, y_pred)
+    #     # est_loss = rmse(y_est, y_pred) * 10000
+    #     return est_loss
 
     def test_set_loss(self):
         """ Retrieve loss on test set """

{sdevpy-1.0.1 → 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.1 → 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.1 → sdevpy-1.0.3}/src/sdevpy/maths/metrics.py

@@ -3,6 +3,13 @@ import numpy as np
 from sklearn.metrics import mean_squared_error
 import tensorflow as tf
 
+def mse(set1, set2):
+    """ Mean Squared Error """
+    return mean_squared_error(set1, set2)
+
+def rmsew(set1, set2, weights):
+    """ Root Mean Squared Error with weights """
+    return np.sqrt(mean_squared_error(set1, set2, sample_weight=weights))
 
 def rmse(set1, set2):
     """ Root Mean Squared Error """
@@ -13,6 +20,10 @@ def bps_rmse(y_true, y_ref):
     return 10000.0 * rmse(y_true, y_ref)
 
 # Tensorflow versions
+def tf_mse(y_true, y_pred):
+    """ Mean Squared Error in tensorflow """
+    return tf.math.reduce_mean(tf.square(y_true - y_pred))
+
 def tf_rmse(y_true, y_pred):
     """ Root Mean Squared Error in tensorflow """
     return tf.sqrt(tf.math.reduce_mean(tf.square(y_true - y_pred)))

sdevpy-1.0.3/src/sdevpy/maths/optimization.py

@@ -0,0 +1,158 @@
+""" Optimization """
+# https://machinelearningmastery.com/how-to-use-nelder-mead-optimization-in-python/
+# https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html
+# For DE: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.differential_evolution.html
+
+from abc import abstractmethod
+import numpy as np
+import scipy.optimize as opt
+import matplotlib.pyplot as plt
+
+
+SCIPY_OPTIMIZERS = ['Nelder-Mead', 'Powell', 'CG', 'BFGS', 'L-BFGS-B', 'TNC', 'COBYLA',
+                    'SLSQP', 'trust-constr', 'Newton-CG', 'dogleg', 'trust-ncg',
+                    'trust-exact', 'trust-krylov', 'DE']
+
+
+# Available strategies for DE
+# best1bin, best1exp, best2exp, best2bin, rand1bin, rand1exp, rand2bin, rand2exp,
+# randtobest1bin, randtobest1exp, currenttobest1bin, currenttobest1exp
+
+def create_optimizer(method, **kwargs):
+    """ Create an optimizer. Currently only supporting SciPy """
+    optimizer = None
+    if method in SCIPY_OPTIMIZERS:
+        optimizer = SciPyOptimizer(method, **kwargs)
+    else:
+        raise RuntimeError("Optimizer type not supported: " + method)
+    
+    return optimizer
+
+def create_bounds(lw_bounds, up_bounds):
+    return opt.Bounds(lw_bounds, up_bounds, keep_feasible=False)
+
+
+class Optimizer:
+    # def __init__(self):
+
+    @abstractmethod
+    def minimize(self, f, x0, args, bounds):
+        """ Minimization """
+
+
+class SciPyOptimizer(Optimizer):
+    """ Wrapper for SciPy optimizers, including differential_evolution """
+    def __init__(self, method = 'Powell', **kwargs):
+        self.method_ = method
+        self.std_minimizers = ['Nelder-Mead', 'Powell', 'CG', 'BFGS', 'L-BFGS-B', 'TNC', 'COBYLA',
+                               'SLSQP', 'trust-constr', 'Newton-CG', 'dogleg', 'trust-ncg',
+                               'trust-exact', 'trust-krylov']
+
+        self.other_minimizers = ['DE']
+
+        self.kwargs = kwargs
+        
+        if self.method_ not in self.std_minimizers and self.method_ not in self.other_minimizers:
+            raise RuntimeError("Method " + self.method_ + " not found in SciPy")
+
+    def minimize(self, f, x0=None, args=(), bounds=None):
+        result = None
+        if self.method_ in self.std_minimizers:
+            tol = self.kwargs.get('tol', None)
+            result = opt.minimize(f, x0, args, method=self.method_, bounds=bounds,
+                                  tol=tol)
+        elif self.method_== 'DE':
+            atol = self.kwargs.get('atol', 0)
+            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))
+            result = opt.differential_evolution(f, x0=x0, args=args, bounds=bounds, atol=atol,
+                                                popsize=popsize, strategy=strategy,
+                                                recombination=recombination)
+        else:
+            raise RuntimeError("Method " + self.method_ + " not recognized")
+        
+        return result
+
+class MultiOptimizer(Optimizer):
+    """ Wrapper for SciPy optimizers, including differential_evolution """
+    def __init__(self, methods = ['L-BFGS-B', 'DE'], mtol=1e-4, **kwargs):
+        self.methods_ = methods
+        self.mtol_ = mtol
+        self.kwargs = kwargs
+
+        self.optimizers_ = []
+        for method in self.methods_:
+            self.optimizers_.append(create_optimizer(method, **kwargs))
+
+    def minimize(self, f, x0=None, args=(), bounds=None):
+        result = None
+        for i, optimizer in enumerate(self.optimizers_):
+            print("Trying optimization using " + self.methods_[i] + ": ", end='')
+            result = optimizer.minimize(f, x0, args, bounds)
+            if result.fun < self.mtol_:
+                print("SUCCESS!")
+                break
+            else:
+                print("FAILURE")
+        
+        return result
+
+
+if __name__ == "__main__":
+    # Objective function
+    def f(x, *args):
+        x_ = x[0]
+        a = args[0]
+        b = args[1]
+        c = args[2]
+        prod = a * b * c
+        bi = a * b + b * c + a * c
+        sum = a + b + c
+        return 0.25 * np.power(x_, 4) - sum / 3.0 * np.power(x_, 3) + 0.5 * bi * x_**2 - prod * x_ + 1
+
+
+    # Choose method
+    method = 'Nelder-Mead'
+    # method = "Powell" # Success x^4
+    # method = "CG"
+    # method = "BFGS"
+    # method = "L-BFGS-B"
+    # method = "TNC"
+    # method = "COBYLA" # Success x^4
+    # method = "SLSQP"
+    # method = "trust-constr"
+    # method = "Newton-CG" # Requires Jacobian
+    # method = "dogleg" # Requires Jacobian
+    # method = "trust-ncg" # Requires Jacobian
+    # method = "trust-exact" # Requires Jacobian
+    # method = "trust-krylov" # Requires Jacobian
+    # method = "DE" # Success x^4
+
+    # Create the optimizer
+    optimizer = create_optimizer(method)
+
+    # Define the bounds
+    bounds = opt.Bounds([0], [4], keep_feasible=False)
+
+    # Optimize
+    result = optimizer.minimize(f, x0=[1.5], args=(1, 2, 3.2), bounds=bounds)
+
+    for key in result.keys():
+        if key in result:
+            print(key + "\n", result[key])
+
+    x = result.x
+    fun = result.fun
+    # print("Keys\n", result.keys())
+
+    # Plot
+    points = np.linspace(0, 4, 100).reshape(-1, 1)
+    y = []
+    for p in points:
+        y.append(f(p, 1, 2, 3.2))
+
+    plt.plot(points, y, color='blue', alpha=0.8, label='Objective')
+    plt.scatter(x[0], fun, color='red', alpha=1.0, label='Solution')
+    plt.show()

sdevpy-1.0.3/src/sdevpy/projects/stovolinverse/stovolinvgen.py

@@ -0,0 +1,75 @@
+""" Generate training data for Stochastic Local Vol models. We implement the inverse map here.
+    Datasets of parameters (outputs) vs prices/implied vols (inputs) are generated to later train
+    a network that learns the so-called 'inverse' calculation, i.e. parameters from prices. """
+import os
+from datetime import datetime
+from sdevpy.volsurfacegen import stovolfactory
+from sdevpy import settings
+from sdevpy.tools import filemanager
+from sdevpy.tools.timer import Stopwatch
+
+# ################ Runtime configuration ##########################################################
+MODEL_TYPE = "SABR"
+# MODEL_TYPE = "McSABR"
+# MODEL_TYPE = "FbSABR"
+# MODEL_TYPE = "McZABR"
+# MODEL_TYPE = "McHeston"
+SHIFT = 0.03
+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 = 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")
+print("> Project folder: " + project_folder)
+dataset_folder = os.path.join(project_folder, "datasets")
+print("> Data folder: " + dataset_folder)
+filemanager.check_directory(dataset_folder)
+print("> Chosen model: " + MODEL_TYPE)
+
+# ################ Select model ###################################################################
+generator = stovolfactory.set_generator(MODEL_TYPE, SHIFT, NUM_EXPIRIES, num_mc=NUM_MC,
+                                        points_per_year=POINTS_PER_YEAR, seed=SEED)
+
+# ################ 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]}
+# # 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]}
+# # ZABR
+# 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.10, 1.0], 'Rho': [-0.6, 0.6],
+#           'Gamma': [0.1, 0.9]}
+# Heston
+# RANGES = {'Ttm': [1.0 / 12.0, 35.0], 'F': [-0.009, 0.041], 'LnVol': [0.05, 0.25],
+#           'Kappa': [0.25, 4.00], 'Theta': [0.05**2, 0.25**2], 'Xi': [0.10, 0.50],
+#           'Rho': [-0.40, 0.40]}
+
+# ################ Generate dataset ###############################################################
+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, USE_NVOL)
+timer_gen.stop()
+
+timer_out = Stopwatch("File Output")
+timer_out.trigger()
+now = datetime.now()
+dt_string = now.strftime("%Y%m%d-%H_%M_%S")
+data_file = os.path.join(dataset_folder, MODEL_TYPE + "_data_" + dt_string + ".tsv")
+print("> Output to file: " + data_file)
+generator.to_file(data_df, data_file)
+timer_out.stop()
+
+# Show timers
+timer_gen.print()
+timer_out.print()