def test():
log = lambda message: sys.stdout.write(message)
writer = Writer('D:/exe/imod/IMOD_USER/pusair-output')
try:
log('Reading config... ')
config.parse()
if config.config['gradient'] > 1:
raise ValueError('Maximum gradient is 1')
log('Done\n')
p, adj = slurp.prep(
# fbore=str('D:/exe/imod/IMOD_USER/pusair-input/Boreholes_Dimas.ipf'),
fbore=str('D:/exe/imod/IMOD_USER/pusair-input/Boreholes_Jakarta.ipf'),
fscreen=str('data/well_M_z_all.ipf'),
config=config,
log=log)
interpolator = Interpolator(p, adj, writer, log)
interpolator.interpolate()
log('\n[DONE]')
except Exception as e:
log('\n\n[ERROR] {}'.format(e))
traceback.print_exc()
writer.reset()
def run(self):
log = lambda message: self.emit(SIGNAL('logging(QString)'), message)
writer = Writer(str(self.text_output))
try:
log('Reading config... ')
config.parse()
if config.config['gradient'] > 1:
raise ValueError('Maximum gradient is 1')
log('Done\n')
p, adj = slurp.prep(
fbore=str(self.text_input),
fscreen=str(self.text_screen),
config=config,
log=log)
interpolator = Interpolator(p, adj, writer, log)
interpolator.interpolate()
log('\n[DONE]')
except Exception as e:
log('\n\n[ERROR] {}'.format(e))
traceback.print_exc()
self.emit(SIGNAL('finish_program()'))
def Interpolate(self, **kwds): #XXX: refactor so use self.interpolator ?
"""interpolate data (x,z) to generate response function z=f(*x)
Input:
maxpts: int, maximum number of points to use from (x,z)
noise: float, amplitude of gaussian noise to remove duplicate x
method: string for kind of interpolator
extrap: if True, extrapolate a bounding box (can reduce # of nans)
arrays: if True, return a numpy array; otherwise don't return arrays
Output:
interpolated response function, where z=f(*x.T)
NOTE:
if scipy is not installed, will use np.interp for 1D (non-rbf),
or mystic's rbf otherwise. default method is 'nearest' for
1D and 'linear' otherwise. method can be one of ('rbf','linear',
'nearest','cubic','inverse','gaussian','quintic','thin_plate').
"""
from interpolator import Interpolator
args = self.args.copy()
args.update(kwds)
maxpts, noise = self.maxpts, self.noise
ii = Interpolator(self.x, self.z, maxpts=maxpts, noise=noise, **args)
self.surrogate = ii.Interpolate(**args)
# build the surrogate
self.surrogate.__doc__ = self.objective.__doc__
return self.surrogate
def add_wheel(self, n, distance, angle, radius, calibration = 1.0):
overall_adjust = calibration / radius
factor_advance = -sin(angle)
factor_lateral = cos(angle)
factor_turn = distance
row = (factor_advance * overall_adjust,
factor_lateral * overall_adjust,
factor_turn * overall_adjust)
self._wheels[n] = row
self._forward_matrix = None
self._back_matrix = None
interpolator = Interpolator()
interpolator.smooth_function = smooth_ease
self._wheel_speeds[n] = interpolator
def compute(self, rdf):
cut_beg = 13.0
cut_end = 15.0
# Removes values with a density of zero, they will get added back later.
rdf = rdf[nonzero(rdf[:,1])[0], :]
# Finds the first index where the density is greater than 0.25*rho.
i0 = nonzero(rdf[:,1] > 0.25)[0][0]
# Get distance (r) and energy (e).
r = rdf[:,0]
e = -kB*self.temperature*log(rdf[:,1])
dr_final = (cut_end-self.min_distance)/self.npts
# Figure out what range we need
# Compute derivative from splines.
rr = arange(cut_end, r[i0], -dr_final)[::-1]
interp = Interpolator(r,e)
ff = [-interp.derivative(ri) for ri in rr]
v0 = [5.0, 0.01]
lj96_err = lambda v: ff - lj96_force(v,rr)
v = optimize.leastsq(lj96_err, v0)[0]
# Add more values to short distance to make sure that
# LAMMPS run won't fail when pair distance < table min.
rpad = arange(self.min_distance, rr[0]-0.5*dr_final, dr_final)
fpad = lj96_force(v, rpad) + ff[0] - lj96_force(v, rr[0])
rr = concatenate((rpad, rr))
ff = concatenate((fpad, ff))
# Now we cut off forces smoothly at any point past max_attraction.
ff[rr>cut_beg] *= 0.5*(1.0+cos(pi*(rr[rr>cut_beg]-cut_beg)/(cut_end-cut_beg)))
ff[rr>cut_end] = 0.0
# Compute energy by integrating forces.
# Integrating backwards reduces noise.
ee = -simpson_integrate(rr[::-1], ff[::-1])[::-1]
ee -= ee[-1]
self.distance.append(rr)
self.force.append(ff)
self.energy.append(ee)
def get_x_y(data_list):
interpolator = Interpolator()
interpolator.set_u(ACTIONS)
x = []
y = []
for data_row in data_list:
new_q = data_row["reward"]
if not data_row["done"]:
new_q += DISCOUNT * np.max(data_row["next_qualities"])
interpolator.set_q(data_row["qualities"])
interpolator.update_function(data_row["action"], new_q)
x.append(data_row["state"])
y.append(interpolator.get_q())
return x, y
def _get_interpolator(self):
single_CB = CompositeCrackBridge(E_m=self.E_m,
reinforcement_lst=[self.reinforcement])
CB_model = CompositeCrackBridgePostprocessor(model=single_CB)
return Interpolator(CB_model = CB_model,
load_sigma_c_max = self.load_sigma_c_max,
load_n_sigma_c = self.load_n_sigma_c,
n_w = 80, n_x = 61, n_BC = 6
)
def fit(self, **kwds):
"""generate an interpolated model from data
Input:
data: a mystic legacydata.dataset (or callable model, y = model(x))
rnd: bool, if False, treat the model as deterministic [default: True]
cached: bool, if True, use a mystic.cache [default: False]
NOTE:
any additional keyword arguments will be passed to the interpolator
NOTE:
if data is a model, interpolator will use model's cached archive
"""
self.__kwds__.update(kwds)
cached = self.__kwds__.pop('cached', False)
archive = data = self.__kwds__.pop('data', None)
self.rnd = self.__kwds__.pop('rnd', self.rnd) and (
bool(self.__kwds__.get('noise', True))
) # or callable(data) or isinstance(data, type('')))
if callable(data): #XXX: is a model, allow this?
data = sample(data, bounds=None, pts=0) #XXX: axis? multivalue?
elif isinstance(data, type('')): #XXX: is a name, allow this?
import mystic.cache as mc
import dataset as ds
data = ds.from_archive(mc.archive.read(data))
x = getattr(data, 'coords', getattr(data, 'x', None))
z = getattr(data, 'values', getattr(data, 'y', None))
from interpolator import Interpolator
terp = Interpolator(x, z, **self.__kwds__)
self.__func__ = terp.Interpolate() #XXX: ValueError: zero-size
self.__model__ = _init_axis(terp.model)
self.__model__.__name__ = self.__name__
self.__kwds__['data'] = archive
if cached: #FIXME: clear the archive??? generate new uid name?
self.__kwds__['cached'] = True
self._OUQModel__init_cache()
if hasattr(self.__model__, '__cache__'):
c = self.__model__.__cache__()
c.clear()
else:
self.__kwds__['cached'] = False
return
def __init__(self, window_name="output"):
self.WIDTH = 250
self.DISPLAY_STEERING_MIN = -1
self.DISPLAY_THROTTLE_MIN = -1
self.DISPLAY_STEERING_MAX = 1
self.DISPLAY_THROTTLE_MAX = 1
self.DISPLAY_STEERING_RANGE = self.DISPLAY_STEERING_MAX - self.DISPLAY_STEERING_MIN
self.DISPLAY_THROTTLE_RANGE = self.DISPLAY_THROTTLE_MAX - self.DISPLAY_THROTTLE_MIN
self.DISPLAY_STEP = 0.1
self.DISPLAY_STEERING_SEGMENT_WIDTH = int(
self.WIDTH * self.DISPLAY_STEP / self.DISPLAY_STEERING_RANGE)
self.DISPLAY_THROTTLE_SEGMENT_WIDTH = int(
self.WIDTH * self.DISPLAY_STEP / self.DISPLAY_THROTTLE_RANGE)
self.HUE_RANGE = 60
self.img = None
self.window_name = window_name
self._clear()
self.interpolator = Interpolator()
def __init__(self, known_points, known_values, k=1.0):
Interpolator.__init__(self, known_points, known_values)
# k: exponent for inverse distance weighing function; k >= 1; larger k yields an interpolated surface with bigger "plateaus" around the sample points
assert k >= 1.0
self._k = k
nargs=5,
required=False,
metavar=('DATABASE', 'USER', 'PASSWORD', 'HOST',
'PORT'),
help='Specifies connection to database')
file_parser.add_argument('--db',
nargs=5,
required=False,
metavar=('DATABASE', 'USER', 'PASSWORD', 'HOST',
'PORT'),
help='Specifies connection to database')
args = parser.parse_args()
output, closing = output.get_outputs(args)
interpolator = Interpolator(output)
try:
if args.command == 'mqtt':
def on_message(client, user_data, msg):
if msg.topic == STANDARD_TOPIC:
message = msg.payload.rstrip()
interpolator.add_item(message.split(','))
def on_connect(client, userdata, flags, rc):
client.subscribe(STANDARD_TOPIC)
client = mqtt.Client()
client.on_connect = on_connect
increment = True
f.close()
os.rename(outpath + ".tmp", outpath)
#interpolator.printTime("Completed dump");
#self.invalid.append(path);
if not increment:
i = i + 1
self.cleanup()
######################################################
# start Gatekeeper and listen for requests...
######################################################
lockfile = "lockfile"
filename = '../weather_data/all.nc'
ip = Interpolator(filename)
gk = Gatekeeper("../coms", lockfile)
mindelay = 0.1
# seconds
start = time.time()
last = start
ip.printTime("Starting")
## Running it indefinitely
try:
while (True):
gk.process(ip)
current = time.time()
delay = last + mindelay - current
if (delay > 0):
time.sleep(delay)
class OutputVisualizer:
def __init__(self, window_name="output"):
self.WIDTH = 250
self.DISPLAY_STEERING_MIN = -1
self.DISPLAY_THROTTLE_MIN = -1
self.DISPLAY_STEERING_MAX = 1
self.DISPLAY_THROTTLE_MAX = 1
self.DISPLAY_STEERING_RANGE = self.DISPLAY_STEERING_MAX - self.DISPLAY_STEERING_MIN
self.DISPLAY_THROTTLE_RANGE = self.DISPLAY_THROTTLE_MAX - self.DISPLAY_THROTTLE_MIN
self.DISPLAY_STEP = 0.1
self.DISPLAY_STEERING_SEGMENT_WIDTH = int(
self.WIDTH * self.DISPLAY_STEP / self.DISPLAY_STEERING_RANGE)
self.DISPLAY_THROTTLE_SEGMENT_WIDTH = int(
self.WIDTH * self.DISPLAY_STEP / self.DISPLAY_THROTTLE_RANGE)
self.HUE_RANGE = 60
self.img = None
self.window_name = window_name
self._clear()
self.interpolator = Interpolator()
def _clear(self):
self.img = np.zeros((self.WIDTH, self.WIDTH, 3), np.uint8)
def _iterate(self, output):
u = output[:, :2]
q = output[:, 2]
self.interpolator.set_u(u)
self.interpolator.set_q(q)
X = []
Y = []
Z = []
for throttle in np.arange(-1, 1.1, 0.1):
for steering in np.arange(-1, 1.1, 0.1):
X.append(throttle)
Y.append(steering)
Z.append(
self.interpolator.get_quality(
np.array([throttle, steering])))
return X, Y, Z
def _coord2px(self, value):
return int(min(max(value, 0), self.WIDTH - 1))
def _draw_output_2(self, output):
u = output[:, :2]
q = output[:, 2]
x = [action[1] for action in u]
y = [action[0] for action in u]
x_0 = min(x)
y_0 = min(y)
x_pixels_per_value = self.WIDTH / (max(x) - min(x))
y_pixels_per_value = self.WIDTH / (max(y) - min(y))
x_loc = [
self._coord2px((x_value - x_0) * x_pixels_per_value)
for x_value in x
]
y_loc = [
self._coord2px(self.WIDTH - (y_value - y_0) * y_pixels_per_value)
for y_value in y
]
x_values = sorted(set(x_loc))
y_values = sorted(set(y_loc))
x_start = dict(
zip(x_values, [0] + [
self._coord2px((x_values[i + 1] + x_values[i]) / 2)
for i in range(len(x_values) - 1)
]))
y_start = dict(
zip(y_values, [0] + [
self._coord2px((y_values[i + 1] + y_values[i]) / 2)
for i in range(len(y_values) - 1)
]))
x_stop = dict(
zip(x_values, [
self._coord2px((x_values[i + 1] + x_values[i]) / 2)
for i in range(len(x_values) - 1)
] + [self.WIDTH - 1]))
y_stop = dict(
zip(y_values, [
self._coord2px((y_values[i + 1] + y_values[i]) / 2)
for i in range(len(y_values) - 1)
] + [self.WIDTH - 1]))
q_0 = min(q + [0])
hue_per_value = self.HUE_RANGE / (max(q + [0]) - min(q + [0]))
for i in range(len(q)):
cv2.rectangle(self.img, (x_start[x_loc[i]], y_start[y_loc[i]]),
(x_stop[x_loc[i]], y_stop[y_loc[i]]),
color=tuple(
map(
int,
cv2.cvtColor(
np.uint8([[[(q[i] - q_0) * hue_per_value,
255, 255]]]),
cv2.COLOR_HSV2BGR)[0, 0])),
thickness=-1)
cv2.circle(self.img, (x_loc[i], y_loc[i]),
max(int(self.DISPLAY_THROTTLE_SEGMENT_WIDTH / 5), 1),
(0, 0, 0), -1)
def _draw_output(self, output):
u = output[:, :2]
q = output[:, 2]
self.interpolator.set_u(u)
self.interpolator.set_q(q)
X = []
Y = []
Z = []
for throttle in np.arange(
self.DISPLAY_THROTTLE_MIN,
self.DISPLAY_THROTTLE_MAX + self.DISPLAY_STEP,
self.DISPLAY_STEP):
y = (self.WIDTH - self.DISPLAY_THROTTLE_SEGMENT_WIDTH) * (
0.5 - throttle / self.DISPLAY_THROTTLE_RANGE)
for steering in np.arange(
self.DISPLAY_STEERING_MIN,
self.DISPLAY_STEERING_MAX + self.DISPLAY_STEP,
self.DISPLAY_STEP):
x = (self.WIDTH - self.DISPLAY_STEERING_SEGMENT_WIDTH) * (
0.5 + steering / self.DISPLAY_STEERING_RANGE)
X.append(int(x))
Y.append(int(y))
Z.append(
self.interpolator.get_quality(
np.array([throttle, steering])))
knots = []
for i in range(len(u)):
throttle = u[i][0]
steering = u[i][1]
y = int(self.WIDTH *
(0.5 - throttle / self.DISPLAY_THROTTLE_RANGE))
x = int(self.WIDTH *
(0.5 + steering / self.DISPLAY_STEERING_RANGE))
knots.append((x, y))
min_q = min(Z)
range_q = max(q) - min_q
q_multiplier = self.HUE_RANGE / range_q
if math.isnan(q_multiplier) or math.isinf(q_multiplier):
q_multiplier = 1
Z = [
min(max(int(q_multiplier * (z - min_q)), 0), self.HUE_RANGE)
for z in Z
]
for i in range(len(Z)):
cv2.rectangle(self.img, (int(min(
self.WIDTH - 1, X[i])), int(min(self.WIDTH - 1, Y[i]))),
(int(
min(self.WIDTH - 1,
X[i] + self.DISPLAY_STEERING_SEGMENT_WIDTH)),
int(
min(self.WIDTH - 1, Y[i] +
self.DISPLAY_THROTTLE_SEGMENT_WIDTH))),
color=tuple(
map(
int,
cv2.cvtColor(np.uint8([[[Z[i], 255, 255]]]),
cv2.COLOR_HSV2BGR)[0, 0])),
thickness=-1)
for knot in knots:
cv2.circle(self.img, knot,
max(int(self.DISPLAY_THROTTLE_SEGMENT_WIDTH / 5), 1),
(0, 0, 0), -1)
def render(self, output):
self._clear()
self._draw_output_2(output)
cv2.imshow(self.window_name, self.img)
cv2.waitKey(40)
def train(self, terminal_state):
# Start training only if certain number of samples is already saved
if len(self.replay_memory) < MIN_REPLAY_MEMORY_SIZE:
return
# Calculate Prioritized Experience Replay weights
current_states = np.array([transition[0] for transition in self.replay_memory])
future_states = np.array([transition[3] for transition in self.replay_memory])
current_qs = self.model.predict(current_states)
future_qs = self.target_model.predict(future_states)
p = np.array([abs((reward + DISCOUNT * np.amax(future_qs[index]) if not done else reward)
- current_qs[index][ACTIONS.index(action)])
for index, (_, action, reward, _, done) in enumerate(self.replay_memory)])
p = np.interp(p, (p.min(), p.max()), (0, +1))
p /= np.sum(p)
# Get a minibatch of random samples from memory replay table
minibatch = np.array(self.replay_memory)[np.random.choice(len(self.replay_memory),
size=MINIBATCH_SIZE,
replace=False,
p=p)] # random.sample(self.replay_memory, MINIBATCH_SIZE)
# Get current states from minibatch, then query NN model for Q values
current_states = np.array([transition[0] for transition in minibatch]) # / 255
current_qs_list = self.model.predict(current_states)
# Get future states from minibatch, then query NN model for Q values
# When using target network, query it, otherwise main network should be queried
new_current_states = np.array([transition[3] for transition in minibatch]) # / 255
future_target_qs_list = self.target_model.predict(new_current_states)
future_model_qs_list = self.model.predict(new_current_states)
x = []
y = []
interpolator = Interpolator()
# Now we need to enumerate our batches
for index, (current_state, action, reward, new_current_state, done) in enumerate(minibatch):
# If not a terminal state, get new q from future states, otherwise set it to 0
# almost like with Q Learning, but we use just part of equation here
future_model_qs_at_index = future_model_qs_list[index]
future_target_qs_at_index = future_target_qs_list[index]
# future_qs = np.reshape(future_model_qs_at_index, OUTPUT_2D_SHAPE)
if not done:
max_future_q = future_target_qs_at_index[np.argmax(future_model_qs_at_index)]
new_q = reward + DISCOUNT * max_future_q
else:
new_q = reward
# Update Q value for given state
current_qs_list_at_index = current_qs_list[index]
current_qs = np.reshape(current_qs_list_at_index, OUTPUT_2D_SHAPE)
current_actions = ACTIONS
current_qualities = current_qs
interpolator.set_u(current_actions)
interpolator.set_q(current_qualities)
interpolator.update_function(action, new_q)
# current_qs = np.zeros(OUTPUT_2D_SHAPE)
# current_qs[:, :2] = interpolator.get_u()
current_qs = interpolator.get_q() # [current_actions.index(action)] = [new_q] #
# print(current_state)
# print(current_qs_list)
# print(action)
# current_qs[action] = new_q
# And append to our training data
x.append(current_state)
reshaped_current_qs = np.reshape(current_qs, OUTPUT_1D_SHAPE)
y.append(reshaped_current_qs)
# print("x:", x)
# print("y:", y)
# Fit on all samples as one batch, log only on terminal state
self.model.fit(np.array(x), np.array(y), batch_size=MINIBATCH_SIZE, verbose=0, shuffle=False,
callbacks=[self.tensorboard] if terminal_state else None)
# Update target network counter every episode
if terminal_state:
self.target_update_counter += 1
# If counter reaches set value, update target network with weights of main network
if self.target_update_counter > UPDATE_TARGET_EVERY:
self.target_model.set_weights(self.model.get_weights())
# a = self.model.get_weights()
# print(a)
self.target_update_counter = 0
self.save_replay_memory()
def __init__(self, simulate=False):
# setup motor controller. The PWM controller can control up to 16
# different devices. We have to add devices, one for each thruster that
# we can control. The first parameter is the human-friendly name of the
# device. That is used for logging to the console and/or a database. The
# next parameter indicates which PWM connector this device is connected
# to. This is refered to as the PWM channel. The last two values
# indicate at what time intervals (ticks) the PWM should turn on and
# off, respectively. We simply start each device at 0 time and control
# the duration of the pulses by adjusting the off time. Note that we may
# be able to shuffle on/off times to even out the current draw from the
# thrusters, but so far, that hasn't been an issue. It's even possible
# that the PWM controller may do that for us already.
if simulate is False:
from pwm_controller import PWMController
self.motor_controller = PWMController()
self.motor_controller.add_device("HL", HL, 0, NEUTRAL)
self.motor_controller.add_device("VL", VL, 0, NEUTRAL)
self.motor_controller.add_device("VC", VC, 0, NEUTRAL)
self.motor_controller.add_device("VR", VR, 0, NEUTRAL)
self.motor_controller.add_device("HR", HR, 0, NEUTRAL)
self.motor_controller.add_device("LIGHT", LIGHT, 0, FULL_REVERSE)
else:
self.motor_controller = None
# setup the joysticks. We use a 2D vector to represent the x and y
# values of the joysticks.
self.j1 = Vector2D()
self.j2 = Vector2D()
# create interpolators
self.horizontal_left = Interpolator()
self.vertical_left = Interpolator()
self.vertical_center = Interpolator()
self.vertical_right = Interpolator()
self.horizontal_right = Interpolator()
# setup interpolators from a file or manually
if os.path.isfile(SETTINGS_FILE):
with open(SETTINGS_FILE, 'r') as f:
self.set_settings(json.load(f), False)
else:
# Set the sensitivity to be applied to each thruster. 0 indicates a
# linear response which is the default when no sensitivity is applied. 1
# indicates full sensitivity. Values between 0 and 1 can be used to
# increase and to decrease the overall sensitivity. Increasing sensivity
# dampens lower values and amplifies larger values giving more precision
# at lower power levels.
self.sensitivity = 0.7
# We use a cubic to apply sensitivity. If you find that full sensitivity
# (dampening) does not give you fine enough control, you can increase\
# the degree of the polynomial used for dampening. Note that this must
# be a positive odd number. Any other values will cause unexpected
# results.
self.power = 3
# setup the various interpolators for each thruster. Each item we add
# to the interpolator consists of two values: an angle in degrees and a
# thrust value. An interpolator works by returning a value for any given
# input value. More specifically in this case, we will give each
# interpolator an angle and it will return a thrust value for that
# angle. Since we have only given the interpolator values for very
# specific angles, it will have to determine values for angles we have
# not provided. It does this using linear interpolation.
self.horizontal_left.addIndexValue(0.0, -1.0)
self.horizontal_left.addIndexValue(90.0, 1.0)
self.horizontal_left.addIndexValue(180.0, 1.0)
self.horizontal_left.addIndexValue(270.0, -1.0)
self.horizontal_left.addIndexValue(360.0, -1.0)
self.vertical_left.addIndexValue(0.0, 1.0)
self.vertical_left.addIndexValue(90.0, -1.0)
self.vertical_left.addIndexValue(180.0, -1.0)
self.vertical_left.addIndexValue(270.0, 1.0)
self.vertical_left.addIndexValue(360.0, 1.0)
self.vertical_center.addIndexValue(0.0, 0.0)
self.vertical_center.addIndexValue(90.0, 1.0)
self.vertical_center.addIndexValue(180.0, 0.0)
self.vertical_center.addIndexValue(270.0, -1.0)
self.vertical_center.addIndexValue(360.0, 0.0)
self.vertical_right.addIndexValue(0.0, -1.0)
self.vertical_right.addIndexValue(90.0, -1.0)
self.vertical_right.addIndexValue(180.0, 1.0)
self.vertical_right.addIndexValue(270.0, 1.0)
self.vertical_right.addIndexValue(360.0, -1.0)
self.horizontal_right.addIndexValue(0.0, 1.0)
self.horizontal_right.addIndexValue(90.0, 1.0)
self.horizontal_right.addIndexValue(180.0, -1.0)
self.horizontal_right.addIndexValue(270.0, -1.0)
self.horizontal_right.addIndexValue(360.0, 1.0)
# setup ascent/descent controllers
self.ascent = -1.0
self.descent = -1.0
# setup light
self.light = 0.0
def test___init__(self):
''' Just run the linear and quadratic interpolations '''
fseries, signalseries, errorseries = self.ServeInput()
interpolator = Interpolator(fseries, signalseries, running_regr_type = 'linear', windowlength=0)
y_interpolated = interpolator.y(fseries)
e_interpolated = interpolator.e(fseries)
self.assertAlmostEqual(numpy.sum(signalseries-y_interpolated), 0.0, places=10)
self.assertAlmostEqual(numpy.sum(e_interpolated), 0.0, places=10)
fseries, signalseries, errorseries = self.ServeInput()
interpolator = Interpolator(fseries, signalseries, running_regr_type = 'linear', windowlength=5)
y_interpolated = interpolator.y(fseries)
e_interpolated = interpolator.e(fseries)
fseries, signalseries, errorseries = self.ServeInput(create_errorseries=True)
interpolator = Interpolator(fseries, signalseries, running_regr_type = 'linear', windowlength=5)
y_interpolated = interpolator.y(fseries)
e_interpolated = interpolator.e(fseries)
fseries, signalseries, errorseries = self.ServeInput()
interpolator = Interpolator(fseries, signalseries, running_regr_type = 'quadratic', windowlength=5)
y_interpolated = interpolator.y(fseries)
e_interpolated = interpolator.e(fseries)
fseries, signalseries, errorseries = self.ServeInput(create_errorseries=True)
interpolator = Interpolator(fseries, signalseries, running_regr_type = 'quadratic', windowlength=5)
y_interpolated = interpolator.y(fseries)
e_interpolated = interpolator.e(fseries)
plt.plot(timestamps, data[i][3], 'b')
plt.xlabel('frame time (msec)')
plt.ylabel('acceleromenter value')
plt.legend(['x', 'y', 'z'])
plt.show()
visualized += 1
if (visualize_interpolated):
timestamps = np.arange(train_frame_start,
train_frame_end + train_sparseness, train_sparseness)
visualize_count = 3
visualized = 0
for i in xrange(0, len(labels)):
if (not labels[i] and visualized < visualize_count):
cutted_data = Interpolator.cut_data([data[i]],
test_frame_start, test_frame_end, test_sparseness)
interpolated_data = Interpolator.interpolate(
cutted_data, train_frame_start,
train_frame_end, train_sparseness,
interpolation_degree)
plt.figure(figsize=(20, 10))
plt.plot(timestamps, data[i][2], '--b')
plt.plot(timestamps, interpolated_data[0][2], '-r')
plt.xlabel('frame time (msec)')
plt.ylabel('acceleromenter value')
plt.legend(['source data', 'interpolated data'])
plt.show()
visualized += 1
if (training_enabled):
train_dataset_size = int(0.8 * len(data))
class ThrusterController:
def __init__(self, simulate=False):
# setup motor controller. The PWM controller can control up to 16
# different devices. We have to add devices, one for each thruster that
# we can control. The first parameter is the human-friendly name of the
# device. That is used for logging to the console and/or a database. The
# next parameter indicates which PWM connector this device is connected
# to. This is refered to as the PWM channel. The last two values
# indicate at what time intervals (ticks) the PWM should turn on and
# off, respectively. We simply start each device at 0 time and control
# the duration of the pulses by adjusting the off time. Note that we may
# be able to shuffle on/off times to even out the current draw from the
# thrusters, but so far, that hasn't been an issue. It's even possible
# that the PWM controller may do that for us already.
if simulate is False:
from pwm_controller import PWMController
self.motor_controller = PWMController()
self.motor_controller.add_device("HL", HL, 0, NEUTRAL)
self.motor_controller.add_device("VL", VL, 0, NEUTRAL)
self.motor_controller.add_device("VC", VC, 0, NEUTRAL)
self.motor_controller.add_device("VR", VR, 0, NEUTRAL)
self.motor_controller.add_device("HR", HR, 0, NEUTRAL)
self.motor_controller.add_device("LIGHT", LIGHT, 0, FULL_REVERSE)
else:
self.motor_controller = None
# setup the joysticks. We use a 2D vector to represent the x and y
# values of the joysticks.
self.j1 = Vector2D()
self.j2 = Vector2D()
# create interpolators
self.horizontal_left = Interpolator()
self.vertical_left = Interpolator()
self.vertical_center = Interpolator()
self.vertical_right = Interpolator()
self.horizontal_right = Interpolator()
# setup interpolators from a file or manually
if os.path.isfile(SETTINGS_FILE):
with open(SETTINGS_FILE, 'r') as f:
self.set_settings(json.load(f), False)
else:
# Set the sensitivity to be applied to each thruster. 0 indicates a
# linear response which is the default when no sensitivity is applied. 1
# indicates full sensitivity. Values between 0 and 1 can be used to
# increase and to decrease the overall sensitivity. Increasing sensivity
# dampens lower values and amplifies larger values giving more precision
# at lower power levels.
self.sensitivity = 0.7
# We use a cubic to apply sensitivity. If you find that full sensitivity
# (dampening) does not give you fine enough control, you can increase\
# the degree of the polynomial used for dampening. Note that this must
# be a positive odd number. Any other values will cause unexpected
# results.
self.power = 3
# setup the various interpolators for each thruster. Each item we add
# to the interpolator consists of two values: an angle in degrees and a
# thrust value. An interpolator works by returning a value for any given
# input value. More specifically in this case, we will give each
# interpolator an angle and it will return a thrust value for that
# angle. Since we have only given the interpolator values for very
# specific angles, it will have to determine values for angles we have
# not provided. It does this using linear interpolation.
self.horizontal_left.addIndexValue(0.0, -1.0)
self.horizontal_left.addIndexValue(90.0, 1.0)
self.horizontal_left.addIndexValue(180.0, 1.0)
self.horizontal_left.addIndexValue(270.0, -1.0)
self.horizontal_left.addIndexValue(360.0, -1.0)
self.vertical_left.addIndexValue(0.0, 1.0)
self.vertical_left.addIndexValue(90.0, -1.0)
self.vertical_left.addIndexValue(180.0, -1.0)
self.vertical_left.addIndexValue(270.0, 1.0)
self.vertical_left.addIndexValue(360.0, 1.0)
self.vertical_center.addIndexValue(0.0, 0.0)
self.vertical_center.addIndexValue(90.0, 1.0)
self.vertical_center.addIndexValue(180.0, 0.0)
self.vertical_center.addIndexValue(270.0, -1.0)
self.vertical_center.addIndexValue(360.0, 0.0)
self.vertical_right.addIndexValue(0.0, -1.0)
self.vertical_right.addIndexValue(90.0, -1.0)
self.vertical_right.addIndexValue(180.0, 1.0)
self.vertical_right.addIndexValue(270.0, 1.0)
self.vertical_right.addIndexValue(360.0, -1.0)
self.horizontal_right.addIndexValue(0.0, 1.0)
self.horizontal_right.addIndexValue(90.0, 1.0)
self.horizontal_right.addIndexValue(180.0, -1.0)
self.horizontal_right.addIndexValue(270.0, -1.0)
self.horizontal_right.addIndexValue(360.0, 1.0)
# setup ascent/descent controllers
self.ascent = -1.0
self.descent = -1.0
# setup light
self.light = 0.0
def __del__(self):
'''
When an instance of this class gets destroyed, we need to make sure that
we turn off all motors. Otherwise, we could end up in a situation where
the vehicle could have thrusters running when we don't have scripts
running to control it.
'''
self.set_motor(HL, 0.0)
self.set_motor(VL, 0.0)
self.set_motor(VC, 0.0)
self.set_motor(VL, 0.0)
self.set_motor(HR, 0.0)
def update_axis(self, axis, value):
'''
This is the main method of this class. It is responsible for taking an
controller input value (referred to as an axis value) and then
converting that into the appropriate thrust values for the appropriate
thrusters associated with that axis.
For the two joysticks, we convert the joystick position into an angle.
We know which thrusters each joystick controls, so we feed the
calculated angle into the thruster interpolators for that joystick. This
gives us the new thruster value for each thruster, which we then apply
to the PWM controller devices for those thrusters.
Note that the angle of the joystick does not give us all of the
information that we need. If the joystick is close to the center
position, then we don't need to apply as much thrust. If it is pushed
all the way to the edge, then we nee 100% thrust. So, we treat the
center as 0% and the edge as 100%. The values we get back from the
interpolators are 100% values, so we simply apply the joystick
percentage to the interpolator value to find the actual thrust value we
need to use.
Things get a bit more complicated for the vertical thrusters because it
is possible that we will be pitiching or rolling the vehicle while
simultaneously trying to move the vehicle directly up or down. If we
pitch or roll the vehicle only, then the process is exactly as we
described above. However, if are pithing and/or rolling AND moveing the
vehicle vertically, we need to combine the two operations into one set
of thruster values. We have to first determine the values for pitch and
roll, then we increase or decrease all thruster values equally in the up
or down direction. However it is possible that we will not be able to
increase/decrease all thrusters by the same amount since we are already
applying thrust for pitch and roll. This means we need to make sure our
values do not go outside the closed intervale [-1,1]. This means that as
we pitch or roll harder, the vehical will flattern out as we apply
vertical thrust.
'''
# We need to keep track of which thrusters need updating. We use the
# following flags for that purpose
update_horizontal_thrusters = False
update_vertical_thrusters = False
# Round the incoming value to the specified precision to reduce input
# noise
value = round(value, PRECISION)
# Update the appropriate joystick vector based on which controller axis
# has changed. Note that we make sure the value is different from what
# we have already to prevent unnecessary updates. Recall that the
# controller may send values whose differences are smaller than our
# precision. This means we will get an update from the controller, but
# we decided to ignore it since it won't result in a significant change
# to our thrusters.
if axis == JL_H:
if self.j1.x != value:
self.j1.x = value
update_horizontal_thrusters = True
elif axis == JL_V:
if self.j1.y != value:
self.j1.y = value
update_horizontal_thrusters = True
elif axis == JR_H:
if self.j2.x != value:
self.j2.x = value
update_vertical_thrusters = True
elif axis == JR_V:
if self.j2.y != value:
self.j2.y = value
update_vertical_thrusters = True
elif axis == AL:
if self.descent != value:
self.descent = value
update_vertical_thrusters = True
elif axis == AR:
if self.ascent != value:
self.ascent = value
update_vertical_thrusters = True
else:
pass
# print("unknown axis ", event.axis)
# updating horizontal thrusters is easy: find current angle, convert
# angle to thruster values, apply values
if update_horizontal_thrusters:
left_value = self.horizontal_left.valueAtIndex(self.j1.angle)
right_value = self.horizontal_right.valueAtIndex(self.j1.angle)
power = min(1.0, self.j1.length)
self.set_motor(HL, left_value * power)
self.set_motor(HR, right_value * power)
# updating vertical thrusters is trickier. We do the same as above, but
# then post-process the values if we are applying vertical up/down
# thrust. As mentioned above, we have to be careful to stay within our
# [-1,1] interval.
if update_vertical_thrusters:
power = min(1.0, self.j2.length)
back_value = self.vertical_center.valueAtIndex(self.j2.angle) * power
front_left_value = self.vertical_left.valueAtIndex(self.j2.angle) * power
front_right_value = self.vertical_right.valueAtIndex(self.j2.angle) * power
if self.ascent != -1.0:
percent = (1.0 + self.ascent) / 2.0
max_thrust = max(back_value, front_left_value, front_right_value)
max_adjust = (1.0 - max_thrust) * percent
# back_value += max_adjust
front_left_value += max_adjust
front_right_value += max_adjust
elif self.descent != -1.0:
percent = (1.0 + self.descent) / 2.0
min_thrust = min(back_value, front_left_value, front_right_value)
max_adjust = (min_thrust - -1.0) * percent
# back_value -= max_adjust
front_left_value -= max_adjust
front_right_value -= max_adjust
self.set_motor(VC, back_value)
self.set_motor(VL, front_left_value)
self.set_motor(VR, front_right_value)
def update_button(self, button, value):
if button == UP:
self.light = min(1.0, self.light + LIGHT_STEP)
elif button == DOWN:
self.light = max(0.0, self.light - LIGHT_STEP)
elif button == RESET:
self.light = 0.0
light_value = map_range(self.light, 0.0, 1.0, -1.0, 1.0)
print("button %s, light = %s, light_value = %s" % (button, self.light, light_value))
self.set_motor(LIGHT, light_value)
def set_motor(self, motor_number, value):
if self.motor_controller is not None:
motor = self.motor_controller.devices[motor_number]
value = self.apply_sensitivity(value)
pwm_value = int(map_range(value, -1.0, 1.0, FULL_REVERSE, FULL_FORWARD))
# print("setting motor {0} to {1}".format(motor_number, pwm_value))
motor.off = pwm_value
def apply_sensitivity(self, value):
return self.sensitivity * value**self.power + (1.0 - self.sensitivity) * value
def get_settings(self):
return {
'version': 1,
'sensitivity': {
'strength': self.sensitivity,
'power': self.power
},
'thrusters': [
self.horizontal_left.to_array(),
self.vertical_left.to_array(),
self.vertical_center.to_array(),
self.vertical_right.to_array(),
self.horizontal_right.to_array()
]
}
def set_settings(self, data, save=True):
if data['version'] == 1:
# save settings for future loading
if save:
if data['name'] == "":
filename = SETTINGS_FILE
else:
filename = os.path.join("settings", data['name'] + ".json")
with open(filename, 'w') as out:
out.write(json.dumps(data, indent=2))
# update current settings
self.sensitivity = float(data['sensitivity']['strength'])
self.power = float(data['sensitivity']['power'])
self.horizontal_left.from_array(data['thrusters'][0])
self.vertical_left.from_array(data['thrusters'][1])
self.vertical_center.from_array(data['thrusters'][2])
self.vertical_right.from_array(data['thrusters'][3])
self.horizontal_right.from_array(data['thrusters'][4])
else:
print("Unsupported data version number '{}'".format(data['version']))
exit(1)
# Start frame
batch_count = (cag['frame_count'] - start_frame) // cag['batch_size']
if (cag['frame_count'] - 1) % cag['batch_size']:
batch_count += 1
# Setup
sys.path.append(f"{os.path.abspath(cag['algorithm'])}")
from interpolator import Interpolator
# Interpolate
interpolator = Interpolator(
cag['model_path'],
cag['sf'],
int(cag['height']),
int(cag['width']),
batch_size=cag['batch_size'],
net_name=cag['net_name'],
channel=3 # DAIN
)
save = data_writer(cag['output_type'])
ori_frames = []
batch = [None] * (cag['batch_size'])
batch.append(video.read()[1])
interpolator.batch[0] = interpolator.ndarray2tensor([batch[-1]])[0]
timer = 0
start_time = time.time()
try:
for i in range(batch_count):
batch[0] = batch[-1]
batch[1:] = [video.read() for _ in range(cag['batch_size'])]
pp = pd.concat((p, sp))
pp.sort_values(['x','y'], inplace=True)
# log(pp.head().to_string())
# log('\n')
# log(pp.tail().to_string())
log('Pre-processing... ')
pp.drop(pp[pp.r < config.config['min_height']].index, inplace=True)
pp.drop(pp[pp.r > config.config['max_height']].index, inplace=True)
rh_min = 1.6*config.config['cellsize']
pp.loc[pp.rh < rh_min, 'rh'] = rh_min
adj = get_groupies(pp, grad=config.config['gradient'])
log('Done\n')
return pp, adj
if __name__ == "__main__":
from interpolator import Interpolator
from writer import Writer
import config
config.parse()
if len(sys.argv) > 1:
df, adj = prep(fbore=sys.argv[1], fscreen=sys.argv[2], config=config)
w = Writer(sys.argv[3])
i = Interpolator(df, adj, w)
i.interpolate()
else:
df, adj = prep(config=config)
i = Interpolator(df, adj)
i.interpolate()
frame_count = int(cap.get(7))
frame_count_len = len(str(frame_count))
# Setup
if 'Interpolator' not in locals():
if args['empty_cache']:
os.environ['CUDA_EMPTY_CACHE'] = '1'
if args['model_path'] == 'default': # 模型路径
model_path = f"{args['algorithm']}/{model_path[args['algorithm']]}"
# Model checking
if not os.path.exists(model_path):
print(f"Model {model_path} doesn't exist, exiting")
exit(1)
sys.path.append(f"{os.path.abspath(args['algorithm'])}")
from interpolator import Interpolator
# Interpolate
interpolator = Interpolator(model_path, sf, int(cap.get(4)), int(cap.get(3)), batch_size=1,
save_which=1, net_name='DAIN_slowmotion', channel=3)
timer = 0
loss_fn = mse()
start_time = time.time()
batch = [cap.read()[1]]
batch_count = frame_count//sf-1
for i in range(batch_count):
gt = []
for f in [cap.read() for _ in range(sf-1)]:
if f[0]:
gt.append(f[1])
else:
break
f = cap.read()
if f[0]:
del batch[:-1]