def identify_linear(data,
n=6,
r=20,
subscan=True,
info=2,
weight=True,
optimize=True):
lin_errvec = []
linmodel = Subspace(data.sig)
#linmodel._cost_normalize = 1
if subscan:
linmodel.scan(nvec=[6],
maxr=20,
optimize=True,
weight=weight,
info=info,
bd_method=bd_method)
lin_errvec = linmodel.extract_model(data.yval, data.uval)
print(
f"Best subspace model on val data, n, r: {linmodel.n}, {linmodel.r}"
)
#linmodel.estimate(n=n, r=r, weight=weight)
#linmodel.optimize(weight=weight, info=info)
else:
linmodel.estimate(n=n, r=r, weight=weight, bd_method=bd_method)
if optimize:
linmodel.optimize(weight=weight, info=info)
return linmodel, lin_errvec
def identify_linear(data, n, r, subscan=True, info=2):
lin_errvec = []
linmodel = Subspace(data.sig)
linmodel._cost_normalize = 1
if subscan:
linmodel.scan(nvec=[2, 3, 4, 5, 6, 7, 8],
maxr=20,
optimize=True,
weight=False,
info=info)
lin_errvec = linmodel.extract_model(data.yval, data.uval)
print(f"Best subspace model, n, r: {linmodel.n}, {linmodel.r}")
#linmodel.estimate(n=n, r=r, weight=weight)
#linmodel.optimize(weight=weight, info=info)
else:
linmodel.estimate(n=n, r=r, weight=weight)
linmodel.optimize(weight=weight, info=info)
return linmodel, lin_errvec
sig.lines = lines
# plot periodicity for one realization to verify data is steady state
# sig.periodicity()
# Calculate BLA, total- and noise distortion. Used for subspace identification
sig.bla()
# average signal over periods. Used for training of PNLSS model
um, ym = sig.average()
# model orders and Subspace dimensioning parameter
nvec = [3]
maxr = 10
if 'linmodel' not in locals() or True:
linmodel = Subspace(sig)
linmodel.estimate(2, maxr, weight=weight)
linmodel.optimize(weight=weight)
print(f"Best subspace model, n, r: {linmodel.n}, {linmodel.r}")
linmodel_orig = linmodel
if False: # dont scan subspace
linmodel = Subspace(sig)
# get best model on validation data
models, infodict = linmodel.scan(nvec, maxr, weight=weight)
l_errvec = linmodel.extract_model(yval, uval)
# or estimate the subspace model directly
linmodel.estimate(
2, 5, weight=weight) # best model, when noise weighting is used
linmodel.optimize(weight=weight)
print(f"Best subspace model, n, r: {linmodel.n}, {linmodel.r}")
def identify(data, nlx, nly, nmax=25, info=2, fnsi=False):
# transient: Add one period before the start of each realization. Note that
# this is for the signal averaged over periods
Rest = data.yest.shape[2]
T1 = np.r_[data.npp * data.Ntr,
np.r_[0:(Rest - 1) * data.npp + 1:data.npp]]
linmodel = Subspace(data.sig)
linmodel._cost_normalize = 1
linmodel.estimate(2, 5, weight=weight)
linmodel.optimize(weight=weight, info=info)
# estimate NLSS
model = NLSS(linmodel)
# model._cost_normalize = 1
model.add_nl(nlx=nlx, nly=nly)
model.set_signal(data.sig)
model.transient(T1)
model.optimize(lamb=100, weight=weight, nmax=nmax, info=info)
# get best model on validation data. Change Transient settings, as there is
# only one realization
nl_errvec = model.extract_model(data.yval,
data.uval,
T1=data.npp * data.Ntr,
info=info)
models = [linmodel, model]
descrip = [type(mod).__name__ for mod in models]
if fnsi:
# FNSI can only use 1 realization
sig = deepcopy(data.sig)
# This is stupid, but unfortunately nessecary
sig.y = sig.y[:, :, 0][:, :, None]
sig.u = sig.u[:, :, 0][:, :, None]
sig.R = 1
sig.average()
fnsi1 = FNSI()
fnsi1.set_signal(sig)
fnsi1.add_nl(nlx=nlx)
fnsi1.estimate(n=2, r=5, weight=weight)
fnsi1.transient(T1)
fnsi2 = deepcopy(fnsi1)
fnsi2.optimize(lamb=100, weight=weight, nmax=nmax, info=info)
models = models + [fnsi1, fnsi2]
descrip = descrip + ['FNSI', 'FNSI optimized']
descrip = tuple(descrip) # convert to tuple for legend concatenation
# simulation error
val = np.empty((*data.yval.shape, len(models)))
est = np.empty((*data.ym.shape, len(models)))
test = np.empty((*data.ytest.shape, len(models)))
for i, model in enumerate(models):
test[..., i] = model.simulate(data.utest, T1=data.npp * data.Ntr)[1]
val[..., i] = model.simulate(data.uval, T1=data.npp * data.Ntr)[1]
est[..., i] = model.simulate(data.um, T1=T1)[1]
Pest = data.yest.shape[3]
# convenience inline functions
def stack(ydata, ymodel): return \
np.concatenate((ydata[..., None], (ydata[..., None] - ymodel)), axis=2)
def rms(y):
return np.sqrt(np.mean(y**2, axis=0))
est_err = stack(data.ym, est) # (npp*R,p,nmodels)
val_err = stack(data.yval, val)
test_err = stack(data.ytest, test)
noise = np.abs(np.sqrt(Pest * data.covY.squeeze()))
print()
print(f"err for models: signal, {descrip}")
# print(f'rms error noise:\n{rms(noise)} \ndb: \n{db(rms(noise))} ')
# only print error for p = 0. Almost equal to p = 1
print(f'rms error est (db): \n{db(rms(est_err[:,0]))}')
print(f'rms error val (db): \n{db(rms(val_err[:,0]))}')
# print(f'rms error test: \n{rms(test_err)} \ndb: \n{db(rms(test_err))}')
return Result(est_err, val_err, test_err, noise, nl_errvec, descrip)