Prognostics Model

class prog_models.PrognosticsModel(**kwargs)

A general time-variant state space model of system degradation behavior.

The PrognosticsModel class is a wrapper around a mathematical model of a system as represented by a state, output, input, event_state and threshold equations.

A Model also has a parameters structure, which contains fields for various model parameters.

Parameters

kwargs (keyword arguments, optional) –

Configuration parameters for model. Parameters supported by every model include:

  • process_noiseProcess noise (applied at dx/next_state).

    Can be scalar (e.g., .2) characteric of the process noise distribution to be applied to every state, a dictionary of values for each state (e.g., {‘x1’: 0.2, ‘x2’: 0.3}), or a function (x) -> x

    See: examples.noise for more details

  • process_noise_dist : Optional, distribution for process noise (e.g., normal, uniform, triangular)

  • measurement_noiseMeasurement noise (applied in output eqn)

    Can be number (e.g., .2) characteric of the process noise distribution applied to every output, a dictionary of values for each output (e.g., {‘z1’: 0.2, ‘z2’: 0.3}), or a function (z) -> z

    See: examples.noise for more details

  • measurement_noise_dist : Optional, distribution for measurement noise (e.g., normal, uniform, triangular)

E.g., PrognosticsModel(process_noise= 0.3, measurement_noise= {‘z1’: 0.1, ‘z2’: 0.3})

Raises

ProgModelTypeError

Example

m = PrognosticsModel({‘process_noise’: 3.2})

apply_measurement_noise(z) dict

Apply measurement noise to the measurement

Parameters

z (dict) –

output, with keys defined by model.outputs

e.g., z = {‘abc’: 332.1, ‘def’: 221.003} given outputs = [‘abc’, ‘def’]

Returns

z – output, with applied noise, with keys defined by model.outputs

e.g., z = {‘abc’: 332.2, ‘def’: 221.043} given outputs = [‘abc’, ‘def’]

Return type

dict

Example

m = PrognosticsModel() # Replace with specific model being simulated
z = {‘z1’: 2.2}
z = m.apply_measurement_noise(z)

Note

Configured using parameters measurement_noise and measurement_noise_dist

apply_process_noise(x, dt=1) dict

Apply process noise to the state

Parameters
  • x (dict) –

    state, with keys defined by model.states

    e.g., x = {‘abc’: 332.1, ‘def’: 221.003} given states = [‘abc’, ‘def’]

  • dt (Number, optional) – Time step (e.g., dt = 0.1)

Returns

x – state, with applied noise, with keys defined by model.states e.g., x = {‘abc’: 332.2, ‘def’: 221.043} given states = [‘abc’, ‘def’]

Return type

dict

Example

m = PrognosticsModel() # Replace with specific model being simulated
u = {‘u1’: 3.2}
z = {‘z1’: 2.2}
x = m.initialize(u, z) # Initialize first state
x = m.apply_process_noise(x)

Note

Configured using parameters process_noise and process_noise_dist

calc_error(times, inputs, outputs, **kwargs)

Calculate error between simulated and observed

Parameters
  • times ([double]) – array of times for each sample

  • inputs ([dict]) – array of input dictionaries where input[x] corresponds to time[x]

  • outputs ([dict]) – array of output dictionaries where output[x] corresponds to time[x]

  • kwargs

    Configuration parameters, such as:

    dt [double] : time step

Returns

Total error

Return type

double

dx(x, u)

Calculate the first derivative of state x at a specific time t, given state and input

Parameters
  • x (dict) –

    state, with keys defined by model.states

    e.g., x = {‘abc’: 332.1, ‘def’: 221.003} given states = [‘abc’, ‘def’]

  • u (dict) –

    Inputs, with keys defined by model.inputs

    e.g., u = {‘i’:3.2} given inputs = [‘i’]

Returns

dx – First derivitive of state, with keys defined by model.states

e.g., dx = {‘abc’: 3.1, ‘def’: -2.003} given states = [‘abc’, ‘def’]

Return type

dict

Example

m = DerivProgModel() # Replace with specific model being simulated
u = {‘u1’: 3.2}
z = {‘z1’: 2.2}
x = m.initialize(u, z) # Initialize first state
dx = m.dx(x, u) # Returns first derivative of state given input u

See also

next_state

Note

A model should overwrite either next_state or dx. Override dx for continuous models, and next_state for discrete, where the behavior cannot be described by the first derivative

estimate_params(runs, keys, **kwargs)

Estimate the model parameters given data. Overrides model parameters

Parameters
  • runs (array[tuple]) – data from all runs, where runs[0] is the data from run 0. Each run consists of a tuple of arrays of times, input dicts, and output dicts

  • keys ([string]) – Parameter keys to optimize

  • kwargs

    Configuration parameters. Supported parameters include:

    method: Optimization method- see scikit.optimize.minimize
    options: Options passed to optimizer

See: examples.param_est

event_state(x) dict

Calculate event states (i.e., measures of progress towards event (0-1, where 0 means event has occured))

