def experiment_s_bst():
r = range(start, end, offset)
times = []
for i in r:
times.append(search_bst(i))
plot_data(r, times, "BinarySearchTree", "Search", "n", "time")
def synthesize(model, text, sentence, prefix=''):
src_pos = np.array([i+1 for i in range(text.shape[1])])
src_pos = np.stack([src_pos])
src_pos = torch.from_numpy(src_pos).to(device).long()
model.to(device)
mel, mel_postnet, duration_output, f0_output, energy_output = model(text, src_pos)
model.to('cpu')
mel_torch = mel.transpose(1, 2).detach()
mel_postnet_torch = mel_postnet.transpose(1, 2).detach()
mel = mel[0].cpu().transpose(0, 1).detach()
mel_postnet = mel_postnet[0].cpu().transpose(0, 1).detach()
f0_output = f0_output[0].detach().cpu().numpy()
energy_output = energy_output[0].detach().cpu().numpy()
if not os.path.exists(hp.test_path):
os.makedirs(hp.test_path)
Audio.tools.inv_mel_spec(mel_postnet, os.path.join(hp.test_path, '{}_griffin_lim_{}.wav'.format(prefix, sentence)))
wave_glow = utils.get_WaveGlow()
waveglow.inference.inference(mel_postnet_torch, wave_glow, os.path.join(
hp.test_path, '{}_waveglow_{}.wav'.format(prefix, sentence)))
utils.plot_data([(mel_postnet.numpy(), f0_output, energy_output)], ['Synthesized Spectrogram'], filename=os.path.join(hp.test_path, '{}_{}.png'.format(prefix, sentence)))
def experiment_s_rbt():
r = range(start, end, offset)
times = []
for i in r:
times.append(search_rbt(i))
plot_data(r, times, "RedBlackTree", "Search", "n", "time")
def experiment_w_c_q_s():
r = range(start, end, offset)
times = []
for i in r:
times.append(worst_case_quick_sort(i))
plot_data(r, times, "worst case quick sort", "Sorting", "n", "time")
def experiment_i_rbt():
r = range(start, end, offset)
times = []
for i in r:
times.append(insertion_rbt(i))
plot_data(r, times, "RedBlackTree", "Insertion", "n", "time")
def synthesize(model, waveglow, melgan, text, sentence, prefix=''):
sentence = sentence[:200] # long filename will result in OS Error
src_len = torch.from_numpy(np.array([text.shape[1]])).to(device)
with torch.no_grad():
mel, mel_postnet, log_duration_output, f0_output, energy_output, _, _, mel_len = model(text, src_len)
mel_torch = mel.transpose(1, 2).detach()
mel_postnet_torch = mel_postnet.transpose(1, 2).detach()
mel = mel[0].cpu().transpose(0, 1).detach()
mel_postnet = mel_postnet[0].cpu().transpose(0, 1).detach()
f0_output = f0_output[0].detach().cpu().numpy()
energy_output = energy_output[0].detach().cpu().numpy()
if not os.path.exists(hp.test_path):
os.makedirs(hp.test_path)
Audio.tools.inv_mel_spec(mel_postnet, os.path.join(hp.test_path, '{}_griffin_lim_{}.wav'.format(prefix, sentence)))
if waveglow is not None:
utils.waveglow_infer(mel_postnet_torch, waveglow,
os.path.join(hp.test_path, '{}_{}_{}.wav'.format(prefix, hp.vocoder, sentence)))
if melgan is not None:
utils.melgan_infer(mel_postnet_torch, melgan,
os.path.join(hp.test_path, '{}_{}_{}.wav'.format(prefix, hp.vocoder, sentence)))
utils.plot_data([(mel_postnet.numpy(), f0_output, energy_output)], ['Synthesized Spectrogram'],
filename=os.path.join(hp.test_path, '{}_{}.png'.format(prefix, sentence)))
def test_run():
# Read data
dates = pd.date_range('2009-01-01', '2012-12-31')
symbols = ['SPY']
df = utils.get_data(symbols, dates)
utils.plot_data(df)
# Compute daily returns
daily_returns = utils.compute_daily_returns(df)
utils.plot_data(daily_returns,
title="Daily Returns",
ylabel="Daily Returns")
# Plot a histogram
daily_returns.hist(bins=20)
# Get mean and standard deviation
mean = daily_returns['SPY'].mean()
print("mean=", mean)
std = daily_returns['SPY'].std()
plt.axvline(mean, color="w", linestyle="dashed", linewidth=2)
plt.axvline(std, color="r", linestyle="dashed", linewidth=2)
plt.axvline(-std, color="r", linestyle="dashed", linewidth=2)
plt.show()
# Compute kurtosis
print(daily_returns.kurtosis())
def lang_cluster_centroids(self, lang_num, cut_small=True):
'''Plots the cluster centroids of the clusters that lang_num is split up into.'''
clust_dist = self._cluster_distribution(num, comp, cut_small)
clust_dist_sort = sorted(clust_dist.items(), key=lambda x: x[1], reverse=True)
grid_size = math.ceil( np.sqrt(len(clust_dist)) )
fig, axarr = plt.subplots(grid_size, grid_size, sharex='col', sharey='row')
i = 0
for r in range(grid_size):
for c in range(grid_size):
if i < len(clust_dist_sort):
data = self.group_centers[clust_dist_sort[i][0]].reshape((8,40))
u.plot_data(data, ax=axarr[r,c], word_labels=False, stim_labels=False, yaxis_label=False, xaxis_label=False, title=True, title_name=str(clust_dist_sort[i][1]))
i += 1
else:
axarr[r,c].axis("off")
plt.tight_layout()
image_path = path.abspath(path.join("Boundary Analysis", "Heatmaps", self.save_path))
if not path.exists(image_path):
mkdir(image_path)
if cut_small:
image_name = comp.capitalize() + str(num) + "_centroids_remove_small.png"
else:
image_name = comp.capitalize() + str(num) + "_centroids.png"
plt.savefig(path.join(image_path, image_name))
plt.close()
def experiment_i_bst():
r = range(start, end, offset)
times = []
for i in r:
times.append(insertion_bst(i))
plot_data(r, times, "BinarySearchTree", "Insertion", "n", "time")
def test_run():
#read data
dates = pd.date_range('1990-05-01', '2016-09-30')
symbols = ['01', '02', '03', '04']
df = pt.get_data(symbols, dates)
fill_missing_data(df)
pt.plot_data(df)
def plot_group_numbers(self, save_fig=True):
'''Plots the group centroids of the resulting clusters using the cluster index as the header of each subfigure. This representation
is useful when generating a key for MDS plots.'''
grid_size = math.ceil( np.sqrt(len(self.groups)) )
fig, axarr = plt.subplots(grid_size, grid_size, sharex='col', sharey='row')
weights = [self.r[i] for i in np.unique(self.c_assign)] #remove non-existent groups
sort_weights = sorted(weights, reverse=True)
index_list = []
for w in sort_weights:
indices = np.where(weights == w)[0]
index_list.extend(indices)
i = 0
for r in range(grid_size):
for c in range(grid_size):
if i < len(self.groups):
group = self.groups[index_list[i]]
data = self.group_centers[index_list[i]].reshape((8,40))
u.plot_data(data, ax=axarr[r,c], word_labels=False, stim_labels=False, yaxis_label=False, xaxis_label=False, title=True, title_name=str(index_list[i]))
i += 1
else:
axarr[r,c].axis("off")
plt.tight_layout()
if save_fig:
plt.savefig(self.save_path + "_wgrpnum.png")
plt.show()
plt.close()
def plot_alignment():
in_dir = '../self_alignment/alignments'
t2_in_dir = '../alignments'
for num in range(20):
fname = str(num) + ".npy"
a = np.load(os.path.join(in_dir, fname))
align = np.zeros((a.shape[0], a.sum()), dtype=float)
last = 0
for i in range(len(a)):
num = a[i]
for j in range(num):
pos = last + j
align[i][pos] = 1.0
last = num + last
t2a = np.load(os.path.join(t2_in_dir, fname))
t2align = np.zeros((t2a.shape[0], t2a.sum()), dtype=float)
last = 0
for i in range(len(t2a)):
num = t2a[i]
for j in range(num):
pos = last + j
t2align[i][pos] = 1.0
last = num + last
utils.plot_data([align, t2align], fname)
def train_with_gradient_descent(dataset):
learning_rate = 0.01
n_iter = 5000
n_samples = len(dataset)
# w0, w1 = random.uniform(-1, 1), random.uniform(-1, 1)
w0, w1 = 0, 0
loss_val = loss(dataset, w0, w1)
print('initial loss={}'.format(loss_val))
for t in range(n_iter):
grad_w0, grad_w1 = 0, 0
for x, y in dataset:
y_pred = linear_pred(x, w0, w1)
grad_w0 += y_pred - y
grad_w1 += x * (y_pred - y)
grad_w0 *= 2 / n_samples
grad_w1 *= 2 / n_samples
w0 = w0 - learning_rate * grad_w0
w1 = w1 - learning_rate * grad_w1
loss_val = loss(dataset, w0, w1)
if (t + 1) % 500 == 0:
print('iter {}, loss={}'.format(t + 1, loss_val))
plot_data(dataset, (w0, w1))
def synthesize(model, waveglow, melgan, text, sentence, prefix=''):
sentence = sentence[:10] # long filename will result in OS Error
mean_mel, std_mel = torch.tensor(np.load(
os.path.join(hp.preprocessed_path, "mel_stat.npy")),
dtype=torch.float).to(device)
mean_f0, std_f0 = torch.tensor(np.load(
os.path.join(hp.preprocessed_path, "f0_stat.npy")),
dtype=torch.float).to(device)
mean_energy, std_energy = torch.tensor(np.load(
os.path.join(hp.preprocessed_path, "energy_stat.npy")),
dtype=torch.float).to(device)
mean_mel, std_mel = mean_mel.reshape(1, -1), std_mel.reshape(1, -1)
mean_f0, std_f0 = mean_f0.reshape(1, -1), std_f0.reshape(1, -1)
mean_energy, std_energy = mean_energy.reshape(1, -1), std_energy.reshape(
1, -1)
src_len = torch.from_numpy(np.array([text.shape[1]])).to(device)
mel, mel_postnet, log_duration_output, f0_output, energy_output, _, _, mel_len = model(
text, src_len)
mel_torch = mel.transpose(1, 2).detach()
mel_postnet_torch = mel_postnet.transpose(1, 2).detach()
f0_output = f0_output[0]
energy_output = energy_output[0]
mel_torch = utils.de_norm(mel_torch.transpose(1, 2), mean_mel, std_mel)
mel_postnet_torch = utils.de_norm(mel_postnet_torch.transpose(1, 2),
mean_mel, std_mel).transpose(1, 2)
f0_output = utils.de_norm(f0_output, mean_f0,
std_f0).squeeze().detach().cpu().numpy()
energy_output = utils.de_norm(energy_output, mean_energy,
std_energy).squeeze().detach().cpu().numpy()
if not os.path.exists(hp.test_path):
os.makedirs(hp.test_path)
Audio.tools.inv_mel_spec(
mel_postnet_torch[0],
os.path.join(hp.test_path,
'{}_griffin_lim_{}.wav'.format(prefix, sentence)))
if waveglow is not None:
utils.waveglow_infer(
mel_postnet_torch, waveglow,
os.path.join(hp.test_path,
'{}_{}_{}.wav'.format(prefix, hp.vocoder, sentence)))
if melgan is not None:
utils.melgan_infer(
mel_postnet_torch, melgan,
os.path.join(hp.test_path,
'{}_{}_{}.wav'.format(prefix, hp.vocoder, sentence)))
utils.plot_data([
(mel_postnet_torch[0].detach().cpu().numpy(), f0_output, energy_output)
], ['Synthesized Spectrogram'],
filename=os.path.join(hp.test_path,
'{}_{}.png'.format(prefix,
sentence)))
def main(args):
# read training data
data_frame_train = pd.read_csv(args.trainpath, dtype=np.uint8, header=None)
NUM_TRAIN = data_frame_train.shape[0]
NUM_PIXELS = data_frame_train.shape[1] - 1
# read test data
data_frame_test = pd.read_csv(args.testpath, dtype=np.uint8, header=None)
NUM_TEST = data_frame_test.shape[0]
# reformat data
[images_train, labels_train] = reformat_data(data_frame_train)
[images_test, labels_test] = reformat_data(data_frame_test)
# plot data as sanity check
plot_data(images_train)
if (args.algorithm == 'B'):
predictBinomial(images_train, images_test, labels_train, labels_test)
elif (args.algorithm == 'G_gray'):
predictGrayscale(images_train, images_test, labels_train, labels_test)
elif (args.algorithm == 'G_pca'):
predictPCA(images_train, images_test, labels_train, labels_test)
elif (args.algorithm == 'G_hog'):
predictHoG(images_train, images_test, labels_train, labels_test)
def experiment_a_c_i_s():
r = range(start, end, offset)
times = []
for i in r:
times.append(avg_case_insertion_sort(i))
plot_data(r, times, "average case insertion sort", "Sorting", "n", "time")
def experiment_mst_prim(filename, p):
r = range(start, end, offset)
times = []
for i in r:
times.append(uniform_graph_mst_prim(i, filename, p))
plot_data(r, times, "Prim", "Minimum Spanning Tree P={}".format(p), "n",
"time", filepath + format_p(p) + 'mstprim.png')
def test_run(): port_vals, daily_returns, cum_ret, sharpe_ratio = portfolio_stats(1000000, ['SPY', 'XOM', 'GOOG', 'GLD'], [.4, .4, .1, .1]) print 'Cumulative return:', cum_ret print 'Average daily return:', daily_returns.mean() print 'Risk (daily std):', daily_returns.std() print 'Sharpe ratio:', sharpe_ratio plot_data(port_vals, title='Portfolio value', ylabel='Portfolio value')
def experiment_cc(filename, p):
r = range(start, end, offset)
times = []
for i in r:
times.append(connected_components(i, filename, p))
plot_data(r, times, "Connected Components",
"Connected Components P={}".format(p), "n", "time",
filepath + format_p(p) + 'conncomponents.png')
def test_run():
# Read data
dates = pd.date_range('2010-01-01', '2012-12-31')
symbols = ['SPY', 'XOM', 'GOOG', 'GLD']
df = utils.get_data(symbols, dates)
utils.plot_data(df)
#Compute global statistic for each stock
print(df.mean())
def test_run():
# Read data
dates = pd.date_range('2000-01-01', '2012-12-31')
symbols = ['SPY']
df = get_data(symbols, dates)
plot_data(df)
#Compute daily returns
daily_returns = compute_daily_returns(df)
plot_data(daily_returns, title ="Daily returns", ylabel="Daily returns")
def test_run():
# Read data
dates = pd.date_range('2016-07-01', '2016-07-31') # one month only
symbols = ['01', '02']
df = pt.get_data(symbols, dates)
pt.plot_data(df)
# Compute daily returns
daily_returns = compute_daily_returns_with_pandas(df)
pt.plot_data(daily_returns, title="Daily returns", ylabel="Daily returns")
def plot_last_trace(self):
'''
Method for plotting the most recent trace (if it exists)
'''
if self.last_trace:
try:
utils.plot_data(self.last_trace)
except:
print(f"Cannot find trace {file_to_open}")
else:
print("No trace acquired in this session")
def p05_how_to_plot_a_histogram():
dates = pd.date_range('2010-01-01', '2018-03-01')
symbols = ['SPY']
df = get_data(symbols, dates)
plot_data(df)
dr = compute_daily_returns(df)
plot_data(dr,
title='Daily Returns of {}'.format(symbols),
xlabel='Date',
ylabel='ratio')
dr.hist(bins=200)
plt.show()
def sample_evolution(start, ns=100): # start = start data
sample = t.compile_function(initial_vmap, mb_size=1, monitors=[m_model], name='evaluate', train=False, mode=mode)
data = start
plot_data(data)
while True:
for k in range(ns):
for x in sample({ rbm.v: data }): # draw a new sample
data = x[0]
plot_data(data)
def plot_file(self):
'''
Method for plotting a file as selected by the user
'''
# open up a filedialog to let the user navigate to the appropriate file
fpath = filedialog.askopenfilename()
if fpath:
# if they want to display with FFT
if self.fft_check_value.get():
utils.plot_data_with_fft(fpath)
else:
utils.plot_data(fpath)
def main():
n = 200
batch_n = 16
epochs = 500
learning_rate = 0.003
reg_constant = 1
x, y = create_data_2(n)
sgd = BatchSGD(learning_rate, reg_constant)
newton = Newton(learning_rate, reg_constant)
plot_data(
[sgd.weight, newton.weight],
['SGD classification', 'Newton classification'],
x, y,
'weights_data_before'
)
sgd_loss_hist = []
newton_loss_hist = []
for epoch in range(epochs):
i = 0
while i < n:
newton.fit(x[i:min(i+batch_n, n)], y[i:min(i+batch_n, n)])
sgd.fit(x[i:min(i+batch_n, n)], y[i:min(i+batch_n, n)])
i += batch_n
loss, accuracy = sgd.evaluate(x, y)
sgd_loss_hist.append(loss)
loss, accuracy = newton.evaluate(x, y)
newton_loss_hist.append(loss)
plot_data(
[sgd.weight, newton.weight],
['SGD classification', 'Newton classification'],
x, y,
'weights_data_after'
)
plot_loss(
[sgd_loss_hist, newton_loss_hist],
['Batch SGD loss', 'Newton loss'],
'sgd_vs_newton'
)
loss, accuracy = sgd.evaluate(x, y)
print(
'SGD evaluation__________\nLoss\t: {:2.4f}\nAccuracy: {:2.4f}'.format(
loss, accuracy)
)
loss, accuracy = newton.evaluate(x, y)
print()
print(
'Newton evaluation_______\nLoss\t: {:2.4f}\nAccuracy: {:2.4f}'.format(
loss, accuracy)
)
def test_run():
# Read data
dates = pd.date_range('2012-07-01', '2012-07-31')
symbols = ['SPY', 'XOM']
df = utils.get_data(symbols, dates)
# utils.plot_data(df)
# Compute daily return
# daily_returns = utils.compute_daily_returns(df)
# utils.plot_data(daily_returns, title="Daily returns", ylabel="Daily returns")
# print(df)
# print(df[:-1].values)
cumulative_returns = utils.compute_cumulative_returns(df)
utils.plot_data(cumulative_returns,
title="Cumulative returns",
ylabel="Cumulative returns")
def test_run():
start_date = '2010-01-01'
end_date = '2010-12-31'
dates = pd.date_range(start_date, end_date)
#Read in more stocks
symbols = ['GOOG', 'IBM', 'GLD']
df = utils.get_data(symbols, dates)
# Slice by row range (dates) using DataFrame.ix[] selector
# print(df.ix['2010-01-01':'2010-01-31'])
# Slice by column (symbols)
# print(df[GOOG'] # a single label selects a single column
# print(df[['IBM','GLD']]) # a list of labels seleccts multiple columns
# Slice by row and column
# print(df.ix['2010-03-10':'2010-03-15', ['SPY', 'IBM']])
utils.plot_data(utils.normalize_data(df))
def synthesize(model, condition, index):
# long filename will result in OS Error
src_len = torch.from_numpy(np.array([condition.shape[1]])).to(device)
condition = condition[np.newaxis, :, :]
condition = torch.LongTensor(condition).to(device).transpose(1, 2)
# print(condition)
ap_output, sp_output, sp_postnet_output, log_duration_output, f0_output, energy_output, src_mask, ap_mask, sp_mask, variance_adaptor_output, decoder_output = model(
condition, src_len)
length = min(ap_output.shape[1], sp_output.shape[1], f0_output.shape[1])
ap = ap_output[0, :length].detach().cpu().double().numpy()
sp = sp_output[0, :length].detach().cpu().double().numpy()
sp_postnet = sp_postnet_output[0, :length].detach().cpu().double().numpy()
f0_output = f0_output[0, :length].detach().cpu().double().numpy()
energy_output = energy_output[0, :length].detach().cpu().numpy()
print(condition.transpose(1, 2)[0][2])
print(log_duration_output)
# print(ap.shape,sp_postnet.shape,f0_output.shape)
# return utils.world_infer()
# y=untils.world_infer()
# if not os.path.exists(hp.test_path):
# os.makedirs(hp.test_path)
# Audio.tools.inv_mel_spec(mel_postnet, os.path.join(hp.test_path, '{}_griffin_lim_{}.wav'.format(prefix, sentence)))
# if hp.vocoder=='waveglow':
# melgan = utils.get_melgan()
# melgan.to(device)
# utils.waveglow_infer(mel_postnet_torch, waveglow, os.path.join(hp.test_path, '{}_{}_{}.wav'.format(prefix, hp.vocoder, sentence)))
# if hp.vocoder=='melgan':
# waveglow = utils.get_waveglow()
# waveglow.to(device)
# utils.melgan_infer(mel_postnet_torch, melgan, os.path.join(hp.test_path, '{}_{}_{}.wav'.format(prefix, hp.vocoder, sentence)))
y = utils.world_infer(ap, sp, f0_output)
sp_postnet = np.swapaxes(sp_postnet, 0, 1)
utils.plot_data([(sp_postnet, f0_output, energy_output)],
['Synthesized Spectrogram'],
filename=os.path.join(hp.test_path,
'out_%03d.png' % index))
return y
from keras.models import Sequential
from keras.layers import Dense
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.model_selection import train_test_split
import utils
X, y = make_classification(n_samples=1000, n_features=2, n_redundant=0, \
n_informative=2, random_state=0, n_clusters_per_class=1)
print(X.shape)
X_train, X_validation, y_train, y_validation = train_test_split(X, y, test_size=0.33, random_state=100)
print(X_train.shape)
print(X_validation.shape)
utils.plot_data(X_train, y_train)
#perceptron model for binary classification
model = Sequential()
model.add(Dense(units=1, input_shape=(2,), activation='sigmoid'))
model.compile(optimizer='sgd', loss='mean_squared_error', metrics=['accuracy'])
history = model.fit(x=X_train, y=y_train, verbose=3, epochs=1000, validation_data=(X_validation,y_validation), batch_size=10)
print(model.summary())
print(model.get_weights())
historydf = pd.DataFrame(history.history, index=history.epoch)
utils.plot_loss_accuracy(history)
def main(argv=None):
if argv is not None:
sys.argv = argv
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("-d", "--directory", default="featuredatas-json",
help="feature data location (default featuredatas-json)")
parser.add_argument("-n", "--num-particles", type=int, default=1000,
help="number of particles to simulate (default 1000)")
parser.add_argument("--range-noise", type=float, default=3.0,
help="range prediction noise (default 3.0m)")
parser.add_argument("--angle-noise", type=float, default=3.0,
help="angle prediction noise (default 3.0 degrees)")
parser.add_argument("--range-resolution", type=float, default=3.0,
help="range resolution of the sensor (default 3.0m)")
parser.add_argument("--angular-resolution", type=float, default=1.5,
help="angular sensor resolution (default 1.5 degrees)")
parser.add_argument("-t", "--timeout", type=float, default=0.01,
help="seconds to wait between pings (default 0.01s)")
parser.add_argument("-r", "--fov-range", type=float, default=500.0,
help="range of the field of view (default 500.0m)")
parser.add_argument("-a", "--fov-hor-angle", type=float, default=90.0,
help="number of degrees in field of view (default 90.0)")
parser.add_argument("-m", "--hide-measurements", action="store_true",
help="hide measurements in the particle plot")
parser.add_argument("--save-figure", action="store_true",
help="save figure frames as images")
parser.add_argument("--write-latlon", action="store_true",
help=("Save diver position estimates as"
"lat/lon's to a file"))
args = parser.parse_args()
if not os.path.isdir(args.directory):
sys.stdout.write("Could not find the {} directory!".format(args.directory))
return
if args.save_figure and not os.path.isdir("images"):
os.makedirs("images")
if args.write_latlon:
latlon_file = open("diver_position_estimates.txt", 'w')
# This assumes the input directory is of the form *-<data_format> where
# <data_format> is either 'proto' or 'json'.
data_format = args.directory.split('-')[-1]
# Read first data file to get position for drawing initialization.
feature_data = get_first_feature_data(args.directory, data_format)
init_position = SensorPosition(feature_data.position.lat,
feature_data.position.lon,
feature_data.heading.heading)
# Initialize plot.
plt.ion()
fig = plt.figure()
particle_plot = fig.add_subplot(111)
# Accumulated x- and y-dispalcement of sensor (ship) in meters re starting
# position.
acc_dx, acc_dy = 0.0, 0.0
# Initialize our particles.
particles = []
for i in range(args.num_particles):
particles.append(Particle(args.fov_range, args.fov_hor_angle,
args.range_noise, args.angle_noise,
args.range_resolution, args.angular_resolution))
# Collection of filtered position computed from posterior particles.
filtered_xs, filtered_ys = [], []
particle_xs, particle_ys = utils.get_particle_positions(
particles, acc_dx, acc_dy, init_position.heading)
utils.plot_data(particle_xs, particle_ys, filtered_xs, filtered_ys, [], -1,
True, acc_dx, acc_dy, init_position.heading, particle_plot)
plt.draw()
# Pump.
last_position = None
for i, feature_data in enumerate(
get_feature_datas(args.directory, data_format)):
current_position = SensorPosition(feature_data.position.lat,
feature_data.position.lon,
feature_data.heading.heading)
dx, dy = 0.0, 0.0
if last_position is not None:
dx, dy = utils.compute_sensor_movement(last_position, current_position)
for particle in particles:
particle.move(last_position, current_position, dx, dy)
acc_dx += dx
acc_dy += dy
measurements = get_measurements(feature_data)
new_weights = get_weights(particles, measurements)
if new_weights:
weights = new_weights
particles = resample_particles(particles, weights)
particle_xs, particle_ys = utils.get_particle_positions(
particles, acc_dx, acc_dy, current_position.heading)
filtered_x, filtered_y = utils.extract_position_from_particles(
particle_xs, particle_ys)
filtered_lat, filtered_lon = geo.add_offsets_to_latlons(
current_position, filtered_x - acc_dx, filtered_y - acc_dy)
filtered_xs.append(filtered_x)
filtered_ys.append(filtered_y)
last_position = current_position
utils.plot_data(particle_xs, particle_ys, filtered_xs, filtered_ys,
measurements, i, args.hide_measurements, acc_dx, acc_dy,
current_position.heading, particle_plot)
plt.draw()
if args.save_figure:
plt.savefig("images//%03d.png" % i, format='png')
if args.write_latlon:
latlon_file.write(
"%d,%0.9f,%0.9f\n" % (utils.date_to_sec(
feature_data.time), filtered_lat, filtered_lon))
latlon_file.flush()
time.sleep(args.timeout)
if args.write_latlon:
latlon_file.close()
