def _score_with_reward_function(references: np.array,
hypotheses: np.array) -> np.array:
"""Score (time, batch) arrays with sentence-based reward function.
Parts of the sentence after generated <pad> or </s> are ignored.
BPE-postprocessing is also included.
:param references: indices of references, shape (time, batch)
:param hypotheses: indices of hypotheses, shape (time, batch)
:return: an array of batch length with float rewards
"""
rewards = []
for refs, hyps in zip(references.transpose(),
hypotheses.transpose()):
ref_seq = []
hyp_seq = []
for r_token in refs:
token = self.decoder.vocabulary.index_to_word[r_token]
if token in (END_TOKEN, PAD_TOKEN):
break
ref_seq.append(token)
for h_token in hyps:
token = self.decoder.vocabulary.index_to_word[h_token]
if token in (END_TOKEN, PAD_TOKEN):
break
hyp_seq.append(token)
# join BPEs, split on " " to prepare list for evaluator
refs_tokens = " ".join(ref_seq).replace("@@ ", "").split(" ")
hyps_tokens = " ".join(hyp_seq).replace("@@ ", "").split(" ")
reward = float(self.reward_function([hyps_tokens],
[refs_tokens]))
rewards.append(reward)
return np.array(rewards, dtype=np.float32)
def update(self, y_t: np.array, y_pred: np.array):
y_t = y_t.flatten()
y_pred = y_pred.flatten()
n_obs = self.model_info.endog.shape[0]
m = self.model
# Residual Calculation
eps_t = y_t - y_pred
m.resid = np.insert(m.resid, n_obs, eps_t, axis=0)
# Add data point
self.model_info.endog = np.insert(self.model_info.endog, n_obs, y_t, axis=0)
def array2pil(a: np.array) -> Image:
if a.dtype == np.dtype("B"):
if a.ndim == 2:
return Image.frombytes("L", (a.shape[1], a.shape[0]),
a.tostring())
elif a.ndim == 3:
return Image.frombytes("RGB", (a.shape[1], a.shape[0]),
a.tostring())
else:
raise Exception("bad image rank")
elif a.dtype == np.dtype('float32'):
return Image.frombytes("F", (a.shape[1], a.shape[0]), a.tostring())
else:
raise Exception("unknown image type")
def __init__(self, A: np.array=np.zeros((3,4)), b: np.array=np.zeros(3), d: np.array=np.zeros(4)):
self.c = A.flatten()
self.shape = A.shape
self.A_eq = np.hstack([np.identity(self.shape[1])] * self.shape[0])
self.A_ub = block_diag(*[np.ones(self.shape[1])] * self.shape[0])
self.b = b
self.d = d
def __init__(self, n_input: int, n_output: int, W: nparray, b: nparray, activation: Elemwise = T.tanh):
"""
A layer of a neural network, computes s(Wx + b) where s is a nonlinearity and x is the input vector.
:parameters:
- rng: numpy random state
- n_in: input dimensionality
- n_out: output dimensionality
- W: np.array, shape=(n_in, n_out)
Optional weight matrix, if not given is initialised randomly.
- b: np.array, shape=(n_out,)
Optional bias vector, if not given is initialised randomly.
- activation : theano.tensor.elemwise.Elemwise
Activation function for layer output
"""
assert W.shape == (n_input, n_output), \
'W does not match the expected dimensionality (%d, %d) != %s' % (n_input, n_output, W.shape)
assert b.shape == (n_output,), 'b does not match the expected dimensionality (%d,) != %s' % (n_output, b.shape)
self.n_input = n_input
self.n_output = n_output
# All parameters should be shared variables.
# They're used in this class to compute the layer output,
# but are updated elsewhere when optimizing the network parameters.
# Note that we are explicitly requiring that W_init has the theano.config.floatX dtype
self.W = theano.shared(value=W.astype(theano.config.floatX),
# The name parameter is solely for printing purporses
name='W',
# Setting borrow=True allows Theano to use user memory for this object.
# It can make code slightly faster by avoiding a deep copy on construction.
# For more details, see
# http://deeplearning.net/software/theano/tutorial/aliasing.html
borrow=True)
# We can force our bias vector b to be a column vector using numpy's reshape method.
# When b is a column vector, we can pass a matrix-shaped input to the layer
# and get a matrix-shaped output, thanks to broadcasting (described below)
self.b = theano.shared(value=b.astype(theano.config.floatX),
name='b',
borrow=True)
self.activation = activation
# We'll compute the gradient of the cost of the network with respect to the parameters in this list.
self.params = [self.W, self.b]
def __init__(self, list_lagged_parameters: list,
response_array: np.array,
time_array: pd.DatetimeIndex,
use_constant: bool=True,
data_variance: np.array=None):
self.list_lagged_parameters = list_lagged_parameters.copy()
self.response_array = response_array.copy()
self.time_array = time_array.values.copy()
self.use_constant = use_constant
self.use_weights = data_variance is not None
self.num_params = len(self.list_lagged_parameters)
self.list_labels = []
self.max_shift = 0
if self.use_constant:
self.num_params += 1
self.list_labels.append('Constant')
# Find max shift, necessary to clip all data to the same size
for param in self.list_lagged_parameters:
self.list_labels.append(param.label)
if param.shift_size > self.max_shift:
self.max_shift = param.shift_size
# Clip initial points in the un-shifted response and time data
self.response_array = self.response_array[self.max_shift:]
self.time_array = self.time_array[self.max_shift:]
self.clipped_data_length = len(self.response_array)
if self.use_weights:
self.weights = 1.0 / data_variance[self.max_shift:]
self.list_lagged_arrays = []
if self.use_constant:
self.constant_array = np.ones(self.clipped_data_length)
self.list_lagged_arrays.append(self.constant_array)
# Extract clipped views of the lagged parameters
for param in self.list_lagged_parameters:
shift = self.max_shift - param.shift_size
self.list_lagged_arrays.append(param.data[shift:])
# Range of data to use in fit
self.start_index = 0
self.end_index = self.clipped_data_length - 1
self.has_results = False
self.fit_matrix = None
self.model = None
self.results = None
self.auto_correlation_matrix = None
self.time_axis = None
self.response_cut = None
def causal_rect_window_filter(data: np.array, window_length: int) -> np.array:
window_length = np.round(window_length)
if window_length > 0:
front_pad = window_length - 1
end_pad = 0
norm_window = np.repeat(1.0, window_length) / window_length
data_long = np.pad(data, ((front_pad, end_pad),), mode='edge')
# avoid fftconvolve as it distributes one input NaN to entire output
data_filtered = sps.convolve(data_long, norm_window, 'valid')
else:
data_filtered = data.copy()
return data_filtered
def causal_hann_window_filter(data: np.array, window_length: int) -> np.array:
window_length = np.round(window_length)
if window_length > 0:
front_pad = window_length
end_pad = 1
norm_window = sps.hann(window_length + 2)
norm_window /= np.sum(norm_window)
data_long = np.pad(data, ((front_pad, end_pad),), mode='edge')
# avoid fftconvolve as it distributes one input NaN to entire output
data_filtered = sps.convolve(data_long, norm_window, 'valid')
else:
data_filtered = data.copy()
return data_filtered
def __init__(self, X: np.array, Y: np.array, tune_parameters=False):
super().__init__(X, Y, tune_parameters=False)
self.X = X.todense() # TensorFlow/Skflow doesn't support sparse matrices
output_layer = len(np.unique(Y))
if tune_parameters:
self.param_dist_random = {'learning_rate': random.random(100),
'optimizer': ['Adam'],
'hidden_units': [sp_randint(50, 500), sp_randint(50, 500)]}
self.clf = skflow.TensorFlowDNNClassifier(hidden_units=self.hidden_units,
n_classes=output_layer, steps=self.steps,
learning_rate=self.learning_rate, verbose=0,
optimizer=self.optimizer)
def rect_window_filter(data: np.array, window_length: int) -> np.array:
window_length = np.round(window_length)
if window_length:
if window_length % 2 == 0: # even length window
front_pad = window_length/2
end_pad = window_length/2
norm_window = np.repeat(1.0, window_length + 1)
norm_window[0] = 0.5
norm_window[-1] = 0.5
norm_window /= window_length
else: # odd length window
front_pad = (window_length - 1)/2
end_pad = front_pad
norm_window = np.repeat(1.0, window_length) / window_length
data_long = np.pad(data, ((front_pad, end_pad),), mode='edge')
data_filtered = sps.convolve(data_long, norm_window, 'valid')
else:
data_filtered = data.copy()
return data_filtered
def __init__(self, load: np.array,
name:str='xxxxxx',
powerpool: str='UD-E_PowerPool', # ATTR_NOT_ASSIGNED not allowed
max_flex: np.array=None,
min_flex: np.array=None,
api=remote.API('127.0.0.1', '')
):
super().__init__()
self.API = api
self.name = name
self.powerpool = slugify(powerpool)
# self.API = remote.API('127.0.0.1', '')
# self.API = remote.API('ud-e-data-science.westeurope.cloudapp.azure.com', 'EnergyIsFun', port=8123, use_ssl=True)
self._load = load
self.load = load.tolist()
# self.max_flex = max_flex or (0.1 * load).tolist()
self.max_flex = max_flex or (load * np.random.rand(load.shape[0]) * 0.2).tolist()
# self.min_flex = min_flex or (np.random.uniform(0, 1) * load).tolist()
self.min_flex = min_flex or savgol_filter((load * np.random.rand(load.shape[0])), 9, 2).tolist()
self._check_powerpool()
def __init__(self, data: np.array,
label: str,
transition_length: int,
shift_size: int=0,
filter_type: str='hann'):
"""
Process data to be lagged with a smooth transition determined by the filter type and shift.
:param data: Data to be lagged.
:param label: Label for data.
:param transition_length: Number of points over which the lag transition occurs.
:param shift_size: Number of points to shift the data.
:param filter_type: Type of filter to use to generate the transition.
:raise ValueError: Error if the filter_type is not valid.
"""
self.data = data.copy()
self.label = label
self.transition_length = transition_length
self.window_size = self.transition_length + 1
self.shift_size = np.round(shift_size)
dict_filter_type_func = {'none': None,
'rect': causal_rect_window_filter,
'hann': causal_hann_window_filter
}
try:
filter_func = dict_filter_type_func[filter_type]
except KeyError:
type_str = ', '.join(dict_filter_type_func.keys())
raise ValueError(filter_type+' is not a valid type of binning. Valid types: '+type_str)
self.use_shift = self.shift_size > 0
if filter_func is not None:
self.data = filter_func(self.data, self.window_size)
if self.use_shift:
self.data = self.data[:-self.shift_size]
def convert(self, arr: np.array):
arr.uri = self.png_convertor(arr)
def bpbounds_calc_tri_z3(p: np.array):
# assuming that p is in the following order
# notation for conditional probabilities is p(y,x|z)
p = p.ravel()
p000 = p[0]
p100 = p[1]
p010 = p[2]
p110 = p[3]
p001 = p[4]
p101 = p[5]
p011 = p[6]
p111 = p[7]
p002 = p[8]
p102 = p[9]
p012 = p[10]
p112 = p[11]
# bounds on probabilities
p10low1 = p100
p10low2 = p101
p10low3 = p102
p10low4 = p100 + p110 + p101 + p011 - 1
p10low5 = p100 + p010 + p101 + p111 - 1
p10low6 = p101 + p111 + p102 + p012 - 1
p10low7 = p101 + p011 + p102 + p112 - 1
p10low8 = p102 + p112 + p100 + p010 - 1
p10low9 = p102 + p012 + p100 + p110 - 1
p10upp1 = 1 - p000
p10upp2 = 1 - p001
p10upp3 = 1 - p002
p10upp4 = p100 + p010 + p101 + p111
p10upp5 = p100 + p110 + p101 + p011
p10upp6 = p101 + p011 + p102 + p112
p10upp7 = p101 + p111 + p102 + p012
p10upp8 = p102 + p012 + p100 + p110
p10upp9 = p102 + p112 + p100 + p010
p10low = max([
p10low1, p10low2, p10low3, p10low4, p10low5, p10low6, p10low7, p10low8,
p10low9
])
p10upp = min([
p10upp1, p10upp2, p10upp3, p10upp4, p10upp5, p10upp6, p10upp7, p10upp8,
p10upp9
])
p11low1 = p110
p11low2 = p111
p11low3 = p112
p11low4 = p100 + p110 - p101 - p011
p11low5 = -p100 - p010 + p101 + p111
p11low6 = p101 + p111 - p102 - p012
p11low7 = -p101 - p011 + p102 + p112
p11low8 = p102 + p112 - p100 - p010
p11low9 = -p102 - p012 + p100 + p110
p11upp1 = 1 - p010
p11upp2 = 1 - p011
p11upp3 = 1 - p012
p11upp4 = p100 + p110 - p101 - p011 + 1
p11upp5 = -p100 - p010 + p101 + p111 + 1
p11upp6 = p101 + p111 - p102 - p012 + 1
p11upp7 = -p101 - p011 + p102 + p112 + 1
p11upp8 = p102 + p112 - p100 - p010 + 1
p11upp9 = -p102 - p012 + p100 + p110 + 1
p11low = max([
p11low1, p11low2, p11low3, p11low4, p11low5, p11low6, p11low7, p11low8,
p11low9
])
p11upp = min([
p11upp1, p11upp2, p11upp3, p11upp4, p11upp5, p11upp6, p11upp7, p11upp8,
p11upp9
])
p10lower = [
p10low1, p10low2, p10low3, p10low4, p10low5, p10low6, p10low7, p10low8,
p10low9
]
p10upper = [
p10upp1, p10upp2, p10upp3, p10upp4, p10upp5, p10upp6, p10upp7, p10upp8,
p10upp9
]
p11lower = [
p11low1, p11low2, p11low3, p11low4, p11low5, p11low6, p11low7, p11low8,
p11low9
]
p11upper = [
p11upp1, p11upp2, p11upp3, p11upp4, p11upp5, p11upp6, p11upp7, p11upp8,
p11upp9
]
retlist = {
"p10low": p10low,
"p10upp": p10upp,
"p11low": p11low,
"p11upp": p11upp,
"p10lower": p10lower,
"p10upper": p10upper,
"p11lower": p11lower,
"p11upper": p11upper
}
# bounds on causal risk ratio
rrlow = p11low / p10upp
rrupp = p11upp / p10low
retlist["crrlb"] = rrlow
retlist["crrub"] = rrupp
# monotonicity bounds
m1 = (p102 <= p101) & (p101 <= p100)
m2 = (p110 <= p111) & (p111 <= p112)
m3 = (p010 <= p011) & (p011 <= p012)
m4 = (p002 <= p001) & (p001 <= p000)
monoinequality = (m1 == True & m2 == True & m3 == True & m4 == True)
retlist["monoinequality"] = monoinequality
if monoinequality:
mlow = p112 + p000 - 1
mupp = 1 - p100 - p110
retlist["monobplb"] = mlow
retlist["monobpub"] = mupp
# bounds on intervention probabilities assuming monotonicity
monop10low = p100
monop10upp = 1 - p000
monop11low = p112
monop11upp = 1 - p012
retlist["monop10lb"] = monop10low
retlist["monop10ub"] = monop10upp
retlist["monop11lb"] = monop11low
retlist["monop11ub"] = monop11upp
# bounds on causal risk ratio assuming monotonicity
monocrrlow = monop11low / monop10upp
monocrrupp = monop11upp / monop10low
retlist["monocrrlb"] = monocrrlow
retlist["monocrrub"] = monocrrupp
else:
retlist["monobplb"] = 0
retlist["monobpub"] = 0
retlist["monop10lb"] = 0
retlist["monop10ub"] = 0
retlist["monop11lb"] = 0
retlist["monop11ub"] = 0
retlist["monocrrlb"] = 0
retlist["monocrrub"] = 0
return retlist
def rayleigh_quotient(matrix: scipy.sparse.csr_matrix,
vector: np.array) -> float:
"""Compute the Rayleigh quotient of a matrix and a vector.
"""
return matrix.dot(vector).T.dot(vector) / vector.dot(vector)
def create_matrices(
time: np.array,
offx: np.array,
offy: np.array,
dt: float,
duration: float,
t0: float,
nfft: int,
nfftime: np.array,
tt: np.array,
):
"""Returns a tuple of numpy arrays.
:param time: Time values in seconds (numpy array).
:param offx: Sample offsets (numpy array).
:param offy: Line offsets (numpy array).
:param dt: Time difference between the FROM and MATCH times (float).
:param duration: The total time duration (float).
:param t0: Zero time to start the Fourier Transform steps (float).
:param nfft: Number of divisions to use for the Fourier Transform (int).
:param nfftime: *nfft* time values starting at *t0* (numpy array).
:param tt: Fractional values in [0:1] that correspond to the nfft number
(numpy array).
:return: There are seven elements in the tuple:
0: Interpolation of *offx* at the values of *nfftime*
1: Interpolation of *offy* at the values of *nfftime*
2: Fourier transform of xinterp * (2 / *nfft*)
3: Fourier transform of yinterp * (2 / *nfft*)
4: phase difference
5: overxx: ?
6: overyy: ?
"""
t_shift = time - t0
fx = PchipInterpolator(t_shift, offx, extrapolate=False)
fy = PchipInterpolator(t_shift, offy, extrapolate=False)
xinterp = fx(nfftime - t0)
yinterp = fy(nfftime - t0)
np.nan_to_num(xinterp, copy=False, nan=np.mean(offx))
np.nan_to_num(yinterp, copy=False, nan=np.mean(offy))
# getting the frequencies of the Fourier transform
freq = np.linspace(0, nfft / 2, int(nfft / 2), endpoint=False)
# taking the fourier transform of the offsets
x = 2 * np.fft.fft(xinterp) / nfft
y = 2 * np.fft.fft(yinterp) / nfft
# separating sines and cosines
xa = x[:int(nfft / 2)].real
xb = -1 * x[:int(nfft / 2)].imag
ya = y[:int(nfft / 2)].real
yb = -1 * y[:int(nfft / 2)].imag
# calculates the phase difference
twopi = math.pi * 2
ddt_temp = (dt / duration * twopi) * freq
ddt = ddt_temp - twopi * np.floor(ddt_temp / twopi)
# the coeficients for the frequencies
with np.errstate(divide="ignore"):
aaax = (-0.5 * (-1 * xa * np.cos(ddt) + np.sin(ddt) * xb - xa) /
np.sin(ddt))
aaay = (-0.5 * (-1 * ya * np.cos(ddt) + np.sin(ddt) * yb - ya) /
np.sin(ddt))
with np.errstate(invalid="ignore"):
bbbx = -0.5 * (xb * np.cos(ddt) + np.sin(ddt) * xa + xb) / np.sin(ddt)
bbby = -0.5 * (yb * np.cos(ddt) + np.sin(ddt) * ya + yb) / np.sin(ddt)
# create series of sines and cosines
ft = freq.reshape(-1, 1) * tt.reshape(1, -1) * twopi
sn = np.sin(ft)
cn = np.cos(ft)
aaax_rep = np.repeat(aaax.reshape(-1, 1), tt.size, axis=1)
bbbx_rep = np.repeat(bbbx.reshape(-1, 1), tt.size, axis=1)
aaay_rep = np.repeat(aaay.reshape(-1, 1), tt.size, axis=1)
bbby_rep = np.repeat(bbby.reshape(-1, 1), tt.size, axis=1)
with np.errstate(invalid="ignore"):
overxx = aaax_rep * sn + bbbx_rep * cn
overyy = aaay_rep * sn + bbby_rep * cn
# Outputs
# ArrayXd & tt, ArrayXd & ET, ArrayXd & ET_shift,
# ArrayXd & ddt,
# ArrayXd & xinterp, ArrayXd & yinterp,
# ArrayXcd & X, ArrayXcd & Y, MatrixXd & overxx, MatrixXd & overyy
#
return xinterp, yinterp, x, y, ddt, overxx, overyy
def predict(self, X: np.array, threshold: float = 0.5) -> np.array:
X = np.array(X)
if X.ndim == 1:
X = X.reshape((X.shape[0], 1))
return self.predict_probs(X).round()
def encode(f: FileOut, x: np.array) -> None:
assert x.dtype == dtype, f"expected array type: {dtype}, received: {x.dtype}"
l_enc(f, x.shape)
bytesC_enc(f, x.tobytes())
def __init__(self,
stateDim: int,
actionDim: int,
actionMin: np.array,
actionMax: np.array,
learningRate=0.0005,
gamma=0.99,
GAElambda=0.95,
PPOepsilon=0.2,
PPOentropyLossWeight=0,
nHidden: int = 2,
nUnitsPerLayer: int = 128,
mode="PPO-CMA-m",
activation="lrelu",
H: int = 9,
entropyLossWeight: float = 0,
sdLowLimit=0.01,
useScaler: bool = True,
criticTimestepScale=0.001,
initialMean: np.array = None,
initialSd: np.array = None):
#Create policy network
print("Creating policy")
self.actionMin = actionMin.copy()
self.actionMax = actionMax.copy()
self.actionDim = actionDim
self.stateDim = stateDim
self.useScaler = useScaler
if useScaler:
self.scaler = Scaler(stateDim)
self.scalerInitialized = False
self.normalizeAdvantages = True
self.gamma = gamma
self.GAElambda = GAElambda
self.criticTimestepScale = 0 if gamma == 0 else criticTimestepScale #with gamma==0, no need for this
piEpsilon = None
nHistory = 1
negativeAdvantageAvoidanceSigma = 0
if mode == "PPO-CMA" or mode == "PPO-CMA-m":
usePPOLoss = False #if True, we use PPO's clipped surrogate loss function instead of the standard -A_i * log(pi(a_i | s_i))
separateVarAdapt = True
self.reluAdvantages = True if mode == "PPO-CMA" else False
nHistory = H #policy mean adapts immediately, policy covariance as an aggreagate of this many past iterations
useSigmaSoftClip = True
negativeAdvantageAvoidanceSigma = 1 if mode == "PPO-CMA-m" else 0
elif mode == "PPO":
usePPOLoss = True #if True, we use PPO's clipped surrogate loss function instead of the standard -A_i * log(pi(a_i | s_i))
separateVarAdapt = False
# separateSigmaAdapt=False
self.reluAdvantages = False
useSigmaSoftClip = True
piEpsilon = 0
elif mode == "PG":
usePPOLoss = False #if True, we use PPO's clipped surrogate loss function instead of the standard -A_i * log(pi(a_i | s_i))
separateVarAdapt = False
# separateSigmaAdapt=False
self.reluAdvantages = False
useSigmaSoftClip = True
piEpsilon = 0
elif mode == "PG-pos":
usePPOLoss = False #if True, we use PPO's clipped surrogate loss function instead of the standard -A_i * log(pi(a_i | s_i))
separateVarAdapt = False
# separateSigmaAdapt=False
self.reluAdvantages = True
useSigmaSoftClip = True
piEpsilon = 0
else:
raise ("Unknown mode {}".format(mode))
self.policy = Policy(
stateDim,
actionDim,
actionMin,
actionMax,
entropyLossWeight=PPOentropyLossWeight,
networkActivation=activation,
networkDepth=nHidden,
networkUnits=nUnitsPerLayer,
networkSkips=False,
learningRate=learningRate,
minSigma=sdLowLimit,
PPOepsilon=PPOepsilon,
usePPOLoss=usePPOLoss,
separateVarAdapt=separateVarAdapt,
nHistory=nHistory,
useSigmaSoftClip=useSigmaSoftClip,
piEpsilon=piEpsilon,
negativeAdvantageAvoidanceSigma=negativeAdvantageAvoidanceSigma)
#Create critic network, +1 stateDim because at least in OpenAI gym, episodes are time-limited and the value estimates thus depend on simulation time.
#Thus, we use time step as an additional feature for the critic.
#Note that this does not mess up generalization, as the feature is not used for the policy during training or at runtime
print("Creating critic network")
self.critic = Critic(stateDim=stateDim + 1,
learningRate=learningRate,
nHidden=nHidden,
networkUnits=nUnitsPerLayer,
networkActivation=activation,
useSkips=False,
lossType="L1")
#Experience trajectory buffers for the memorize() and updateWithMemorized() methods
self.experienceTrajectories = []
self.currentTrajectory = []
#Init may take as argument a desired initial action mean and sd. These need to be remembered for the first iteration's act,
#which samples the initial mean and sd directly instead of utilizing the policy network.
if initialMean is not None:
self.initialMean = initialMean.copy()
else:
self.initialMean = 0.5 * (self.actionMin +
self.actionMax) * np.ones(self.actionDim)
if initialSd is not None:
self.initialSd = initialSd.copy()
else:
self.initialSd = 0.5 * (self.actionMax - self.actionMin) * np.ones(
self.actionDim)
def mag(x: np.array):
return (x.dot(x))**0.5
def __top(model: np.array, n: int=1):
return [i for i in model.argsort()[-n:][::-1] if model[i] != 0.0]
def compute_logistic_gradient(y: np.array, tx: np.array, w: np.array):
pred = sigmoid(tx.dot(w))
gradient = tx.T.dot(pred - y)
return gradient
def shoulderVecFromR(R: np.array):
return R.reshape([-1, 3, 3])[:, 1].reshape(R.shape[:-1])
def convert_pixels_to_8_bits(visual_data: np.array) -> np.array:
return visual_data.astype(np.uint8)
def normalize(visual_data: np.array) -> np.array:
return 255 * ((visual_data - visual_data.min()) /
(visual_data.max() - visual_data.min()))
def write_edf(output_path: str,
raw_data: np.array,
ch_names: List[str],
sfreq: float,
events: List[Tuple[float, float, str]],
overwrite=False) -> Path:
"""
Converts BciPy raw_data to the EDF+ filetype using pyEDFlib.
Adapted from: https://github.com/holgern/pyedflib
Parameters
----------
output_path - optional path to write converted data; defaults to writing
a file named raw.edf in the raw_data_dir.
raw_data - raw data with a row for each channel
ch_names - names of the channels
sfreq - sample frequency
events - List[Tuple(onset_in_seconds: float, duration_in_seconds: float, description: str)]
overwrite - If True, the destination file (if it exists) will be overwritten.
If False (default), an error will be raised if the file exists.
Returns
-------
Path to new edf file
"""
if not overwrite and os.path.exists(output_path):
raise OSError('EDF file already exists.')
# set conversion parameters
dmin, dmax = [-32768, 32767]
pmin, pmax = [raw_data.min(), raw_data.max()]
n_channels = len(raw_data)
try:
writer = EdfWriter(str(output_path),
n_channels=n_channels,
file_type=FILETYPE_EDFPLUS)
channel_info = []
data_list = []
for i in range(n_channels):
ch_dict = {
'label': ch_names[i],
'dimension': 'uV',
'sample_rate': sfreq,
'physical_min': pmin,
'physical_max': pmax,
'digital_min': dmin,
'digital_max': dmax,
'transducer': '',
'prefilter': ''
}
channel_info.append(ch_dict)
data_list.append(raw_data[i])
writer.setSignalHeaders(channel_info)
writer.writeSamples(data_list)
if events:
for onset, duration, label in events:
writer.writeAnnotation(onset, duration, label)
except Exception as error:
logging.getLogger(__name__).info(error)
return None
finally:
writer.close()
return output_path
def _transform_response(response: np.array) -> json:
return json.dumps({"outputs": response.tolist()[0]})
def query_by_embedding(
self,
query_emb: np.array,
filters: Optional[Dict[str, List[str]]] = None,
top_k: int = 10,
index: Optional[str] = None,
return_embedding: Optional[bool] = None) -> List[Document]:
if index is None:
index = self.index
return_embedding = return_embedding or self.return_embedding
if not self.embedding_field:
raise RuntimeError(
"Please specify arg `embedding_field` in ElasticsearchDocumentStore()"
)
else:
# +1 in similarity to avoid negative numbers (for cosine sim)
body = {
"size": top_k,
"query": {
"script_score": {
"query": {
"match_all": {}
},
"script": {
# offset score to ensure a positive range as required by Elasticsearch
"source":
f"{self.similarity_fn_name}(params.query_vector,'{self.embedding_field}') + 1000",
"params": {
"query_vector": query_emb.tolist()
}
}
}
}
} # type: Dict[str,Any]
if filters:
for key, values in filters.items():
if type(values) != list:
raise ValueError(
f'Wrong filter format for key "{key}": Please provide a list of allowed values for each key. '
'Example: {"name": ["some", "more"], "category": ["only_one"]} '
)
body["query"]["script_score"]["query"] = {"terms": filters}
excluded_meta_data: Optional[list] = None
if self.excluded_meta_data:
excluded_meta_data = deepcopy(self.excluded_meta_data)
if return_embedding is True and self.embedding_field in excluded_meta_data:
excluded_meta_data.remove(self.embedding_field)
elif return_embedding is False and self.embedding_field not in excluded_meta_data:
excluded_meta_data.append(self.embedding_field)
elif return_embedding is False:
excluded_meta_data = [self.embedding_field]
if excluded_meta_data:
body["_source"] = {"excludes": excluded_meta_data}
logger.debug(f"Retriever query: {body}")
result = self.client.search(index=index,
body=body,
request_timeout=300)["hits"]["hits"]
documents = [
self._convert_es_hit_to_document(
hit, adapt_score_for_embedding=True) for hit in result
]
return documents
def Forward(self, data: np.array):
return np.fft.fftn(data.astype(complex))
def hypothesis(self, X: np.array) -> float:
if X.ndim == 0:
X = X.reshape([1,1])
return self.theta[0] + np.matmul(X, self.theta[1:])
def print_data_statistics(x_train: np.array, x_val: np.array,
x_test: np.array, y_train: np.array,
y_val: np.array) -> None:
"""
"""
Total_data_num = len(x_train) + len(x_val) + len(x_test)
print("\n________Table : Data portions info_________")
t = Texttable()
t.add_rows([['Data Portion', 'Number', 'Percent'],
['Total', Total_data_num, "{:.0%}".format(1)],
[
'Train data',
len(x_train),
"{:.2%}".format(len(x_train) / Total_data_num)
],
[
'val data',
len(x_val),
"{:.2%}".format(len(x_val) / Total_data_num)
],
[
'Test data',
len(x_test),
"{:.2%}".format(len(x_test) / Total_data_num)
]])
print(t.draw())
print("//////////////////////////////////////////////////\n")
print(
"_______________________Table : Data shape info________________________"
)
t = Texttable()
t.add_rows([['Name', 'Shape', 'Min', 'Max', 'Type'],
[
'x train', x_train.shape,
x_train.min(),
x_train.max(),
type(x_train)
],
[
'y train', y_train.shape,
y_train.min(),
y_train.max(),
type(y_train)
],
[
'x validation', x_val.shape,
x_val.min(),
x_val.max(),
type(x_val)
],
[
'y validation', y_val.shape,
y_val.min(),
y_val.max(),
type(y_val)
],
[
'x test', x_test.shape,
x_test.min(),
x_test.max(),
type(x_test)
]])
print(t.draw())
print("//////////////////////////////////////////////////\n")
def HMC_ensemble_run(model: keras.models.Model,
x_train: np.array,
y_train: np.array,
N_mc: int,
ep: float,
tau: int,
burn_in: int,
sample_every: int,
return_extra=False,
verbose=True,
verbose_n = 100,
):
"""
Takes a keras model and a dataset (x_train, y_train) and returns a list of numpy
arrays to be used as weights for an ensemble predictor.
"""
step_size = ep
n_steps = tau
Ws = model.weights
lossfn = model.loss #this is kinda cheeky
X = model.input
Y_ = model.output
Y = K.placeholder(shape=Y_.shape)
L = K.sum(lossfn(Y, Y_)) #the sum accross the batch
Gs = K.gradients(L, Ws)
eval_loss_and_grads = K.function([X,Y], [L] + Gs)
def get_loss_and_grads(x, y):
res = eval_loss_and_grads([x, y])
return res[0], res[1:]
losses = []
i = 0
weights = []
ensemble = []
accept_n = 0
ep_lo = 0.8 * step_size
ep_hi = 1.2 * step_size
tau_lo = int(0.5 * n_steps)
tau_hi = int(1.5 * n_steps)
obj = 0
while len(ensemble) < N_mc:
ep = ep_lo + (ep_hi - ep_lo) * np.random.random()
tau = np.random.randint(tau_lo, high=tau_hi)
obj, gs = get_loss_and_grads(x_train, y_train)
losses.append(obj)
if verbose and i % verbose_n == 0:
acc = np.mean(model.predict(x_train).argmax(axis=1) == y_train.argmax(axis=1))
accept_ratio = accept_n / i if i > 0 else 0
print("iter: ", i, 'accuracy :', acc, 'loss: ', obj, 'accept_ratio: ', accept_ratio)
i += 1
ps = [np.random.normal(size=w.shape) for w in Ws] # momentum variables
H = .5 * sum([np.sum(p ** 2) for p in ps]) + obj
ws = [K.eval(w) for w in Ws]
weights.append(ws)
ws_old = [K.eval(w) for w in Ws]
# store the values of the weights in case we need to go back
for t in range(tau):
for p, g in zip(ps, gs):
p -= .5 * ep * g
for w, p in zip(ws, ps):
w += ep * p
# evaluate new weights
for (weight, value) in zip(Ws, ws):
K.set_value(weight, value)
obj, gs = get_loss_and_grads(x_train, y_train)
for p, g in zip(ps, gs):
p -= .5 * ep * g
H_new = .5 * sum([np.sum(p ** 2) for p in ps]) + obj
dH = H_new - H
if (dH < 0) or np.random.rand() < np.exp(-dH):
# in this case, we acccept the new values
accept_n += 1
pass
else:
# reverse the step
for weight, value in zip(Ws, ws_old):
K.set_value(weight, value)
if i > burn_in and i % sample_every == 0:
ensemble.append([K.eval(w) for w in Ws])
if return_extra:
weights = np.array(weights)
return ensemble, losses, weights, accept_n / i
else:
return ensemble
def value_iteration(env: EnvWithModel, initV: np.array,
theta: float) -> Tuple[np.array, Policy]:
"""
inp:
env: environment with model information, i.e. you know transition dynamics and reward function
initV: initial V(s); numpy array shape of [nS,]
theta: exit criteria
return:
value: optimal value function; numpy array shape of [nS]
policy: optimal deterministic policy; instance of Policy class
"""
class PiStar(Policy):
def __init__(self, optActionProb, optPolicy):
self.optActionProb = optActionProb
self.optPolicy = optPolicy
def action_prob(self, state, action):
return self.optActionProb[state, action]
def action(self, state):
return self.optPolicy[state]
V = initV.copy()
# print('initV: \n',initV.reshape((4,4)))
# print('V: \n',V.reshape((4,4)))
delta = theta
i = 0
while delta >= theta:
i += 1
delta = 0
for s in range(env.spec.nS):
v = V[s]
update = np.zeros(env.spec.nA)
for a in range(env.spec.nA):
update[a] = np.sum(env.TD[s, a, :] *
(env.R[s, a, :] + env.spec.gamma * V))
V[s] = update.max()
delta = max(delta, np.abs(v - V[s]))
# print('V: \n',V.reshape((4,4)))
# print('V: \n',V)
# print('Delta:',delta)
# print('iterations: ',i)
Q = np.zeros((env.spec.nS, env.spec.nA))
optActionProb = np.zeros((env.spec.nS, env.spec.nA))
optPolicy = np.zeros((env.spec.nS))
for s in range(env.spec.nS):
for a in range(env.spec.nA):
Q[s, a] = np.sum(env.TD[s, a, :] *
(env.R[s, a, :] + env.spec.gamma * V))
aStar = np.argmax(Q[s, :])
optActionProb[s, aStar] = 1
optPolicy[s] = aStar
# print('Q: \n',Q.reshape((4,16)))
# print('Q: \n',Q)
pi = PiStar(optActionProb, optPolicy)
#####################
# TODO: Implement Value Iteration Algorithm (Hint: Sutton Book p.83)
#####################
return V, pi
def allocate(self, mu: np.array, cov: np.array) -> np.array:
"""
Perform the NCO method described in section 4.3 of "A Robust Estimator of the Efficient Frontier"
Excerpt from section 4.3:
The NCO method estimates 𝜔̂∗ while controlling for the signal-induced estimation errors
explained in section 3.2. NCO works as follows:
First, we cluster the covariance matrix into subsets of highly-correlated variables.
One possible clustering algorithm is the partitioning method discussed in López de Prado and Lewis [2019],
but hierarchical methods may also be applied. The result is a partition of the original set,
that is, a collection of mutually disjoint nonempty subsets of variables.
Second, we compute optimal allocations for each of these clusters separately.
This allows us to collapse the original covariance matrix into a reduced covariance matrix,
where each cluster is represented as a single variable. The collapsed correlation matrix is
closer to an identity matrix than the original correlation matrix was, and therefore more
amenable to optimization problems (recall the discussion in section 3.2).
Third, we compute the optimal allocations across the reduced covariance matrix.
Fourth,
the final allocations are the dot-product of the intra-cluster allocations and the inter-cluster allocations.
By splitting the problem into two separate tasks, NCO contains the instability within each cluster:
the instability caused by intra-cluster noise does not propagate across clusters.
See López de Prado [2019] for examples, code and additional details regarding NCO.
:param cov: Covariance matrix
:param mu: Expected return vector
:return: Min variance portfolio if mu is None, max sharpe ratio portfolio if mu is not None
"""
cov = pd.DataFrame(cov)
if mu is not None:
mu = pd.Series(mu.flatten())
assert mu.size == cov.shape[0], 'mu and cov dimension must be the same size'
# get correlation matrix
corr = cov_to_corr(cov)
# find the optimal partition of clusters
clusters = self._cluster_k_means_base(corr)
# calculate intra-cluster allocations by finding the optimal portfolio for each cluster
intra_cluster_allocations = pd.DataFrame(0, index=cov.index, columns=clusters.keys())
for cluster_id, cluster in clusters.items():
cov_ = cov.loc[cluster, cluster].values
mu_ = mu.loc[cluster].values.reshape(-1, 1) if mu is not None else None
intra_cluster_allocations.loc[cluster, cluster_id] = self._get_optimal_portfolio(cov_, mu_)
# reduce covariance matrix
cov = intra_cluster_allocations.T.dot(np.dot(cov, intra_cluster_allocations))
mu = intra_cluster_allocations.T.dot(mu) if mu is not None else None
# calculate inter_cluster allocations on reduced covariance matrix
inter_cluster_allocations = pd.Series(self._get_optimal_portfolio(cov, mu), index=cov.index)
# final allocations are the dot-product of the intra-cluster allocations and the inter-cluster allocations
return intra_cluster_allocations \
.mul(inter_cluster_allocations, axis=1) \
.sum(axis=1).values \
.reshape(-1, 1) \
.flatten()
def model_inference_helper(x_0: np.array, x_1: np.array, time_step: float):
""" Input: x_0, x_1; Output: y_0 """
x_0 = torch.from_numpy(x_0).type(args.dtype)
x_1 = torch.from_numpy(x_1).type(args.dtype)
y_0 = torch.FloatTensor()
intWidth = x_0.size(2)
intHeight = x_0.size(1)
channel = x_0.size(0)
assert channel == 3, "input frame's channel is not equal to 3."
if intWidth != ((intWidth >> 7) << 7):
intWidth_pad = ((intWidth >> 7) + 1) << 7 # more than necessary
intPaddingLeft = int((intWidth_pad - intWidth) / 2)
intPaddingRight = intWidth_pad - intWidth - intPaddingLeft
else:
intWidth_pad = intWidth
intPaddingLeft = 32
intPaddingRight = 32
if intHeight != ((intHeight >> 7) << 7):
intHeight_pad = ((intHeight >> 7) + 1) << 7 # more than necessary
intPaddingTop = int((intHeight_pad - intHeight) / 2)
intPaddingBottom = intHeight_pad - intHeight - intPaddingTop
else:
intHeight_pad = intHeight
intPaddingTop = 32
intPaddingBottom = 32
# torch.set_grad_enabled(False)
x_0 = Variable(torch.unsqueeze(x_0, 0))
x_1 = Variable(torch.unsqueeze(x_1, 0))
x_0 = torch.nn.ReplicationPad2d(
[intPaddingLeft, intPaddingRight, intPaddingTop,
intPaddingBottom])(x_0)
x_1 = torch.nn.ReplicationPad2d(
[intPaddingLeft, intPaddingRight, intPaddingTop,
intPaddingBottom])(x_1)
# if use_cuda:
x_0 = x_0.cuda()
x_1 = x_1.cuda()
# y_s, offset, filter = model(torch.stack((X0, X1), dim=0))
if time_step == 0.5:
y_s, _, _ = model_05(torch.stack((x_0, x_1), dim=0))
if time_step == 0.33:
y_s, _, _ = model_033(torch.stack((x_0, x_1), dim=0))
if time_step == 0.25:
y_s, _, _ = model_025(torch.stack((x_0, x_1), dim=0))
else:
y_s, _, _ = model_020(torch.stack((x_0, x_1), dim=0))
y_0 = y_s[args.save_which]
torch.cuda.empty_cache()
if not isinstance(y_0, list):
y_0 = y_0.data.cpu().numpy()
else:
y_0 = [item.data.cpu().numpy() for item in y_0]
y_0 = [
np.transpose(
255.0 *
item.clip(0, 1.0)[0, :, intPaddingTop:intPaddingTop + intHeight,
intPaddingLeft:intPaddingLeft + intWidth, ],
(1, 2, 0),
) for item in y_0
]
return y_0
def identity_copy(x: _np.array) -> _np.array:
return x.copy()
def online_qp(velqp: VelQP,
v_ini: float,
kappa: np.ndarray,
delta_s: np.ndarray,
P_max: np.array = None,
ax_max: np.array = None,
ay_max: np.array = None,
x0_v: np.ndarray = None,
v_max: np.ndarray = None,
v_end: float = None,
F_ini: float = None,
s_glob: float = None,
v_max_cstr: np.ndarray = None) -> tuple:
"""
Python version: 3.5
Created by: Thomas Herrmann ([email protected])
Created on: 01.11.2019
Documentation: Creates an SQP that optimizes a velocity profile for a given path.
Inputs:
velqp: QP solver object used within the SQP
v_ini: initial velocity hard constraint [m/s]
kappa: kappa profile of given path [rad/m]
delta_s: discretization step length [m]
P_max: max. allowed power [kW]
ax_max: max. allowed longitudinal acceleration [m/s^2]
ay_max: max. allowed ongitudial acceleration [m/s^2]
x0_v: initial guess of optimal velocity [m/s]
v_max: max. should velocity (objective function) [m/s]
v_end: constrained end velocity in optimization horizon [m/s]
F_ini: initial force constraint [kN]
s_glob: global s coordinate of current vehicle position [m]
v_max_cstr: max. must velocity (hard constraint) [m/s]
Outputs:
v_op: optimized velocity using OSQP as QP solver [m/s]
s_t_op: optimized slack values [-]
qp_status: status of last QP within SQP [-]
"""
# --- Steplength reduction parameter for Armijo rule
beta = 2 / 4
# --- Initialization of logging variables
x0_v_log = None
x0_s_t_log = None
kappa_log = None
delta_s_log = None
ax_max_log = None
ay_max_log = None
v_ini_log = None
v_max_log = None
v_end_log = None
F_ini_log = None
####################################################################################################################
# --- Preparing input parameters for SQP
####################################################################################################################
# --- Emergency SQP
# upper bound for last velocity entry depending on current velocity
if velqp.sid == 'EmergSQP':
# --- Upper bound for last velocity point
v_end = 0.4
v_max = np.array(
[v_ini - (x + 1) * 4 for x in range(velqp.sqp_stgs['m'])])
# set all values below threshold to threshold
v_max[v_max < 0.0] = 0.0
# --- Assume linear velocity decrease to v_end from current velocity
x0_v = np.array([
v_ini + x * (v_max[-1] - v_ini) / velqp.sqp_stgs['m']
for x in range(velqp.sqp_stgs['m'])
])
# Initialize slack variables with zero values
x0_s_t = np.array([0] * velqp.n)
# Overwrite None
F_ini = 0
s_glob = 0
# --- /Emergency SQP
# --- Performance SQP
else:
x0_s_t = np.array([0] * velqp.n)
# --- /Performance SQP
# --- Make sure to always have a numeric velocity > 0.1
if v_ini < velqp.sym_sc_['vmin_mps_']:
v_ini = velqp.sym_sc_['vmin_mps_']
x0_v[0] = v_ini
# --- Initialization of optimization variables
# velocity [m/s]
v_op = np.zeros(velqp.sqp_stgs['m'], )
# slack variable on tires
s_t_op = np.zeros(velqp.n, )
qp_iter = 0
qp_status = 0
# SQP mean-error
err = np.inf
# SQP infinity-error
err_inf = np.inf
# SQP-counter
n_sqp = 0
# SQP-timer
dt = 0
# time limit of SQP loop [s]
dt_lim = velqp.sqp_stgs['t_sqp_max']
# --- Save inputs to SQP here for logging purpose
x0_v_log = copy.deepcopy(x0_v.tolist())
x0_s_t_log = copy.deepcopy(x0_s_t.tolist())
kappa_log = kappa.tolist()
delta_s_log = delta_s.tolist()
v_ini_log = v_ini
try:
v_max_log = copy.deepcopy(v_max.tolist())
except AttributeError:
v_max_log = copy.deepcopy(v_max)
v_end_log = v_end
F_ini_log = F_ini
if isinstance(ax_max, np.ndarray) and isinstance(ay_max, np.ndarray):
ax_max_log = ax_max.tolist()
ay_max_log = ay_max.tolist()
else:
ax_max_log = velqp.sym_sc_['axmax_mps2_']
ay_max_log = velqp.sym_sc_['aymax_mps2_']
if isinstance(P_max, np.ndarray):
Pmax_log = P_max.tolist()
else:
Pmax_log = velqp.sym_sc_['Pmax_kW_']
# --- Start SQP-loop
t_start = time.time()
while (err > velqp.err or err_inf > velqp.err_inf
) and n_sqp < velqp.sqp_stgs['n_sqp_max'] and dt < dt_lim:
# --- Update parameters of QP
if len(x0_v) is not int(velqp.sqp_stgs['m']):
print("Error in x0-length in ", velqp.sid)
print(x0_v)
if len(v_max) is not int(velqp.sqp_stgs['m']):
print("Error in v_max-length in ", velqp.sid)
print(v_max)
# --- Update QP matrices
velqp.osqp_update_online(x0_v=x0_v,
x0_s_t=x0_s_t,
v_ini=v_ini,
v_max=v_max,
v_end=v_end,
F_ini=F_ini,
kappa=kappa,
delta_s=delta_s,
P_max=P_max,
ax_max=ax_max,
ay_max=ay_max,
vmax_cstr=v_max_cstr)
# --- Solve the QP
sol, qp_iter, qp_status = velqp.osqp_solve()
# --- Check primal infeasibility of problem and return v = 0
if qp_status == -3:
break
# --- Store solution from previous SQP-iteration
o_old = np.append(v_op, x0_s_t)
# --- Store errors from previous SQP-iteration
err_old = err
err_inf_old = err_inf
try:
############################################################################################################
# --- Armijo: decrease steplength alpha if SQP-error increases between iterations
############################################################################################################
k = 0 # counter for Armijo-loop
while True:
# --- Choose a steplength
alpha = beta**k # steplength e {1, beta, beta^2, ...}
# --- Restructure solution from QP-solution
# Add leading "0" as ini-velocity must be kept constant as given
v_op = alpha * np.insert(sol[0:velqp.m - 1], 0, 0) + x0_v
s_t_op = alpha * sol[velqp.m - 1:] + x0_s_t
# --- Calculate SQP iteration error
o = np.append(v_op, s_t_op)
err = np.sqrt(np.matmul(o - o_old, o - o_old)) / o.shape[0]
err_inf = np.max(np.abs(o - o_old))
# --- Break Armijo-loop in case a suitable steplength alpha was found
if err < err_old and err_inf < err_inf_old:
break
# --- Increase Armijo-loop's counter and restart loop
else:
k += 1
if velqp.sqp_stgs['b_print_sqp_alpha']:
print(velqp.sid + " | alpha: " + str(alpha))
############################################################################################################
# --- Postprocessing Armijo-loop: Create new operating point for optimization variables
############################################################################################################
# --- Create new operating-point for velocity variables
x0_v = v_op
# --- Create new operating-point for tire slack variables
x0_s_t = s_t_op
except TypeError:
# --- Do different initialization till n_sqp_max is reached
if velqp.sid == 'EmergSQP':
x0_v = (v_ini - 0.05) * np.ones((velqp.m, ))
v_op = np.zeros(velqp.sqp_stgs['m'], )
x0_s_t = np.zeros(velqp.n, )
s_t_op = np.zeros(velqp.n, )
print(
"No solution for emerg. line found. Retrying with different initialization ..."
)
# Reset SQP-counter
n_sqp = 0
if not velqp.sqp_stgs['b_online_mode']:
print('Optimized velocity profile: ', v_op[0:velqp.sqp_stgs['m']])
if velqp.sqp_stgs['obj_func'] == 'slacks':
print('Slacks on velocity: ',
v_op[velqp.sqp_stgs['m']:2 * velqp.sqp_stgs['m']])
if velqp.sqp_stgs['b_print_sqp_err']:
print(velqp.sid + " | SQP err: " + str(err))
print(velqp.sid + " | SQP inf.-err: " + str(err_inf))
################################################################################################################
# --- Check termination criteria for SQP-loop
################################################################################################################
# increase SQP-iteration counter
n_sqp += 1
if n_sqp >= velqp.sqp_stgs['n_sqp_max']:
print(velqp.sid + " reached max. SQP iteration-number!")
# update timer
dt = time.time() - t_start
if dt >= dt_lim:
print(velqp.sid + " took too long!")
if velqp.sqp_stgs['b_print_SQP_runtime']:
print(velqp.sid + " | SQP time [ms]: " + str(dt * 1000))
# Only write to log-file after SQP-iterations
if velqp.sid == 'PerfSQP' and velqp.logger_perf is not None:
velqp.logger_perf.debug('%s;%s;%s;%s;%s;%s;%s;%s;%s;%s;%s;%s;%s;%s',
str(datetime.datetime.now().time()), s_glob,
json.dumps(x0_v_log), json.dumps(x0_s_t_log),
json.dumps(kappa_log),
json.dumps(delta_s_log), v_ini_log,
json.dumps(v_max_log), v_end_log, F_ini_log,
Pmax_log, json.dumps(qp_iter),
json.dumps(qp_status), json.dumps(dt * 1000))
velqp.logger_perf.debug('%s', v_op.tolist())
velqp.logger_perf.debug('%s', s_t_op.tolist())
velqp.logger_perf.debug('%s;%s', ax_max_log, ay_max_log)
elif velqp.sid == 'EmergSQP' and velqp.logger_emerg is not None:
velqp.logger_emerg.debug('%s;%s;%s;%s;%s;%s;%s;%s;%s;%s;%s;%s;%s;%s',
str(datetime.datetime.now().time()), s_glob,
json.dumps(x0_v_log), json.dumps(x0_s_t_log),
json.dumps(kappa_log),
json.dumps(delta_s_log), v_ini_log,
json.dumps(v_max_log), v_end_log, F_ini_log,
Pmax_log, json.dumps(qp_iter),
json.dumps(qp_status), json.dumps(dt * 1000))
velqp.logger_emerg.debug('%s', v_op.tolist())
velqp.logger_emerg.debug('%s', s_t_op.tolist())
velqp.logger_emerg.debug('%s;%s', ax_max_log, ay_max_log)
if velqp.sqp_stgs['b_trajectory_check']:
ax_norm = np.abs(kappa[0:velqp.sqp_stgs['m'] - 1] *
v_op[0:velqp.sqp_stgs['m'] - 1]**2) / 13.5
ay_norm = np.abs(
(v_op[1:velqp.sqp_stgs['m']]**2 -
v_op[0:velqp.sqp_stgs['m'] - 1]**2) / (2 * np.array(delta_s)) +
(velqp.sym_sc_['c_res_'] * v_op[0:velqp.sqp_stgs['m'] - 1]**2) /
(1000 * velqp.sym_sc_['m_t_'])) / 13.5
perf_check = (ax_norm + ay_norm) > 1
if perf_check[:-1].any():
print(ax_norm + ay_norm)
print('*** SQP: Trajectory not OK! ', velqp.sid, ' ***')
if velqp.sqp_stgs['b_print_n_sqp']:
print(velqp.sid + ' | nSQP ' + str(n_sqp))
if velqp.sqp_stgs['b_print_s_v_val']:
print(velqp.sid + ' | s_v_tires ' + str(x0_s_t))
if velqp.sqp_stgs['b_print_J']:
print("(v - v_max) ** 2", np.sum((v_op - v_max)**2))
print("Tre. slacks", velqp.sym_sc_['s_tre_w_'] * np.sum(s_t_op**2))
return v_op, s_t_op, qp_status
def bpbounds_calc_tri_z2(p: np.array) -> Dict:
# assuming that p is in the following order
# notation for conditional probabilities is p(y,x|z)
p = p.ravel()
p000 = p[0]
p100 = p[2]
p010 = p[1]
p110 = p[3]
p001 = p[4]
p101 = p[6]
p011 = p[5]
p111 = p[7]
# pearl bounds on probabilities
p10low1 = p101
p10low2 = p100
p10low3 = p100 + p110 - p001 - p111
p10low4 = p010 + p100 - p001 - p011
p10upp1 = 1 - p001
p10upp2 = 1 - p000
p10upp3 = p010 + p100 + p101 + p111
p10upp4 = p100 + p110 + p011 + p101
p10low = max([p10low1, p10low2, p10low3, p10low4])
p10upp = min([p10upp1, p10upp2, p10upp3, p10upp4])
p11low1 = p110
p11low2 = p111
p11low3 = -p000 - p010 + p001 + p111
p11low4 = -p010 - p100 + p101 + p111
p11upp1 = 1 - p011
p11upp2 = 1 - p010
p11upp3 = p000 + p110 + p101 + p111
p11upp4 = p100 + p110 + p001 + p111
p11low = max([p11low1, p11low2, p11low3, p11low4])
p11upp = min([p11upp1, p11upp2, p11upp3, p11upp4])
p10lower = [p10low1, p10low2, p10low3, p10low4]
p10upper = [p10upp1, p10upp2, p10upp3, p10upp4]
p11lower = [p11low1, p11low2, p11low3, p11low4]
p11upper = [p11upp1, p11upp2, p11upp3, p11upp4]
retlist = {
"p10low": p10low,
"p10upp": p10upp,
"p11low": p11low,
"p11upp": p11upp,
"p10lower": p10lower,
"p10upper": p10upper,
"p11lower": p11lower,
"p11upper": p11upper
}
# bounds on causal risk ratio
rrlow = p11low / p10upp
rrupp = p11upp / p10low
retlist["crrlb"] = rrlow
retlist["crrub"] = rrupp
# monotonicity bounds
m1 = p000 - p001 >= 0
m2 = p011 - p010 >= 0
m3 = p100 - p101 >= 0
m4 = p111 - p110 >= 0
mlow = p000 - p001 - p011 - p101
mupp = p000 + p010 + p110 - p011
monoinequality = (m1 == True & m2 == True & m3 == True & m4 == True)
if monoinequality:
retlist["monobplb"] = mlow
retlist["monobpub"] = mupp
# bounds on intervention probabilities assuming monotonicity
monop10low = p100
monop10upp = 1 - p000
monop11low = p111
monop11upp = 1 - p011
retlist["monop10lb"] = monop10low
retlist["monop10ub"] = monop10upp
retlist["monop11lb"] = monop11low
retlist["monop11ub"] = monop11upp
# bounds on causal risk ratio assuming monotonicity
monocrrlow = monop11low / monop10upp
monocrrupp = monop11upp / monop10low
retlist["monocrrlb"] = monocrrlow
retlist["monocrrub"] = monocrrupp
else:
retlist["monobplb"] = 0
retlist["monobpub"] = 0
retlist["monop10lb"] = 0
retlist["monop10ub"] = 0
retlist["monop11lb"] = 0
retlist["monop11ub"] = 0
retlist["monocrrlb"] = 0
retlist["monocrrub"] = 0
retlist["monoinequality"] = monoinequality
return retlist
def __init__(self, image: np.array, copy=False):
"""construct from numpy array"""
if copy:
self.mat = image.copy()
else:
self.mat = image
def L_BFGS(f, f_grad, x_0: np.array, tol: float, stepsize: str, max_iter: int, m_lbfgs: int):
"""
Input: funtion: f, the gradient of f: f_grad, initial point: x_0, tolerence: tol,
step size strategies: stepsize, maximium iteration times: max_iter,
memory parameter: m_lbfgs
Output: 2-d list: result. Every element of result is a list for each iteration.
e.g. ['iteration k', 'x_k', 'stepsize alpha_k', 'f(x_k)', 'norm of f_grad(x_k)'] ：： may change
"""
k, x_k = 0, np.array(x_0.tolist())
alpha_k = 0
norm_gradient_list = []
result = [['iteration k', 'x_k', 'alpha_k', 'f(x_k)', 'norm of f_grad(x_k)']]
result.append([k, x_k.tolist(), alpha_k, f(x_k), np.linalg.norm(f_grad(x_k))])
norm_gradient_list.append(np.linalg.norm(f_grad(x_k)))
#initiate yk_list and sk_list
y_list, s_list = [], []
for i in np.arange(m_lbfgs):
y_list.append(np.zeros(n+1))
s_list.append(np.zeros(n+1))
###Update first x_next by using backtracking and gradient method
d_k = -f_grad(x_k)
stepsize_strategy = stepsize_strategies[stepsize]
if stepsize == 'backtrack':
alpha_k = stepsize_strategy(f, f_grad, x_k, d_k, s=1, sigma=0.5, gamma=0.1)
x_next = x_k + alpha_k*d_k
k = k + 1
norm_gradient_list.append(np.linalg.norm(f_grad(x_next)))
result.append([k, x_next.tolist(), alpha_k, f(x_next), np.linalg.norm(f_grad(x_next))]) #first step
while np.linalg.norm(f_grad(x_next)) >= tol:
yk = f_grad(x_next) - f_grad(x_k)
#update sk
sk = x_next - x_k
y_list.append(yk)
s_list.append(sk) # add from back to forward
y_list.pop(0)
s_list.pop(0)
#compute gamma_k
if sk.dot(yk) < 1e-14:
gamma_k = 1
else:
gamma_k = sk.dot(yk)/np.linalg.norm(yk)**2
alpha_list = []
q = f_grad(x_k)
#Recursive for initializing {H_k}^0
for i in range(m_lbfgs-1, -1, -1): ##倒着来
if s_list[i].dot(y_list[i]) < 1e-14:
alpha_list.append(0)
continue
else:
alpha_i = s_list[i].dot(q)/(s_list[i].dot(y_list[i]))
q = q - alpha_i*y_list[i]
alpha_list.append(alpha_i)
r = gamma_k*q
#Iterative for our final r
for i in range(m_lbfgs): ##顺着来
if s_list[i].dot(y_list[i]) < 1e-14:
continue
else:
beta = y_list[i].dot(r)/(s_list[i].dot(y_list[i]))
r = r + (alpha_list[i] - beta)*s_list[i]
d_k = -r
## For Stepsize
if stepsize == 'backtrack':
alpha_k = stepsize_strategy(f, f_grad, x_k, d_k, s=1, sigma=0.5, gamma=0.1)
#update x_k, x_next
x_k = np.array(x_next.tolist())
x_next = x_next + alpha_k*d_k
k += 1
norm_gradient_list.append(np.linalg.norm(f_grad(x_next)))
result.append([k, x_next.tolist(), alpha_k, f(x_next), np.linalg.norm(f_grad(x_next))])
if k == max_iter:
print('max iteration:',
k, 'the function value is', f(x_next), 'the norm of gradient is:', np.linalg.norm(f_grad(x_next)))
break
xk_result = np.array(result[-1][1]).reshape(-1,1)
norm_gradient_list = np.array(norm_gradient_list)
plot_convergence(norm_gradient_list, 3)
print("iterations:", k)
plot_result(m, xk_result, 3)
print("accuracy:", test(xk_result, dataset_num))
return result
def _process_depth(self, depth: np.array) -> np.array:
depth = depth.astype(np.float32)
return depth
def find_the_way(start: tuple, wall_map: np.array, coin_pos: np.array, max_dist = 100):
'''
finds the best way to go by applying dyjkstras algorithm
:start: tuple of starting coordinates
:wall_map: np.array of the whole board with 0 where there is a free tile
:coin_pos: np.array of coordinates of target positions
:ans: np.array of features (1 if this way is the ideal way, 0 if not)
'''
#board dimensions
dim = wall_map.shape
#some ausiliary functions
def isin(pos, array):
ans = False
for e in array:
if e[0] == pos[0] and e[1] == pos[1]:
ans = True
break
return ans
def within_bounds(pos):
return (np.array(pos) < np.array(dim)).all() and (np.array(pos) >= 0).all()
#initialize all four features as 0, the one that ist best to go along will be set to 1 then
ans = np.zeros(5) #up, right, down, left, dist
#some auxiliary stacks and dicts
inspecting = [start]
done = []
parents = {start:start}
distances = {start: 0}
translations = [(0,-1), (1,0), (0,1), (-1,0)] #up, right, down, left
found = False
#if there arent any coins return 0 0 0 0
if len(coin_pos) == 0: return ans
#if not find the shortest way to the closest coin
while len(inspecting) > 0:
#check all the tiles in consideration
relevant_dists = []
for i in range(len(inspecting)):
relevant_dists.append(distances[inspecting[i]])
#now consider the tile with the smallest distance from the start
current = inspecting.pop(np.argmin(relevant_dists))
#append it to current so it wont get considered again
done.append(current)
#break if that is a coin
if isin(current, coin_pos):
#final = current
found = True
break
#else give all the neighbors a distance based on the distance of the current tile
for t in translations:
neigh = (current[0]+t[0], current[1]+t[1])
if within_bounds(neigh) and wall_map[neigh] == 0 and distances[current] < max_dist: #check if that is a free tile and the max distance hasnt been exceeded yet
if neigh not in inspecting and neigh not in done: inspecting.append(neigh) #check if this tile hasnt been used yet
if neigh not in distances or distances[neigh] > distances[current] + 1: #check if the current distance is smaller than the previous one
distances[neigh] = distances[current] + 1
parents[neigh] = current
ans[4] = distances[tuple(current)]
#if there is no way to any of the targets
if not found:
return ans
#trace back the path to the coin and stop one tile before the starting tile so we know which way to go
while parents[current] != start:
current = parents[current]
#find the right move that gets you to the target
for i in range(4):
t = translations[i]
if current == (start[0] + t[0], start[1] + t[1]):
ans[i] = 1
break
#check if going any other way would get you to a target with the same distance
u, r, d, l, dist = tuple(ans)
new_map = wall_map.copy()
while (np.array([u, r, d, l]) == 1).any() and max_dist == 100: #max recursion depth is 1
t = translations[np.where(np.array([u, r, d, l]) == 1)[0][0]]
coord = (start[0]+t[0], start[1]+t[1])
new_map[coord] = -1
u, r, d, l, dist = find_the_way(start, new_map, coin_pos, max_dist=ans[4])
if dist == ans[4] and (np.array([u, r, d, l]) == 1).any(): ans += np.array([u, r, d, l, 0])
return tuple(ans)
def to_one_hot(y: np.array, categories='auto') -> np.array:
encoder = OneHotEncoder(categories=categories, sparse=False)
return encoder.fit_transform(y.reshape(-1, 1))