Parameters

x (dict) –

state, with keys defined by model.states

e.g., x = {‘abc’: 332.1, ‘def’: 221.003} given states = [‘abc’, ‘def’]

Returns

event_state – Event States, with keys defined by prognostics_model.events.

e.g., event_state = {‘EOL’:0.32} given events = [‘EOL’]

Return type

dict

Example

m = PrognosticsModel() # Replace with specific model being simulated
u = {‘u1’: 3.2}
z = {‘z1’: 2.2}
x = m.initialize(u, z) # Initialize first state
event_state = m.event_state(x) # Returns {‘e1’: 0.8, ‘e2’: 0.6}

Note

Default is to return an empty array (for system models that do not include any events)

See also

threshold_met

static generate_model(keys, initialize_eqn, output_eqn, next_state_eqn=None, dx_eqn=None, event_state_eqn=None, threshold_eqn=None, config={'process_noise': 0.1})

Generate a new prognostics model from individual model functions

Parameters
  • keys (dict) – Dictionary containing keys required by model. Must include inputs, outputs, and states. Can also include events

  • initialize_eqn (callable) – Equation to initialize first state of the model. See initialize

  • output_eqn (callable) – Equation to calculate the outputs (measurements) for the model. See output

  • next_state_eqn (callable) –

    Equation to calculate next_state from current state. See next_state.

    Use this for discrete functions

  • dx_eqn (callable) –

    Equation to calculate dx from current state. See dx.

    Use this for continuous functions

  • event_state_eqn (callable, optional) – Equation to calculate the state for each event of the model. See event_state

  • threshold_eqn (callable, optional) – Equation to calculate if the threshold has been met for each event in model. See threshold_met

  • config (dict, optional) – Any configuration parameters for the model

Returns

model – A callable PrognosticsModel

Return type

PrognosticsModel

Raises

ProgModelInputException

Example

keys = {
‘inputs’: [‘u1’, ‘u2’],
‘states’: [‘x1’, ‘x2’, ‘x3’],
‘outputs’: [‘z1’],
‘events’: [‘e1’, ‘e2’]
}

m = PrognosticsModel.generate_model(keys, initialize_eqn, next_state_eqn, output_eqn, event_state_eqn, threshold_eqn)
abstract initialize(u, z) dict

Calculate initial state given inputs and outputs

Parameters
  • u (dict) –

    Inputs, with keys defined by model.inputs

    e.g., u = {‘i’:3.2} given inputs = [‘i’]

  • z (dict) –

    Outputs, with keys defined by model.outputs

    e.g., z = {‘t’:12.4, ‘v’:3.3} given inputs = [‘t’, ‘v’]

Returns

x – First state, with keys defined by model.states

e.g., x = {‘abc’: 332.1, ‘def’: 221.003} given states = [‘abc’, ‘def’]

Return type

dict

Example

m = PrognosticsModel() # Replace with specific model being simulated
u = {‘u1’: 3.2}
z = {‘z1’: 2.2}
x = m.initialize(u, z) # Initialize first state
next_state(x, u, dt) dict

State transition equation: Calculate next state

Parameters
  • x (dict) –

    state, with keys defined by model.states

    e.g., x = {‘abc’: 332.1, ‘def’: 221.003} given states = [‘abc’, ‘def’]

  • u (dict) –

    Inputs, with keys defined by model.inputs

    e.g., u = {‘i’:3.2} given inputs = [‘i’]

  • dt (number) –

    Timestep size in seconds (≥ 0)

    e.g., dt = 0.1

Returns

x – Next state, with keys defined by model.states e.g., x = {‘abc’: 332.1, ‘def’: 221.003} given states = [‘abc’, ‘def’]

Return type

dict

Example

m = PrognosticsModel() # Replace with specific model being simulated
u = {‘u1’: 3.2}
z = {‘z1’: 2.2}
x = m.initialize(u, z) # Initialize first state
x = m.next_state(x, u, 0.1) # Returns state at 3.1 seconds given input u

See also

dx

Note

A model should overwrite either next_state or dx. Override dx for continuous models, and next_state for discrete, where the behavior cannot be described by the first derivative

observables(x) dict

Calculate observables where

Parameters

x (dict) –

state, with keys defined by model.states

e.g., x = {‘abc’: 332.1, ‘def’: 221.003} given states = [‘abc’, ‘def’]

Returns

obs – Observables, with keys defined by model.observables.

e.g., obs = {‘tMax’:33, ‘iMax’:19} given observables = [‘tMax’, ‘iMax’]

Return type

dict

Example

m = PrognosticsModel() # Replace with specific model being simulated
u = {‘u1’: 3.2}
z = {‘z1’: 2.2}
x = m.initialize(u, z) # Initialize first state
obs = m.observables(3.0, x) # Returns {‘tMax’:33, ‘iMax’:19}
abstract output(x) dict

Calculate next state, forward one timestep

Parameters

x (dict) –

