def plot_sizes_by_track(tracks_df, pes=True):
prefix = 'pes' if pes else 'manus'
limb_ids = ['lp', 'rp'] if pes else ['lm', 'rm']
length_measurements = cd.shared.to_measurements(tracks_df, limb_ids, 'l')
length_dist = mstats.create_distribution(
[x for x in length_measurements if x.value > 0])
pop = mstats.distributions.population(length_dist)
length_median = mstats.ValueUncertainty(
mstats.distributions.percentile(pop),
mstats.distributions.weighted_median_average_deviation(pop))
width_measurements = cd.shared.to_measurements(tracks_df, limb_ids, 'w')
width_dist = mstats.create_distribution(
[x for x in width_measurements if x.value > 0])
pop = mstats.distributions.population(width_dist)
width_median = mstats.ValueUncertainty(
mstats.distributions.percentile(pop),
mstats.distributions.weighted_median_average_deviation(pop))
label = prefix.capitalize()
cd.display.plotly(
[
cd.shared.create_density_trace(length_dist, 0, 'Length'),
cd.shared.create_density_trace(width_dist, 1, 'Width'),
],
plotting.create_layout(
{},
title='{} Width & Length Distributions (by track)'.format(label),
x_label='Size (m)',
y_label='Probability Density'))
print('Median {} Width: {}m'.format(label, width_median.label))
print('Median {} Length: {}m'.format(label, length_median.label))
def test_no_overlap(self):
"""
"""
dist = mstats.create_distribution([-2000], [1.0])
comp = mstats.create_distribution([2000], [1.0])
result = mstats.distributions.overlap2(dist, comp)
self.assertAlmostEqual(result.value, 0)
def test_perfect_overlap(self):
""" """
values = [1, 1]
uncertainties = [0.5, 0.5]
measurements = mstats.values.join(values, uncertainties)
dist = mstats.create_distribution(measurements)
comp = mstats.create_distribution(
[mstats.ValueUncertainty(values[0], uncertainties[0])])
result = mstats.distributions.overlap2(dist, comp)
self.assertEqual(result.value, 1.0)
def test_low_overlap(self):
"""
"""
values = [-10, 2, 20]
uncertainties = [0.5, 0.5, 0.5]
measurements = mstats.values.join(values, uncertainties)
dist = mstats.create_distribution(measurements)
comp = mstats.create_distribution(
[mstats.mean.weighted_mean_and_deviation(measurements)])
result = mstats.distributions.overlap2(dist, comp)
self.assertGreater(result.value, 0.3)
def test_perfect_overlap(self):
""" """
values = [1, 1]
uncertainties = [0.5, 0.5]
measurements = mstats.values.join(values, uncertainties)
dist = mstats.create_distribution(measurements)
comp = mstats.create_distribution(
[mstats.ValueUncertainty(values[0], uncertainties[0])]
)
result = mstats.distributions.overlap2(dist, comp)
self.assertEqual(result.value, 1.0)
def test_low_overlap(self):
"""
"""
values = [-10, 2, 20]
uncertainties = [0.5, 0.5, 0.5]
measurements = mstats.values.join(values, uncertainties)
dist = mstats.create_distribution(measurements)
comp = mstats.create_distribution(
[mstats.mean.weighted_mean_and_deviation(measurements)]
)
result = mstats.distributions.overlap2(dist, comp)
self.assertGreater(result.value, 0.3)
def plot_pes_aspects(trackway_df):
measurements = mstats.values.join(
trackway_df['pes_aspect'].tolist(),
trackway_df['pes_daspect'].tolist()
)
dist = mstats.create_distribution(
[x for x in measurements if x.value > 0]
)
pop = mstats.distributions.population(dist)
median = mstats.ValueUncertainty(
mstats.distributions.percentile(pop),
mstats.distributions.weighted_median_average_deviation(pop)
)
cd.display.plotly(
cd.shared.create_density_trace(dist),
plotting.create_layout(
{},
title='Pes Aspect Ratio Distribution (by trackway)',
x_label='Aspect Ratio (width / length)',
y_label='Probability Density'
)
)
print('Median Pes Aspect Ratio:', median.label)
def get_weighted_median(quantities) -> mstats.ValueUncertainty:
dist = mstats.create_distribution(quantities)
pop = mdist.population(dist)
return mstats.ValueUncertainty(
mdist.percentile(pop, 0.5),
max(0.00001, mdist.weighted_median_average_deviation(pop))
)
def plot_pes_aspects_by_tracks(tracks_df):
widths = cd.shared.to_measurements(tracks_df, ['lp', 'rp'], 'w')
lengths = cd.shared.to_measurements(tracks_df, ['lp', 'rp'], 'l')
measurements = [l / w for l, w in zip(lengths, widths)]
dist = mstats.create_distribution(
[x for x in measurements if x.value > 0]
)
pop = mstats.distributions.population(dist)
median = mstats.ValueUncertainty(
mstats.distributions.percentile(pop),
mstats.distributions.weighted_median_average_deviation(pop)
)
cd.display.plotly(
cd.shared.create_density_trace(dist),
plotting.create_layout(
{},
title='Pes Aspect Ratio Distribution (by track)',
x_label='Aspect Ratio (width / length)',
y_label='Probability Density'
)
)
print('Median Pes Aspect Ratio:', median.label)
def compute_normality_weighted(
key: str,
trackway_df: pd.DataFrame
) -> mstats.ValueUncertainty:
dist = to_distribution(key, trackway_df)
mean = mstats.mean.weighted(*dist.measurements)
comparison = mstats.create_distribution([mean])
return 1.0 - mstats.distributions.overlap2(dist, comparison)
def plot_sizes(trackway_df, pes=True):
prefix = 'pes' if pes else 'manus'
length_measurements = mstats.values.join(
trackway_df['{}_l'.format(prefix)].tolist(),
trackway_df['{}_dl'.format(prefix)].tolist()
)
length_dist = mstats.create_distribution(
[x for x in length_measurements if x.value > 0]
)
pop = mstats.distributions.population(length_dist)
length_median = mstats.ValueUncertainty(
mstats.distributions.percentile(pop),
mstats.distributions.weighted_median_average_deviation(pop)
)
width_measurements = mstats.values.join(
trackway_df['{}_w'.format(prefix)].tolist(),
trackway_df['{}_dw'.format(prefix)].tolist()
)
width_dist = mstats.create_distribution(
[x for x in width_measurements if x.value > 0]
)
pop = mstats.distributions.population(width_dist)
width_median = mstats.ValueUncertainty(
mstats.distributions.percentile(pop),
mstats.distributions.weighted_median_average_deviation(pop)
)
label = prefix.capitalize()
cd.display.plotly(
[
cd.shared.create_density_trace(length_dist, 0, 'Length'),
cd.shared.create_density_trace(width_dist, 1, 'Width'),
],
plotting.create_layout(
{},
title='{} Width & Length Distributions (by trackway)'.format(label),
x_label='Size (m)',
y_label='Probability Density'
)
)
print('Median {} Width: {}m'.format(label, width_median.label))
print('Median {} Length: {}m'.format(label, length_median.label))
def get_median(
quantities: typing.List[mstats.ValueUncertainty]
) -> mstats.ValueUncertainty:
dist = mstats.create_distribution(quantities)
pop = mdist.population(dist)
return mstats.ValueUncertainty(
mdist.percentile(pop, 0.5),
max(0.00001, mdist.weighted_median_average_deviation(pop))
)
def calculate_median(values, uncertainties, color_index=0, plot_name=None):
"""
:param values:
:param uncertainties:
:param color_index:
:param plot_name:
:return:
"""
try:
values = values.values
except:
pass
try:
uncertainties = uncertainties.values
except:
pass
measurements = [
(val, unc) for val, unc in zip(values, uncertainties)
if not np.isnan(val) and not np.isnan(unc)
]
values, uncertainties = zip(*measurements)
measurements = mstats.values.join(values, uncertainties)
dist = mstats.create_distribution(measurements)
pop = mdist.population(dist)
median = mstats.ValueUncertainty(
mdist.percentile(pop),
mdist.weighted_median_average_deviation(pop)
)
x = mdist.adaptive_range(dist, 4)
y = dist.probabilities_at(x)
trace = go.Scatter(
x=x,
y=y,
name=plot_name,
fill='tozeroy',
mode='lines',
line=dict(
color=plotting.get_color(color_index)
)
)
return dict(
measurements=measurements,
median=median,
trace=trace
)
def plot_sizes_by_track(tracks_df, pes=True):
prefix = 'pes' if pes else 'manus'
limb_ids = ['lp', 'rp'] if pes else ['lm', 'rm']
length_measurements = cd.shared.to_measurements(tracks_df, limb_ids, 'l')
length_dist = mstats.create_distribution(
[x for x in length_measurements if x.value > 0]
)
pop = mstats.distributions.population(length_dist)
length_median = mstats.ValueUncertainty(
mstats.distributions.percentile(pop),
mstats.distributions.weighted_median_average_deviation(pop)
)
width_measurements = cd.shared.to_measurements(tracks_df, limb_ids, 'w')
width_dist = mstats.create_distribution(
[x for x in width_measurements if x.value > 0]
)
pop = mstats.distributions.population(width_dist)
width_median = mstats.ValueUncertainty(
mstats.distributions.percentile(pop),
mstats.distributions.weighted_median_average_deviation(pop)
)
label = prefix.capitalize()
cd.display.plotly(
[
cd.shared.create_density_trace(length_dist, 0, 'Length'),
cd.shared.create_density_trace(width_dist, 1, 'Width'),
],
plotting.create_layout(
{},
title='{} Width & Length Distributions (by track)'.format(label),
x_label='Size (m)',
y_label='Probability Density'
)
)
print('Median {} Width: {}m'.format(label, width_median.label))
print('Median {} Length: {}m'.format(label, length_median.label))
def calculate_median_value(values):
if not values or not len(values):
return dict(values=[],
dist=None,
pop=None,
median=mstats.ValueUncertainty(0, 0.0001))
dist = mstats.create_distribution(values)
pop = mdist.population(dist)
median = mstats.ValueUncertainty(
mdist.percentile(pop), mdist.weighted_median_average_deviation(pop))
return dict(values=values, dist=dist, pop=pop, median=median)
def plot_sizes(trackway_df, pes=True):
prefix = 'pes' if pes else 'manus'
length_measurements = mstats.values.join(
trackway_df['{}_l'.format(prefix)].tolist(),
trackway_df['{}_dl'.format(prefix)].tolist())
length_dist = mstats.create_distribution(
[x for x in length_measurements if x.value > 0])
pop = mstats.distributions.population(length_dist)
length_median = mstats.ValueUncertainty(
mstats.distributions.percentile(pop),
mstats.distributions.weighted_median_average_deviation(pop))
width_measurements = mstats.values.join(
trackway_df['{}_w'.format(prefix)].tolist(),
trackway_df['{}_dw'.format(prefix)].tolist())
width_dist = mstats.create_distribution(
[x for x in width_measurements if x.value > 0])
pop = mstats.distributions.population(width_dist)
width_median = mstats.ValueUncertainty(
mstats.distributions.percentile(pop),
mstats.distributions.weighted_median_average_deviation(pop))
label = prefix.capitalize()
cd.display.plotly(
[
cd.shared.create_density_trace(length_dist, 0, 'Length'),
cd.shared.create_density_trace(width_dist, 1, 'Width'),
],
plotting.create_layout(
{},
title='{} Width & Length Distributions (by trackway)'.format(
label),
x_label='Size (m)',
y_label='Probability Density'))
print('Median {} Width: {}m'.format(label, width_median.label))
print('Median {} Length: {}m'.format(label, length_median.label))
def add_to_group(
segment: Segment,
groups: SegmentGroupList,
trackway_data: dict
) -> SegmentGroupList:
"""
:param segment:
:param groups:
:param trackway_data:
:return:
"""
deviations = [deviation_between(g, segment) for g in groups]
if not deviations or min(deviations) > 2:
return groups + [SegmentGroup(
index=len(groups),
segments=[segment],
median=segment.median,
normalized_median=segment.median / trackway_data['width_median']
)]
group_index = deviations.index(min(deviations))
group = groups[group_index]
cauldron.step.breathe()
dist = mstats.create_distribution([s.median for s in group.segments])
pop = mdist.population(dist)
median = mstats.ValueUncertainty(
mdist.percentile(pop, 0.5),
max(0.00001, mdist.weighted_median_average_deviation(pop))
)
normalized = median / trackway_data['width_median']
replacement_group = SegmentGroup(
index=group.index,
median=median,
segments=group.segments + [segment],
normalized_median=normalized
)
return (
groups[:group_index] +
[replacement_group] +
groups[(group_index + 1):]
)
def calculate_widths(name, df, progress):
cd.display.status('Calculating Width Values', progress=progress)
values = mstats.values.join(df['w'].tolist(), df['dw'].tolist())
dist = mstats.create_distribution(values)
mean_weighted = mstats.mean.weighted(values)
return dict(trackway=name,
mean=mstats.mean.unweighted(values).raw,
mean_weighted=mean_weighted.value,
mean_weighted_unc=mean_weighted.uncertainty,
median=np.median(df['w']),
median_weighted=mstats.distributions.percentile(dist),
median_weighted_unc=mstats.distributions.
weighted_median_average_deviation(dist))
def calculate_widths(name, df, progress):
cd.display.status('Calculating Width Values', progress=progress)
values = mstats.values.join(df['w'].tolist(), df['dw'].tolist())
dist = mstats.create_distribution(values)
mean_weighted = mstats.mean.weighted(values)
return dict(
trackway=name,
mean=mstats.mean.unweighted(values).raw,
mean_weighted=mean_weighted.value,
mean_weighted_unc=mean_weighted.uncertainty,
median=np.median(df['w']),
median_weighted=mstats.distributions.percentile(dist),
median_weighted_unc=mstats.distributions.weighted_median_average_deviation(dist)
)
def to_distribution(key: str,
trackway_df: pd.DataFrame) -> mstats.Distribution:
"""
Converts a trackway data frame to a measurement distribution for the
specified key
:param key:
Lookup key within the trackway data frame. Assumes that key exists
as a column in the data frame and that the uncertainties for those
values are stored in a column named d{key}.
:param trackway_df:
:return:
A measurement distribution for the selected measurements
"""
return mstats.create_distribution(trackway_df[key].tolist(),
trackway_df['d{}'.format(key)].tolist())
def to_distribution(key: str, trackway_df: pd.DataFrame) -> mstats.Distribution:
"""
Converts a trackway data frame to a measurement distribution for the
specified key
:param key:
Lookup key within the trackway data frame. Assumes that key exists
as a column in the data frame and that the uncertainties for those
values are stored in a column named d{key}.
:param trackway_df:
:return:
A measurement distribution for the selected measurements
"""
return mstats.create_distribution(
trackway_df[key].tolist(),
trackway_df['d{}'.format(key)].tolist()
)
def calculate_median(values, uncertainties, color_index=0, plot_name=None):
"""
:param values:
:param uncertainties:
:param color_index:
:param plot_name:
:return:
"""
try:
values = values.values
except:
pass
try:
uncertainties = uncertainties.values
except:
pass
measurements = [(val, unc) for val, unc in zip(values, uncertainties)
if not np.isnan(val) and not np.isnan(unc)]
values, uncertainties = zip(*measurements)
measurements = mstats.values.join(values, uncertainties)
dist = mstats.create_distribution(measurements)
pop = mdist.population(dist)
median = mstats.ValueUncertainty(
mdist.percentile(pop), mdist.weighted_median_average_deviation(pop))
x = mdist.adaptive_range(dist, 4)
y = dist.probabilities_at(x)
trace = go.Scatter(x=x,
y=y,
name=plot_name,
fill='tozeroy',
mode='lines',
line=dict(color=plotting.get_color(color_index)))
return dict(measurements=measurements, median=median, trace=trace)
def plot_pes_aspects(trackway_df):
measurements = mstats.values.join(trackway_df['pes_aspect'].tolist(),
trackway_df['pes_daspect'].tolist())
dist = mstats.create_distribution([x for x in measurements if x.value > 0])
pop = mstats.distributions.population(dist)
median = mstats.ValueUncertainty(
mstats.distributions.percentile(pop),
mstats.distributions.weighted_median_average_deviation(pop))
cd.display.plotly(
cd.shared.create_density_trace(dist),
plotting.create_layout(
{},
title='Pes Aspect Ratio Distribution (by trackway)',
x_label='Aspect Ratio (width / length)',
y_label='Probability Density'))
print('Median Pes Aspect Ratio:', median.label)
def plot_pes_aspects_by_tracks(tracks_df):
widths = cd.shared.to_measurements(tracks_df, ['lp', 'rp'], 'w')
lengths = cd.shared.to_measurements(tracks_df, ['lp', 'rp'], 'l')
measurements = [l / w for l, w in zip(lengths, widths)]
dist = mstats.create_distribution([x for x in measurements if x.value > 0])
pop = mstats.distributions.population(dist)
median = mstats.ValueUncertainty(
mstats.distributions.percentile(pop),
mstats.distributions.weighted_median_average_deviation(pop))
cd.display.plotly(
cd.shared.create_density_trace(dist),
plotting.create_layout(
{},
title='Pes Aspect Ratio Distribution (by track)',
x_label='Aspect Ratio (width / length)',
y_label='Probability Density'))
print('Median Pes Aspect Ratio:', median.label)
def calculate_median_value(values):
if not values or not len(values):
return dict(
values=[],
dist=None,
pop=None,
median=mstats.ValueUncertainty(0, 0.0001)
)
dist = mstats.create_distribution(values)
pop = mdist.population(dist)
median = mstats.ValueUncertainty(
mdist.percentile(pop),
mdist.weighted_median_average_deviation(pop)
)
return dict(
values=values,
dist=dist,
pop=pop,
median=median
)
def statistics(coupling_positions: typing.Dict[str, list]) -> dict:
"""
:param coupling_positions:
:return:
"""
lengths = coupling_positions['lengths']
lengths = [e.value for e in lengths]
d = mstats.create_distribution(lengths)
bounds = boxes.weighted_two(d)
median = bounds[2]
mad = mstats.distributions.weighted_median_average_deviation(d)
min_value = d.minimum_boundary(3)
max_value = d.maximum_boundary(3)
x_values = mstats.ops.linear_space(min_value, max_value, 250)
rmsd = calculate_rmsd(median, lengths)
swing = calculate_swing(median, lengths)
fitness = math.sqrt(rmsd ** 2 + swing ** 2)
return dict(
value=mstats.value.ValueUncertainty(median, mad),
rmsd=rmsd,
swing=swing,
fitness=fitness,
bounds=bounds,
distribution_profile={
'x': x_values,
'y': d.probabilities_at(x_values)
},
population=mstats.distributions.population(d, 256),
)
import plotly.graph_objs as go
import numpy as np
from cauldron import plotting
from cauldron import project
import measurement_stats as mstats
df = project.shared.measurements
normalized_values = []
traces = []
for key in ['Width-Box', 'Height-Box']:
d = mstats.create_distribution(measurements=df[key].tolist(),
uncertainties=5)
median = mstats.distributions.percentile(d)
normalized = [100.0 * (v / median - 1.0) for v in d.measurements]
normalized_values += normalized
x_values = list(np.arange(1, len(normalized), 1))
y_values, y_uncertainties = mstats.values.unzip(normalized)
traces.append(
go.Bar(x=x_values,
y=y_values,
error_y=dict(type='data', array=y_uncertainties, visible=True),
name=key.split('-')[0],
marker=dict(color=plotting.get_color(len(traces), 0.5))))
d = mstats.create_distribution(normalized_values)
from _Gauge_Quantization import plotting
tracks = cd.shared.tracks # type: pd.DataFrame
trackway_name = cd.shared.TRACKWAY_NAME
unweighted = cd.shared.unweighted
pes_tracks = tracks[tracks['pes'] == 1]
layout = go.Layout(
title='{} Pes Gauge Values Along Trackway'.format(trackway_name),
xaxis={'title': 'Trackway Position (m)'},
yaxis={'title': 'Gauge (m)'}
)
dist = mstats.create_distribution(
pes_tracks['simpleGauge'].tolist(),
pes_tracks['simpleGaugeUnc'].tolist()
)
pop = mstats.distributions.population(dist)
median_value = mstats.distributions.percentile(pop)
mad = mstats.distributions.weighted_median_average_deviation(pop)
median = mstats.ValueUncertainty(median_value, mad)
scatter_trace = plotting.create_scatter(
pes_tracks['curvePosition'],
pes_tracks['simpleGauge'],
pes_tracks['simpleGaugeUnc'],
name='Gauges'
)
median_traces = plotting.make_ranged_quantity_traces(
x_start=pes_tracks['curvePosition'].min(),
variations = df['raw_mad'] / df['raw_median']
cd.display.plotly(
data=go.Histogram(
x=variations
),
layout=plotting.create_layout(
title='Coupling Length Fractional Deviations',
x_label='Fractional Deviation',
y_label='Frequency (#)'
)
)
dist = mstats.create_distribution(
measurements=variations.tolist(),
uncertainties=0.01
)
x = mstats.distributions.uniform_range(dist, 3)
y = dist.probabilities_at(x)
cd.display.plotly(
data=go.Scatter(
x=x,
y=y,
mode='lines',
fill='tozeroy'
),
layout=plotting.create_layout(
title='Coupling Length KDE',
def compute_normality_weighted(
key: str, trackway_df: pd.DataFrame) -> mstats.ValueUncertainty:
dist = to_distribution(key, trackway_df)
mean = mstats.mean.weighted(*dist.measurements)
comparison = mstats.create_distribution([mean])
return 1.0 - mstats.distributions.overlap2(dist, comparison)
def distribution(
df: pd.DataFrame,
segment_min: float = 0,
segment_max: float = 100,
scale_factor: float = 1.0
) -> dict:
"""
:param df:
:param segment_min:
:param segment_max:
:param scale_factor:
:return:
"""
measurements = mstats.values.join(
df['coupling_length'].tolist(),
df['uncertainty'].tolist()
)
dist = mstats.create_distribution(measurements)
x_values = mstats.distributions.adaptive_range(dist, 4)
y_values = dist.heighted_probabilities_at(x_values, df['fitness'])
max_value = functools.reduce(
lambda a, b: (a if a[1] > b[1] else b),
zip(x_values, y_values),
(0, 0)
)
points = [
p for p in zip(x_values, y_values)
if segment_min < p[0] < segment_max
]
x_segment_values, y_segment_values = zip(*points)
population = mstats.distributions.population(dist, 4096)
population = [x for x in population if segment_min < x < segment_max]
coupling_length = mstats.ValueUncertainty(
np.median(population),
mstats.distributions.weighted_median_average_deviation(population)
)
gaussian_fit = mstats.create_distribution([coupling_length])
y_gauss_values = gaussian_fit.probabilities_at(x_values)
y_gauss_values = [scale_factor * y for y in y_gauss_values]
return dict(
dist=dist,
max=max_value,
coupling_length=coupling_length,
values=dict(
x=x_values,
y=y_values
),
segment=dict(
x=x_segment_values,
y=y_segment_values
),
gauss=dict(
x=x_values,
y=y_gauss_values
)
)
def positions(
foot_positions: limb.Property,
times: dict
) -> typing.Dict[str, list]:
"""
Iterates over the foot positions lists and computes the coupling length for
each entry in the lists (a time step of the simulation) as well as the
positions of the rear and forward couplers.
:param foot_positions:
The foot positions for each limb at each simulated time step
:param times:
:return:
A dictionary with the following keys:
* lengths: The coupling length at each simulated time step
* rear: The rear coupler position at each simulated time step
* forward: The forward coupler position at each simulated time step
"""
coupling_events = []
pes_coupler_positions = []
manus_coupler_positions = []
midpoint_positions = []
for i, time in enumerate(times['cycles']):
pes_pos = foot_positions.left_pes[i].midpoint_between(
foot_positions.right_pes[i]
)
pes_coupler_positions.append(pes_pos)
manus_pos = foot_positions.left_manus[i].midpoint_between(
foot_positions.right_manus[i]
)
manus_coupler_positions.append(manus_pos)
midpoint_pos = pes_pos.midpoint_between(manus_pos)
midpoint_positions.append(midpoint_pos)
sample_time = 2 * time
if not mstats.value.equivalent(sample_time - int(sample_time), 0):
continue
coupling_events.append(events.Event(
time=time,
index=i,
value=pes_pos.distance_between(manus_pos)
))
lengths = [v.value for v in coupling_events]
d = mstats.create_distribution(lengths)
median = mstats.distributions.percentile(d, 0.5)
median_deviations = []
for cl in lengths:
median_deviations.append(cl - median)
return dict(
lengths=coupling_events,
rear=pes_coupler_positions,
forward=manus_coupler_positions,
midpoints=midpoint_positions,
deviations=median_deviations
)
import cauldron as cd
import plotly.graph_objs as go
from cauldron import plotting
import measurement_stats as mstats
df = cd.shared.couplings_df
variations = df['raw_mad'] / df['raw_median']
cd.display.plotly(data=go.Histogram(x=variations),
layout=plotting.create_layout(
title='Coupling Length Fractional Deviations',
x_label='Fractional Deviation',
y_label='Frequency (#)'))
dist = mstats.create_distribution(measurements=variations.tolist(),
uncertainties=0.01)
x = mstats.distributions.uniform_range(dist, 3)
y = dist.probabilities_at(x)
cd.display.plotly(data=go.Scatter(x=x, y=y, mode='lines', fill='tozeroy'),
layout=plotting.create_layout(title='Coupling Length KDE',
x_label='Coupling Lengths (m)',
y_label='Expectation Value'))
To include uncertainty each fitness value needs to be represented as a
Gaussian kernel function with a width based on the uncertainty in coupling
length for that trial. Each Gaussian is weighted according to it fitness
such that a low fitness value produces a correspondingly smaller Gaussian.
The sum over all Gaussian kernels leads to a fitness distribution by
coupling length.
"""
)
measurements = mstats.values.join(
df['coupling_length'].tolist(),
df['uncertainty'].tolist()
)
distribution = mstats.create_distribution(measurements)
x_values = mstats.distributions.adaptive_range(distribution, 4)
y_values = distribution.heighted_probabilities_at(x_values, df['fitness'])
distribution_trace = go.Scatter(
x=x_values,
y=y_values,
name='Distribution',
mode='lines',
fill='tozeroy'
)
cd.display.plotly(
distribution_trace,
layout=plotting.create_layout(
title='Kernel Density Solution Fitness',
import plotly.graph_objs as go
import numpy as np
from cauldron import plotting
from cauldron import project
import measurement_stats as mstats
df = project.shared.measurements
normalized_values = []
traces = []
for key in ['Width-Box', 'Height-Box']:
d = mstats.create_distribution(
measurements=df[key].tolist(),
uncertainties=5
)
median = mstats.distributions.percentile(d)
normalized = [100.0 * (v / median - 1.0) for v in d.measurements]
normalized_values += normalized
x_values = list(np.arange(1, len(normalized), 1))
y_values, y_uncertainties = mstats.values.unzip(normalized)
traces.append(go.Bar(
x=x_values,
y=y_values,
error_y=dict(
type='data',
array=y_uncertainties,
visible=True
import measurement_stats as mstats
from cauldron import project
from cauldron import plotting
import plotly.graph_objs as go
d = mstats.create_distribution(project.shared.normalized_values)
x_values = mstats.distributions.adaptive_range(d, 3.0, max_delta=0.1)
y_values = d.probabilities_at(x_values)
data = go.Scatter(x=x_values, y=y_values, fill='tozeroy')
layout = plotting.create_layout(
title='Combined Measurement Deviations Cumulative Distribution',
x_label='Median Deviation (%)',
y_label='Expectation Value (au)')
project.display.markdown("""
Cumulative Distribution
-----------------------
In this final plot, the median-deviation values for every previous
measurement were combined into a single weighted distribution and plotted
to inspect the structure of the variance. An important conclusion to take
away from this distribution is that the small humps, particularly in the
lower half of the graph, are the result of singular or small numbers of
measurements. This indicates that the measurement distribution is not
robustly sampled and that more samples should be added for additional
statistical validation of the result.
""")
normalized_lengths = []
length_traces = []
normalized_angles = []
angle_traces = []
for key_data in project.shared.measurement_keys:
if key_data['type'] == 'length':
combined_normalized = normalized_lengths
combined_traces = length_traces
else:
combined_normalized = normalized_angles
combined_traces = angle_traces
d = mstats.create_distribution(
measurements=df[key_data['keys'][0]].tolist(),
uncertainties=df[key_data['keys'][1]].tolist())
median = mstats.distributions.percentile(d)
normalized = [100.0 * (v / median - 1.0) for v in d.measurements]
combined_normalized += normalized
x_values = list(np.arange(1, len(normalized), 1))
y_values, y_uncertainties = mstats.values.unzip(normalized)
combined_traces.append(
go.Bar(
x=x_values,
y=y_values,
error_y=dict(type='data', array=y_uncertainties, visible=True),
name=key_data['label'],
x=np.arange(0, len(aisle_capacity), 1) / 60.0,
y=aisle_capacity,
mode='lines',
fill='tozeroy',
line={'color': 'purple'}
),
layout=plotting.create_layout(
title='Aisle Capacity',
x_label='Boarding Time (minutes)',
y_label='Capacity',
y_bounds=[0, 100]
)
)
distribution = mstats.create_distribution(
measurements=aisle_capacity,
uncertainties=50.0 / aisle_count
)
x_values = mstats.distributions.uniform_range(distribution, 3, 1024)
project.display.plotly(
data=go.Scatter(
x=x_values,
y=distribution.probabilities_at(x_values),
mode='lines',
fill='tozeroy',
line={'color': 'purple'}
),
layout=plotting.create_layout(
title='Aisle Capacity KDE Distribution',
x_label='Aisle Capacity (%)',
y_label='Expectation Value (au)'
import measurement_stats as mstats
from cauldron import project
from cauldron import plotting
import plotly.graph_objs as go
d = mstats.create_distribution(project.shared.normalized_values)
x_values = mstats.distributions.adaptive_range(d, 3.0, max_delta=0.1)
y_values = d.probabilities_at(x_values)
data = go.Scatter(
x=x_values,
y=y_values,
fill='tozeroy'
)
layout = plotting.create_layout(
title='Combined Measurement Deviations Cumulative Distribution',
x_label='Median Deviation (%)',
y_label='Expectation Value (au)'
)
project.display.markdown(
"""
Cumulative Distribution
-----------------------
In this final plot, the median-deviation values for every previous
measurement were combined into a single weighted distribution and plotted
import pandas as pd
import plotly.graph_objs as go
from _Gauge_Quantization import plotting
tracks = cd.shared.tracks # type: pd.DataFrame
trackway_name = cd.shared.TRACKWAY_NAME
unweighted = cd.shared.unweighted
pes_tracks = tracks[tracks['pes'] == 1]
layout = go.Layout(
title='{} Pes Gauge Values Along Trackway'.format(trackway_name),
xaxis={'title': 'Trackway Position (m)'},
yaxis={'title': 'Gauge (m)'})
dist = mstats.create_distribution(pes_tracks['simpleGauge'].tolist(),
pes_tracks['simpleGaugeUnc'].tolist())
pop = mstats.distributions.population(dist)
median_value = mstats.distributions.percentile(pop)
mad = mstats.distributions.weighted_median_average_deviation(pop)
median = mstats.ValueUncertainty(median_value, mad)
scatter_trace = plotting.create_scatter(pes_tracks['curvePosition'],
pes_tracks['simpleGauge'],
pes_tracks['simpleGaugeUnc'],
name='Gauges')
median_traces = plotting.make_ranged_quantity_traces(
x_start=pes_tracks['curvePosition'].min(),
x_end=pes_tracks['curvePosition'].max(),
quantity=median,
name='Median',
