pybounds 0.0.12__py3-none-any.whl → 0.0.13__py3-none-any.whl

pybounds/__init__.py

@@ -10,4 +10,4 @@ from .observability import transform_states
 
 from .jacobian import SymbolicJacobian
 
-from .util import colorline
+from .util import colorline, plot_heatmap_log_timeseries

pybounds/observability.py

@@ -329,7 +329,7 @@ class SlidingEmpiricalObservabilityMatrix:
 
 
 class FisherObservability:
-    def __init__(self, O, R=None, lam=None,
+    def __init__(self, O, R=None, lam=None, force_R_scalar=False,
                  states=None, sensors=None, time_steps=None, w=None):
         """ Evaluate the observability of a state variable(s) using the Fisher Information Matrix.
 
@@ -337,12 +337,13 @@ class FisherObservability:
             w is the number of time-steps, p is the number of measurements, and n in the number of states
             can also be set as pd.DataFrame where columns set the state names & a multilevel index sets the
             measurement names: O.index names must be ('sensor', 'time_step')
-        :param None | np.array | float| dict  R: measurement noise covariance matrix (w*p x w*p)
+        :param None | np.array | float | dict  R: measurement noise covariance matrix (w*p x w*p)
             can also be set as pd.DataFrame where R.index = R.columns = O.index
             can also be a scaler where R = R * I_(nxn)
             can also be dict where keys must correspond to the 'sensor' index in O data-frame
             if None, then R = I_(nxn)
         :param float lam: lamda parameter, if lam='limit' compute F^-1 symbolically, otherwise use Chernoff inverse
+        :param bool force_R_scalar: force R to be a scalar, useful when the resulting R matrix is too big to fit in memory
         :param None | tuple | list states: list of states to use from O's. ex: ['g', 'd']
         :param None | tuple | list sensors: list of sensors to use from O's, ex: ['r']
         :param None | tuple | list | np.array time_steps: array of time steps to use from O's, ex: np.array([0, 1, 2])
@@ -394,13 +395,25 @@ class FisherObservability:
         self.pw = self.O.shape[0]  # number of sensors * time-steps
         self.n = self.O.shape[1]  # number of states
 
-        # Set measurement noise covariance matrix
-        self.R = pd.DataFrame(np.eye(self.pw), index=self.O.index, columns=self.O.index)
-        self.R_inv = pd.DataFrame(np.eye(self.pw), index=self.O.index, columns=self.O.index)
-        self.set_noise_covariance(R=R)
+        # Set measurement noise covariance matrix & calculate Fisher Information Matrix
+        if force_R_scalar and np.isscalar(R):  # scalar R
+            self.R = pd.DataFrame({'R': {'index': float(R)}})
+            self.R_inv = pd.DataFrame({'R_inv': {'index': 1 / self.R.values.squeeze()}})
+
+            # Calculate Fisher Information Matrix for scalar R
+            self.F = self.R_inv.values.squeeze() * (self.O.values.T @ self.O.values)
+
+        elif force_R_scalar and not np.isscalar(R):
+            raise Exception('R must be a scalar')
+
+        else:  # non-scalar R
+            self.R = pd.DataFrame(np.eye(self.pw), index=self.O.index, columns=self.O.index)
+            self.R_inv = pd.DataFrame(np.eye(self.pw), index=self.O.index, columns=self.O.index)
+            self.set_noise_covariance(R=R)
+
+            # Calculate Fisher Information Matrix for non-scalar R
+            self.F = self.O.values.T @ self.R_inv.values.squeeze() @ self.O.values
 
-        # Calculate Fisher Information Matrix
-        self.F = self.O.values.T @ self.R_inv.values @ self.O.values
         self.F = pd.DataFrame(self.F, index=self.O.columns, columns=self.O.columns)
 
         # Set sigma
@@ -619,8 +632,10 @@ class ObservabilityMatrixImage:
 
             # Default sensor names based on data-frame 'sensor' index
             sensor_names_all = list(np.unique(O.index.get_level_values('sensor')))
-            self.sensor_names_default = list(O.index.get_level_values('sensor')[0:len(sensor_names_all)])
-
+            self.sensors = list(O.index.get_level_values('sensor'))
+            self.time_steps = np.array(O.index.get_level_values('time_step'))
+            self.sensor_names_default = self.sensors[0:len(sensor_names_all)]
+            self.time_steps_default = np.unique(self.time_steps)
         else:  # numpy matrix
             raise TypeError('n-sensor must be an integer value when O is given as a numpy matrix')
 
@@ -650,7 +665,7 @@ class ObservabilityMatrixImage:
                 self.measurement_names = []
                 for w in range(self.n_time_step):
                     for p in range(self.n_sensor):
-                        m = '$' + self.sensor_names[p] + ',_{' + 'k=' + str(w) + '}$'
+                        m = '$' + self.sensor_names[p] + ',_{' + 'k=' + str(self.time_steps_default[w]) + '}$'
                         self.measurement_names.append(m)
 
             elif len(sensor_names) == 1:
@@ -659,7 +674,7 @@ class ObservabilityMatrixImage:
                 self.measurement_names = []
                 for w in range(self.n_time_step):
                     for p in range(self.n_sensor):
-                        m = '$' + sensor_names[0] + '_{' + str(p) + ',k=' + str(w) + '}$'
+                        m = '$' + sensor_names[0] + '_{' + str(p) + ',k=' + str(self.time_steps_default[w]) + '}$'
                         self.measurement_names.append(m)
             else:
                 raise TypeError('sensor_names must be of length p or length 1')
@@ -670,7 +685,7 @@ class ObservabilityMatrixImage:
             self.measurement_names = []
             for w in range(self.n_time_step):
                 for p in range(self.n_sensor):
-                    m = '$' + self.sensor_names[p] + '_{' + ',k=' + str(w) + '}$'
+                    m = '$' + self.sensor_names[p] + '_{' + ',k=' + str(self.time_steps_default[w]) + '}$'
                     self.measurement_names.append(m)
 
     def plot(self, vmax_percentile=100, vmin_ratio=0.0, vmax_override=None, cmap='bwr', grid=True, scale=1.0, dpi=150,

pybounds/util.py

@@ -1,4 +1,6 @@
 import numpy as np
+import scipy
+import matplotlib as mpl
 import matplotlib.pyplot as plt
 import matplotlib.collections as mcoll
 import matplotlib.patheffects as path_effects
@@ -198,3 +200,80 @@ def colorline(x, y, z, ax=None, cmap=plt.get_cmap('copper'), norm=None, linewidt
     ax.add_collection(lc)
 
     return lc
+
+def plot_heatmap_log_timeseries(data, ax=None, log_ticks=None, data_labels=None,
+                                cmap='inferno_r', y_label=None,
+                                aspect=0.25, interpolation=False):
+    """ Plot log-scale time-series as heatmap.
+    """
+
+    n_label = data.shape[1]
+
+    # Set ticks
+    if log_ticks is None:
+        log_tick_low = int(np.floor(np.log10(np.min(data))))
+        log_tick_high = int(np.ceil(np.log10(np.max(data))))
+    else:
+        log_tick_low = log_ticks[0]
+        log_tick_high = log_ticks[1]
+
+    log_ticks = np.logspace(log_tick_low, log_tick_high, log_tick_high - log_tick_low + 1)
+
+    # Set color normalization
+    cnorm = mpl.colors.LogNorm(10 ** log_tick_low, 10 ** log_tick_high)
+
+    # Set labels
+    if data_labels is None:
+        data_labels = np.arange(0, n_label).tolist()
+        data_labels = [str(x) for x in data_labels]
+
+    # Make figure/axis
+    if ax is None:
+        fig, ax = plt.subplots(1, 1, figsize=(5 * 1, 4 * 1), dpi=150)
+    else:
+        # ax = plt.gca()
+        fig = plt.gcf()
+
+    # Plot heatmap
+    if interpolation:
+        data = 10**scipy.ndimage.zoom(np.log10(data), (interpolation, 1), order=1)
+        aspect = aspect / interpolation
+
+    ax.imshow(data, norm=cnorm, aspect=aspect, cmap=cmap, interpolation='none')
+
+    # Set axis properties
+    ax.grid(True, axis='x')
+    ax.tick_params(axis='both', which='both', labelsize=6, top=False, labeltop=True, bottom=False, labelbottom=False,
+                   color='gray')
+
+    # Set x-ticks
+    LatexConverter = LatexStates()
+    data_labels_latex = LatexConverter.convert_to_latex(data_labels)
+    ax.set_xticks(np.arange(0, len(data_labels)) - 0.5)
+    ax.set_xticklabels(data_labels_latex)
+
+    # Set labels
+    ax.set_ylabel('time steps', fontsize=7, fontweight='bold')
+    ax.set_xlabel('states', fontsize=7, fontweight='bold')
+    ax.xaxis.set_label_position('top')
+
+    # Set x-ticks
+    xticks = ax.get_xticklabels()
+    for tick in xticks:
+        tick.set_ha('left')
+        tick.set_va('center')
+    #     tick.set_rotation(0)
+    #     tick.set_transform(tick.get_transform() + transforms.ScaledTranslation(6 / 72, 0, ax.figure.dpi_scale_trans))
+
+    # Colorbar
+    if y_label is None:
+        y_label = 'values'
+
+    cax = ax.inset_axes((1.03, 0.0, 0.04, 1.0))
+    cbar = fig.colorbar(mpl.cm.ScalarMappable(norm=cnorm, cmap=cmap), cax=cax, ticks=log_ticks)
+    cbar.set_label(y_label, rotation=270, fontsize=7, labelpad=8)
+    cbar.ax.tick_params(labelsize=6)
+
+    ax.spines[['bottom', 'top', 'left', 'right']].set_color('gray')
+
+    return cnorm, cmap, log_ticks

{pybounds-0.0.12.dist-info → pybounds-0.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pybounds
-Version: 0.0.12
+Version: 0.0.13
 Summary: Bounding Observability for Uncertain Nonlinear Dynamics Systems (BOUNDS)
 Home-page: https://pypi.org/project/pybounds/
 Author: Ben Cellini, Burak Boyacioglu, Floris van Breugel

pybounds-0.0.13.dist-info/RECORD

@@ -0,0 +1,10 @@
+pybounds/__init__.py,sha256=mGTxRNwJmvRhRG5M8pVX2QmPV9a6L-bP0DAAM6pAX-A,462
+pybounds/jacobian.py,sha256=hqDOwwqZMdnlTECz0Rx6txCd4VuZ4iZHPaj62PTkKvA,2057
+pybounds/observability.py,sha256=IIC-iaHIZSmKBnxcYKhn5Q18bBX9rwebz0F1twQHE0Y,33922
+pybounds/simulator.py,sha256=Qx9QGFYuuFnyuq1z5dcub5T_Lz8ISWcKLLrHup9UY0A,16702
+pybounds/util.py,sha256=_nWwDLY07Aj8UlzK-xjy-hO_8btUwqDjsiwQmNTkRug,10136
+pybounds-0.0.13.dist-info/LICENSE,sha256=kqeyRXtRGgBVZdXYeIX4zR9l2KZ2rqIBVEiPMTjxjcI,1093
+pybounds-0.0.13.dist-info/METADATA,sha256=fEdYfbP1PU3V2aKA-ce4nt-D5uWWGr3StZR0osVBgz4,2202
+pybounds-0.0.13.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+pybounds-0.0.13.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
+pybounds-0.0.13.dist-info/RECORD,,

pybounds-0.0.12.dist-info/RECORD

@@ -1,10 +0,0 @@
-pybounds/__init__.py,sha256=e4SQdDBQzqr7_x5lcQsuSoWqfBg258i7CDrhhvnmCe4,433
-pybounds/jacobian.py,sha256=hqDOwwqZMdnlTECz0Rx6txCd4VuZ4iZHPaj62PTkKvA,2057
-pybounds/observability.py,sha256=AZgUHk781C0C81aibNAaQSanbhY_0WMbmuCiHT82Onk,32926
-pybounds/simulator.py,sha256=Qx9QGFYuuFnyuq1z5dcub5T_Lz8ISWcKLLrHup9UY0A,16702
-pybounds/util.py,sha256=Gs0UgqgLXTJI9FZww90iJhqU02iJ31bXBURjGiq3YzM,7401
-pybounds-0.0.12.dist-info/LICENSE,sha256=kqeyRXtRGgBVZdXYeIX4zR9l2KZ2rqIBVEiPMTjxjcI,1093
-pybounds-0.0.12.dist-info/METADATA,sha256=9u0pmrau2uJorcTcjznL56LxkOTshpA-uQ7GNTwUqJU,2202
-pybounds-0.0.12.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-pybounds-0.0.12.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
-pybounds-0.0.12.dist-info/RECORD,,