state, with keys defined by model.states

e.g., x = {‘abc’: 332.1, ‘def’: 221.003} given states = [‘abc’, ‘def’]

Returns

z – Outputs, with keys defined by model.outputs.

e.g., z = {‘t’:12.4, ‘v’:3.3} given outputs = [‘t’, ‘v’]

Return type

dict

Example

m = PrognosticsModel() # Replace with specific model being simulated
u = {‘u1’: 3.2}
z = {‘z1’: 2.2}
x = m.initialize(u, z) # Initialize first state
z = m.output(3.0, x) # Returns {‘o1’: 1.2}
simulate_to(time, future_loading_eqn, first_output, **kwargs) tuple

Simulate prognostics model for a given number of seconds

Parameters
  • time (number) –

    Time to which the model will be simulated in seconds (≥ 0.0)

    e.g., time = 200

  • future_loading_eqn (callable) – Function of (t) -> z used to predict future loading (output) at a given time (t)

  • options (kwargs, optional) –

    Configuration options for the simulation

    Note: configuration of the model is set through model.parameters

    Supported parameters: see simulate_to_threshold

Returns

  • times (number) – Times for each simulated point

  • inputs ([dict]) – Future input (from future_loading_eqn) for each time in times

  • states ([dict]) – Estimated states for each time in times

  • outputs ([dict]) – Estimated outputs for each time in times

  • event_states ([dict]) – Estimated event state (e.g., SOH), between 1-0 where 0 is event occurance, for each time in times

Raises

ProgModelInputException

Example

def future_load_eqn(t):
if t< 5.0: # Load is 3.0 for first 5 seconds
return 3.0
else:
return 5.0
first_output = {‘o1’: 3.2, ‘o2’: 1.2}
m = PrognosticsModel() # Replace with specific model being simulated
(times, inputs, states, outputs, event_states) = m.simulate_to(200, future_load_eqn, first_output)
simulate_to_threshold(future_loading_eqn, first_output, threshold_keys=None, **kwargs) tuple

Simulate prognostics model until any or specified threshold(s) have been met

Parameters
  • future_loading_eqn (callable) – Function of (t) -> z used to predict future loading (output) at a given time (t)

  • first_output (dict) – First measured output, needed to initialize state

  • threshold_keys ([str], optional) – Keys for events that will trigger the end of simulation. If blank, simulation will occur if any event will be met ()

  • options (keyword arguments, optional) –

    Configuration options for the simulation

    Note: configuration of the model is set through model.parameters.

    Supported parameters:

    • dt (Number0: time step (s), e.g. {‘dt’: 0.1}

    • save_freq (Number): Frequency at which output is saved (s), e.g., save_freq = 10

    • save_pts ([Number]): Additional ordered list of custom times where output is saved (s), e.g., save_pts= [50, 75]

    • horizon (Number): maximum time that the model will be simulated forward (s), e.g., horizon = 1000

    • x (dict): optional, initial state dict, e.g., x= {‘x1’: 10, ‘x2’: -5.3}

    • thresholds_met_eqn (function/lambda): optional, custom equation to indicate logic for when to stop sim f(thresholds_met) -> bool

    • print_inter (bool): optional, toggle intermediate printing, e.g., print_inter = True

    e.g., m.simulate_to_threshold(eqn, z, dt=0.1, save_pts=[1, 2])

Returns

  • times ([number]) – Times for each simulated point

  • inputs ([dict]) – Future input (from future_loading_eqn) for each time in times

  • states ([dict]) – Estimated states for each time in times

  • outputs ([dict]) – Estimated outputs for each time in times

  • event_states ([dict]) – Estimated event state (e.g., SOH), between 1-0 where 0 is event occurance, for each time in times

Raises

ProgModelInputException

See also

simulate_to

Example

def future_load_eqn(t):
if t< 5.0: # Load is 3.0 for first 5 seconds
return 3.0
else:
return 5.0
first_output = {‘o1’: 3.2, ‘o2’: 1.2}
m = PrognosticsModel() # Replace with specific model being simulated
(times, inputs, states, outputs, event_states) = m.simulate_to_threshold(future_load_eqn, first_output)
threshold_met(x) dict

For each event threshold, calculate if it has been met

Parameters

x (dict) –

state, with keys defined by model.states

e.g., x = {‘abc’: 332.1, ‘def’: 221.003} given states = [‘abc’, ‘def’]

Returns

thresholds_met – If each threshold has been met (bool), with deys defined by prognostics_model.events

e.g., thresholds_met = {‘EOL’: False} given events = [‘EOL’]

Return type

dict

Example

m = PrognosticsModel() # Replace with specific model being simulated
u = {‘u1’: 3.2}
z = {‘z1’: 2.2}
x = m.initialize(u, z) # Initialize first state
threshold_met = m.threshold_met(x) # returns {‘e1’: False, ‘e2’: False}

Note

If not overwritten, the default behavior is to say the threshold is met if the event state is <= 0

See also

event_state