nnodely 0.14.0__py3-none-any.whl

nnodely/part.py

@@ -0,0 +1,201 @@
+import copy
+
+import torch.nn as nn
+
+from nnodely.relation import ToStream, Stream
+from nnodely.model import Model
+from nnodely.utils import check, enforce_types
+
+part_relation_name = 'Part'
+select_relation_name = 'Select'
+timepart_relation_name = 'TimePart'
+timeselect_relation_name = 'TimeSelect'
+samplepart_relation_name = 'SamplePart'
+sampleselect_relation_name = 'SampleSelect'
+
+class Part(Stream, ToStream):
+    @enforce_types
+    def __init__(self, obj:Stream, i:int, j:int):
+        # check(type(obj) is Stream, TypeError,
+        #       f"The type of {obj} is {type(obj)} and is not supported for Part operation.")
+        check(i >= 0 and j > 0 and i < obj.dim['dim'] and j <= obj.dim['dim'],
+              IndexError,
+              f"i={i} or j={j} are not in the range [0,{obj.dim['dim']}]")
+        dim = copy.deepcopy(obj.dim)
+        dim['dim'] = j - i
+        super().__init__(part_relation_name + str(Stream.count),obj.json,dim)
+        self.json['Relations'][self.name] = [part_relation_name,[obj.name],[i,j]]
+
+class Part_Layer(nn.Module):
+    @enforce_types
+    def __init__(self, i:int, j:int):
+        super(Part_Layer, self).__init__()
+        self.i, self.j = i, j
+
+    def forward(self, x):
+        assert x.ndim >= 3, 'The Part Relation Works only for 3D inputs'
+        return x[:, :, self.i:self.j]
+
+## Select elements on the third dimension in the range [i,j]
+def createPart(self, *inputs):
+    return Part_Layer(i=inputs[0][0], j=inputs[0][1])
+
+class Select(Stream, ToStream):
+
+    @enforce_types
+    def __init__(self, obj:Stream, i:int):
+        # check(type(obj) is Stream, TypeError,
+        #       f"The type of {obj} is {type(obj)} and is not supported for Select operation.")
+        check(i >= 0 and i < obj.dim['dim'],
+              IndexError,
+              f"i={i} are not in the range [0,{obj.dim['dim']}]")
+        dim = copy.deepcopy(obj.dim)
+        dim['dim'] = 1
+        super().__init__(select_relation_name + str(Stream.count),obj.json,dim)
+        self.json['Relations'][self.name] = [select_relation_name,[obj.name],i]
+
+class Select_Layer(nn.Module):
+    def __init__(self, idx):
+        super(Select_Layer, self).__init__()
+        self.idx = idx
+
+    def forward(self, x):
+        #assert x.ndim >= 3, 'The Part Relation Works only for 3D inputs'
+        return x[:, :, self.idx:self.idx + 1]
+
+## Select an element i on the third dimension
+def createSelect(self, *inputs):
+    return Select_Layer(idx=inputs[0])
+
+class SamplePart(Stream, ToStream):
+    @enforce_types
+    def __init__(self, obj:Stream, i:int, j:int, offset:int|None = None):
+        # check(type(obj) is Stream, TypeError,
+        #       f"The type of {obj} is {type(obj)} and is not supported for SamplePart operation.")
+        check('sw' in obj.dim, KeyError, 'Input must have a sample window')
+        check(i < j, ValueError, 'i must be smaller than j')
+        all_inputs = obj.json['Inputs'] | obj.json['States']
+        if obj.name in all_inputs:
+            backward_idx = all_inputs[obj.name]['sw'][0]
+            forward_idx = all_inputs[obj.name]['sw'][1]
+        else:
+            backward_idx = 0
+            forward_idx = obj.dim['sw']
+        check(i >= backward_idx and i < forward_idx, ValueError, 'i must be in the sample window of the input')
+        check(j > backward_idx and j <= forward_idx, ValueError, 'j must be in the sample window of the input')
+        dim = copy.deepcopy(obj.dim)
+        dim['sw']  = j - i
+        super().__init__(samplepart_relation_name + str(Stream.count),obj.json,dim)
+        rel = [samplepart_relation_name,[obj.name],[i,j]]
+        if offset is not None:
+            check(i <= offset < j, IndexError,"The offset must be inside the sample window")
+            rel.append(offset)
+        self.json['Relations'][self.name] = rel
+
+class SamplePart_Layer(nn.Module):
+    def __init__(self, part, offset):
+        super(SamplePart_Layer, self).__init__()
+        self.back, self.forw = part[0], part[1]
+        self.offset = offset
+
+    def forward(self, x):
+        if self.offset is not None:
+            x = x - x[:, self.offset].unsqueeze(1)
+        return x[:, self.back:self.forw]
+
+def createSamplePart(self, *inputs):
+    if len(inputs) > 1: ## offset
+        return SamplePart_Layer(part=inputs[0], offset=inputs[1])
+    else:
+        return SamplePart_Layer(part=inputs[0], offset=None)
+
+class SampleSelect(Stream, ToStream):
+
+    @enforce_types
+    def __init__(self, obj:Stream, i:int):
+        # check(type(obj) is Stream, TypeError,
+        #       f"The type of {obj} is {type(obj)} and is not supported for SampleSelect operation.")
+        check('sw' in obj.dim, KeyError, 'Input must have a sample window')
+        backward_idx = 0
+        forward_idx = obj.dim['sw']
+        check(i >= backward_idx and i < forward_idx, ValueError, 'i must be in the sample window of the input')
+        dim = copy.deepcopy(obj.dim)
+        del dim['sw']
+        super().__init__(sampleselect_relation_name + str(Stream.count),obj.json,dim)
+        self.json['Relations'][self.name] = [sampleselect_relation_name,[obj.name],i]
+
+class SampleSelect_Layer(nn.Module):
+    def __init__(self, idx):
+        super(SampleSelect_Layer, self).__init__()
+        self.idx = idx
+
+    def forward(self, x):
+        #assert x.ndim >= 2, 'The Part Relation Works only for 2D inputs'
+        return x[:, self.idx:self.idx + 1, :]
+
+def createSampleSelect(self, *inputs):
+    return SampleSelect_Layer(idx=inputs[0])
+
+class TimePart(Stream, ToStream):
+    @enforce_types
+    def __init__(self, obj:Stream, i:int|float, j:int|float, offset:int|float|None = None):
+        check(type(obj) is Stream, TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for TimePart operation.")
+        check('tw' in obj.dim, KeyError, 'Input must have a time window')
+        check(i < j, ValueError, 'i must be smaller than j')
+        all_inputs = obj.json['Inputs'] | obj.json['States']
+        if obj.name in all_inputs:
+            backward_idx = all_inputs[obj.name]['tw'][0]
+            forward_idx = all_inputs[obj.name]['tw'][1]
+        else:
+            backward_idx = 0
+            forward_idx = obj.dim['tw']
+        check(i >= backward_idx and i < forward_idx, ValueError, 'i must be in the time window of the input')
+        check(j > backward_idx and j <= forward_idx, ValueError, 'j must be in the time window of the input')
+        dim = copy.deepcopy(obj.dim)
+        dim['tw']  = j - i
+        super().__init__(timepart_relation_name + str(Stream.count),obj.json,dim)
+        rel = [timepart_relation_name,[obj.name],[i,j]]
+        if offset is not None:
+            check(i <= offset < j, IndexError,"The offset must be inside the time window")
+            rel.append(offset)
+        self.json['Relations'][self.name] = rel
+
+class TimePart_Layer(nn.Module):
+    def __init__(self, part, offset):
+        super(TimePart_Layer, self).__init__()
+        self.back, self.forw = part[0], part[1]
+        self.offset = offset
+
+    def forward(self, x):
+        if self.offset is not None:
+            x = x - x[:, self.offset].unsqueeze(1)
+        return x[:, self.back:self.forw]
+
+def createTimePart(self, *inputs):
+    if len(inputs) > 1: ## offset
+        return TimePart_Layer(part=inputs[0], offset=inputs[1])
+    else:
+        return TimePart_Layer(part=inputs[0], offset=None)
+
+class TimeSelect(Stream, ToStream):
+
+    @enforce_types
+    def __init__(self, obj:Stream, i:int|float):
+        check('tw' in obj.dim, KeyError, 'Input must have a time window')
+        backward_idx = 0
+        forward_idx = obj.dim['tw']
+        check(i >= backward_idx and i < forward_idx, ValueError, 'i must be in the time window of the input')
+        dim = copy.deepcopy(obj.dim)
+        del dim['tw']
+        super().__init__(timeselect_relation_name + str(Stream.count),obj.json,dim)
+        if (type(obj) is Stream):
+            self.json['Relations'][self.name] = [timeselect_relation_name,[obj.name],i]
+
+setattr(Model, part_relation_name, createPart)
+setattr(Model, select_relation_name, createSelect)
+
+setattr(Model, samplepart_relation_name, createSamplePart)
+setattr(Model, sampleselect_relation_name, createSampleSelect)
+
+setattr(Model, timepart_relation_name, createTimePart)

nnodely/relation.py

@@ -0,0 +1,149 @@
+import copy
+
+import numpy as np
+
+from nnodely.utils import check, merge
+
+from nnodely.logger import logging, nnLogger
+log = nnLogger(__name__, logging.CRITICAL)
+
+MAIN_JSON = {
+                'Info' : {},
+                'Inputs' : {},
+                'States' : {},
+                'Constants': {},
+                'Parameters' : {},
+                'Functions' : {},
+                'Relations': {},
+                'Outputs': {}
+            }
+
+CHECK_NAMES = True
+NeuObj_names = []
+
+def toStream(obj):
+    from nnodely.parameter import Parameter, Constant
+    if type(obj) in (int,float,list,np.ndarray):
+        obj = Constant('Constant'+str(NeuObj.count), obj)
+        #obj = Stream(obj, MAIN_JSON, {'dim': 1}) if type(obj) in (int, float) else obj
+    if type(obj) is Parameter or type(obj) is Constant:
+        obj = Stream(obj.name, obj.json, obj.dim)
+    return obj
+
+
+class NeuObj():
+    count = 0
+    @classmethod
+    def reset_count(self):
+        NeuObj.count = 0
+    def __init__(self, name = '', json = {}, dim = 0):
+        NeuObj.count += 1
+        if CHECK_NAMES == True:
+            check(name not in NeuObj_names, NameError, f"The name {name} is already used change the name of NeuObj.")
+            NeuObj_names.append(name)
+        self.name = name
+        self.dim = dim
+        if json:
+            self.json = copy.deepcopy(json)
+        else:
+            self.json = copy.deepcopy(MAIN_JSON)
+
+class Relation():
+    def __add__(self, obj):
+        from nnodely.arithmetic import Add
+        return Add(self, obj)
+
+    def __sub__(self, obj):
+        from nnodely.arithmetic import Sub
+        return Sub(self, obj)
+
+    def __truediv__(self, obj):
+        from nnodely.arithmetic import Div
+        return Div(self, obj)
+
+    def __mul__(self, obj):
+        from nnodely.arithmetic import Mul
+        return Mul(self, obj)
+
+    def __pow__(self, obj):
+        from nnodely.arithmetic import Pow
+        return Pow(self, obj)
+
+    def __neg__(self):
+        from nnodely.arithmetic import Neg
+        return Neg(self)
+
+class Stream(Relation):
+    count = 0
+    @classmethod
+    def reset_count(self):
+        Stream.count = 0
+
+    def __init__(self, name, json, dim, count = 1):
+        Stream.count += count
+        self.name = name
+        self.json = copy.deepcopy(json)
+        self.dim = dim
+
+    def tw(self, tw, offset = None):
+        from nnodely.input import State, Connect
+        from nnodely.utils import merge
+        s = State(self.name+"_state",dimensions=self.dim['dim'])
+        if type(tw) == int:
+            out_connect = Connect(self, s)
+            win_state = s.tw(tw, offset)
+            return Stream(win_state.name, merge(win_state.json, out_connect.json), win_state.dim,0 )
+
+    def sw(self, sw, offset = None):
+        from nnodely.input import State, Connect
+        from nnodely.utils import merge
+        s = State(self.name+"_state",dimensions=self.dim['dim'])
+        if type(sw) == int:
+            out_connect = Connect(self, s)
+            win_state = s.sw(sw, offset)
+            return Stream(win_state.name, merge(win_state.json, out_connect.json), win_state.dim,0 )
+
+    def z(self, delay):
+        from nnodely.input import State, Connect
+        from nnodely.utils import merge
+        s = State(self.name + "_state",dimensions=self.dim['dim'])
+        if type(delay) == int and delay > 0:
+            out_connect = Connect(self, s)
+            win_state = s.z(delay)
+            return Stream(win_state.name, merge(win_state.json, out_connect.json), win_state.dim,0 )
+
+    def connect(self, obj):
+        from nnodely.input import State
+        check(type(obj) is State, TypeError,
+              f"The {obj} must be a State and not a {type(obj)}.")
+        self.json = merge(self.json, obj.json)
+        check('closedLoop' not in self.json['States'][obj.name] or 'connect' not in self.json['States'][obj.name], KeyError,
+              f"The state variable {obj.name} is already connected.")
+        self.json['States'][obj.name]['connect'] = self.name
+        return Stream(self.name, self.json, self.dim,0 )
+
+    def closedLoop(self, obj):
+        from nnodely.input import State
+        check(type(obj) is State, TypeError,
+              f"The {obj} must be a State and not a {type(obj)}.")
+        self.json = merge(self.json, obj.json)
+        check('closedLoop' not in self.json['States'][obj.name] or 'connect' not in self.json['States'][obj.name],
+              KeyError,
+              f"The state variable {obj.name} is already connected.")
+        self.json['States'][obj.name]['closedLoop'] = self.name
+        return Stream(self.name, self.json, self.dim,0 )
+
+class ToStream():
+    def __new__(cls, *args, **kwargs):
+        out = super(ToStream,cls).__new__(cls)
+        out.__init__(*args, **kwargs)
+        return Stream(out.name,out.json,out.dim,0)
+
+class AutoToStream():
+    def __new__(cls, *args,  **kwargs):
+        if len(args) > 0 and (issubclass(type(args[0]),NeuObj) or type(args[0]) is Stream):
+            instance = super().__new__(cls)
+            instance.__init__()
+            return instance(args[0])
+        instance = super().__new__(cls)
+        return instance

nnodely/trigonometric.py

@@ -0,0 +1,67 @@
+import torch
+import torch.nn as nn
+
+from nnodely.relation import ToStream, Stream, toStream
+from nnodely.model import Model
+from nnodely.utils import check
+
+sin_relation_name = 'Sin'
+cos_relation_name = 'Cos'
+tan_relation_name = 'Tan'
+
+class Sin(Stream, ToStream):
+    def __init__(self, obj:Stream) -> Stream:
+        obj = toStream(obj)
+        check(type(obj) is Stream, TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for Sin operation.")
+        super().__init__(sin_relation_name + str(Stream.count),obj.json,obj.dim)
+        self.json['Relations'][self.name] = [sin_relation_name, [obj.name]]
+
+class Cos(Stream, ToStream):
+    def __init__(self, obj:Stream) -> Stream:
+        obj = toStream(obj)
+        check(type(obj) is Stream, TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for Cos operation.")
+        super().__init__(cos_relation_name + str(Stream.count),obj.json,obj.dim)
+        self.json['Relations'][self.name] = [cos_relation_name, [obj.name]]
+
+class Tan(Stream, ToStream):
+    def __init__(self, obj:Stream) -> Stream:
+        obj = toStream(obj)
+        check(type(obj) is Stream, TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for Tan operation.")
+        super().__init__(tan_relation_name + str(Stream.count),obj.json,obj.dim)
+        self.json['Relations'][self.name] = [tan_relation_name, [obj.name]]
+
+
+class Sin_Layer(nn.Module):
+    def __init__(self,):
+        super(Sin_Layer, self).__init__()
+    def forward(self, x):
+        return torch.sin(x)
+
+def createSin(self, *inputs):
+    return Sin_Layer()
+
+class Cos_Layer(nn.Module):
+    def __init__(self,):
+        super(Cos_Layer, self).__init__()
+    def forward(self, x):
+        return torch.cos(x)
+
+def createCos(self, *inputs):
+    return Cos_Layer()
+
+class Tan_Layer(nn.Module):
+    def __init__(self,):
+        super(Tan_Layer, self).__init__()
+    def forward(self, x):
+        return torch.tan(x)
+
+def createTan(self, *inputs):
+    return Tan_Layer()
+
+
+setattr(Model, sin_relation_name, createSin)
+setattr(Model, cos_relation_name, createCos)
+setattr(Model, tan_relation_name, createTan)

nnodely/utils.py

@@ -0,0 +1,101 @@
+import copy, torch, inspect
+
+from pprint import pformat
+from functools import wraps
+from typing import get_type_hints
+
+from nnodely.logger import logging, nnLogger
+log = nnLogger(__name__, logging.CRITICAL)
+
+def enforce_types(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        hints = get_type_hints(func)
+        all_args = kwargs.copy()
+        all_args.update(dict(zip(inspect.signature(func).parameters, args)))
+
+        for arg, arg_type in hints.items():
+            if arg in all_args and not isinstance(all_args[arg], arg_type):
+                raise TypeError(
+                    f"Expected argument '{arg}' to be of type {arg_type.__name__}, but got {type(all_args[arg]).__name__}")
+
+        return func(*args, **kwargs)
+
+    return wrapper
+
+# Linear interpolation function, operating on batches of input data and returning batches of output data
+def linear_interp(x,x_data,y_data):
+    # Inputs: 
+    # x: query point, a tensor of shape torch.Size([N, 1, 1])
+    # x_data: map of x values, sorted in ascending order, a tensor of shape torch.Size([Q, 1])
+    # y_data: map of y values, a tensor of shape torch.Size([Q, 1])
+    # Output:
+    # y: interpolated value at x, a tensor of shape torch.Size([N, 1, 1])
+
+    # Saturate x to the range of x_data
+    x = torch.min(torch.max(x,x_data[0]),x_data[-1])
+
+    # Find the index of the closest value in x_data
+    idx = torch.argmin(torch.abs(x_data[:-1] - x),dim=1)
+    
+    # Linear interpolation
+    y = y_data[idx] + (y_data[idx+1] - y_data[idx])/(x_data[idx+1] - x_data[idx])*(x - x_data[idx])
+    return y
+
+def tensor_to_list(data):
+    if isinstance(data, torch.Tensor):
+        # Converte il tensore in una lista
+        return data.tolist()
+    elif isinstance(data, dict):
+        # Ricorsione per i dizionari
+        return {key: tensor_to_list(value) for key, value in data.items()}
+    elif isinstance(data, list):
+        # Ricorsione per le liste
+        return [tensor_to_list(item) for item in data]
+    elif isinstance(data, tuple):
+        # Ricorsione per tuple
+        return tuple(tensor_to_list(item) for item in data)
+    elif isinstance(data, torch.nn.modules.container.ParameterDict):
+        # Ricorsione per parameter dict
+        return {key: tensor_to_list(value) for key, value in data.items()}
+    else:
+        # Altri tipi di dati rimangono invariati
+        return data
+
+def merge(source, destination, main = True):
+    if main:
+        log.debug("Merge Source")
+        log.debug("\n"+pformat(source))
+        log.debug("Merge Destination")
+        log.debug("\n"+pformat(destination))
+        result = copy.deepcopy(destination)
+    else:
+        result = destination
+    for key, value in source.items():
+        if isinstance(value, dict):
+            # get node or create one
+            node = result.setdefault(key, {})
+            merge(value, node, False)
+        else:
+            if key in result and type(result[key]) is list:
+                if key == 'tw' or key == 'sw':
+                    if result[key][0] > value[0]:
+                        result[key][0] = value[0]
+                    if result[key][1] < value[1]:
+                        result[key][1] = value[1]
+            else:
+                result[key] = value
+    if main == True:
+        log.debug("Merge Result")
+        log.debug("\n" + pformat(result))
+    return result
+
+def check(condition, exception, string):
+    if not condition:
+        raise exception(string)
+
+def argmax_max(iterable):
+    return max(enumerate(iterable), key=lambda x: x[1])
+
+def argmin_min(iterable):
+    return min(enumerate(iterable), key=lambda x: x[1])

nnodely/visualizer/__init__.py

@@ -0,0 +1,4 @@
+from nnodely.visualizer.visualizer import Visualizer
+from nnodely.visualizer.textvisualizer import TextVisualizer
+from nnodely.visualizer.mplvisualizer import MPLVisualizer
+from nnodely.visualizer.mplnotebookvisualizer import MPLNotebookVisualizer

nnodely/visualizer/dynamicmpl/functionplot.py

@@ -0,0 +1,34 @@
+import sys, json
+
+import matplotlib.pyplot as plt
+
+from mplplots import plots
+
+# Plot data
+line = sys.stdin.readline().strip()
+name, x, x0, x1, params, output = None, None, None, None, None, None
+data_point = {}
+input_names = []
+if line:
+    try:
+        # Convert to float and append to buffer
+        data_point = json.loads(line)
+        name = data_point['name']
+        if 'x1' in data_point.keys():
+            x0 = data_point['x0']
+            x1 = data_point['x1']
+        else:
+            x = data_point['x0']
+        params = data_point['params']
+        input_names = data_point['input_names']
+        output = data_point['output']
+
+        if 'x1' in data_point.keys():
+            plots.plot_3d_function(plt, name, x0, x1, params, output, input_names)
+        else:
+            plots.plot_2d_function(plt, name, x, params, output, input_names)
+        plt.show()
+
+    except ValueError:
+        pass
+

nnodely/visualizer/dynamicmpl/fuzzyplot.py

@@ -0,0 +1,31 @@
+import sys, json
+
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
+
+from mplplots import plots
+
+# Plot data
+line = sys.stdin.readline().strip()
+name, x, y = None, None, []
+chan_centers = []
+
+if line:
+    try:
+        # Convert to float and append to buffer
+        data_point = json.loads(line)
+        name = data_point['name']
+        x = data_point['x']
+        chan_centers = data_point['chan_centers']
+        tableau_colors = mcolors.TABLEAU_COLORS
+        num_of_colors = len(list(tableau_colors.keys()))
+        for ind, key in enumerate(data_point['y'].keys()):
+            y.append(data_point['y'][key])
+
+        fig, ax = plt.subplots()
+        ax.cla()
+        plots.plot_fuzzy(ax, name, x, y, chan_centers)
+        plt.show()
+
+    except ValueError:
+        pass

nnodely/visualizer/dynamicmpl/resultsplot.py

@@ -0,0 +1,28 @@
+import sys, json
+
+import matplotlib.pyplot as plt
+
+from mplplots import plots
+
+line = sys.stdin.readline().strip()
+key, A, B, sample_time = None, None, None, None
+name_data = None
+sample_time = None
+
+if line:
+    try:
+        # Convert to float and append to buffer
+        data_point = json.loads(line)
+        name_data = data_point['name_data']
+        key = data_point['key']
+        A = data_point['prediction_A']
+        B = data_point['prediction_B']
+        sample_time = data_point['sample_time']
+
+        fig, ax = plt.subplots()
+        ax.cla()
+        plots.plot_results(ax, name_data, key, A, B, sample_time)
+        plt.show()
+
+    except ValueError:
+        pass

nnodely/visualizer/dynamicmpl/trainingplot.py

@@ -0,0 +1,46 @@
+import sys, json
+
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from collections import deque
+
+from mplplots import plots
+
+# Buffer to hold the data points
+data_train = deque(maxlen=2000)
+data_val = deque(maxlen=2000)
+last = 1
+epoch = 0
+# Set up the plot
+fig, ax = plt.subplots()
+
+def update_graph(frame):
+    global last, title, epoch
+    if last > 0:
+        # Read data from stdin
+        line = sys.stdin.readline().strip()
+        if line:
+            try:
+                # Convert to float and append to buffer
+                data = json.loads(line)
+                data_train.append(data['train_losses'])
+                if data['val_losses']:
+                    data_val.append(data['val_losses'])
+                title = data['title']
+                key = data['key']
+                last = data['last']
+                epoch = data['epoch']
+                # Clear the current plot
+                ax.cla()
+                # Clear the current plot
+                plots.plot_training(ax, title, key, data_train, data_val, last)
+            except ValueError:
+                pass
+    else:
+        pass
+
+# Use FuncAnimation to update the plot dynamically
+ani = animation.FuncAnimation(fig, update_graph, interval=10, save_count=20)
+
+# Show the plot
+plt.show(block=True)