In [1]:

    

import glob


    

In [2]:

    

import matplotlib.pyplot as plt
import matplotlib as mpl
from matplotlib import colors as mcolors
from matplotlib import patches
import numpy as np
import pandas as pd
import seaborn.apionly as sns
from scipy import stats
import pymc3 as pm
%matplotlib inline


    

In [3]:

    

default_cycler = plt.rcParamsDefault["axes.prop_cycle"]
colorblind_cmaps = ["Dark2", "Set2"]
colorblind_cyclers = {cmap: plt.cycler("color", plt.cm.get_cmap(cmap).colors) for cmap in colorblind_cmaps}
plt.rcParams["axes.prop_cycle"] = colorblind_cyclers["Dark2"]


    

In [4]:

    

plt.rc("text", usetex=True)
plt.rc("font", family="serif")


    

In [5]:

    

plt.rc("text", usetex=False)
plt.rc("font", family="serif")


    

In [6]:

    

import re
FILENAME_PATTERN = "experiment-(\d)_user-(\d+)_run-(\d+)"
filename_regex = re.compile(pattern=FILENAME_PATTERN)

from collections import namedtuple
RunData = namedtuple("RunData", "experiment user run")
BestResult = namedtuple("BestResult", "trace model")
TlxResponse = namedtuple("TlxResponse", "code raw weight score")
Coords = namedtuple("Coords", "x y")
TARGET = Coords(0, 6)

from enum import Enum
DroneState = Enum("DroneState",
                  "Emergency Inited Landed Flying Hovering Test TakingOff GotoHover Landing Looping",
                  start=0)
ExperimentType = Enum("ExperimentType", "Onboard Spirit Combined LineOfSight")


    

In [7]:

    

def change_color(color, saturation=0, value=0):
    rgb = mcolors.ColorConverter.to_rgb(color)
    h, s, v = mcolors.rgb_to_hsv(rgb)
    s *= 1 + saturation/100
    s = np.clip(s, 0, 1)
    v *= 1 + value/100
    v = np.clip(v, 0, 1)
    r, g, b = mcolors.hsv_to_rgb((h, s, v))
    return r, g, b


    

In [8]:

    

def saturate_color(color, percent):
    rgb = mcolors.ColorConverter.to_rgb(color)
    h, s, v = mcolors.rgb_to_hsv(rgb)
    s *= 1 + percent/100
    s = np.clip(s, 0, 1)
    r, g, b = mcolors.hsv_to_rgb((h, s, v))
    return r, g, b


    

In [9]:

    

def shade_color(color, percent):
    rgb = mcolors.ColorConverter.to_rgb(color)
    h, s, v = mcolors.rgb_to_hsv(rgb)
    v *= 1 + percent/100
    v = np.clip(v, 0, 1)
    r, g, b = mcolors.hsv_to_rgb((h, s, v))
    return r, g, b


    

In [10]:

    

def plot_overview(df, experiment_type, color="C0", title=None, target=TARGET,
                  alpha_path=0.2, zorder_path=0, 
                  alpha_point=0.5, zorder_point=1,
                  xlabel="$x$ (m)", ylabel="$y$ (m)"):
        
    df_ex = df[df.experiment_type == experiment_type]
    df_arr = df_ex[df_ex.arrived == 1]
    if title is None:
        title = df_ex.experiment.iloc[0]
    for run in set(df_ex.total_ordering):
        df_run = df_ex[df_ex.total_ordering == run]
        plt.plot(df_run.xn, df_run.yn, alpha=alpha_path, color=color, zorder=zorder_path)
    plt.scatter(df_arr.xn, df_arr.yn, alpha=alpha_point, color=color, zorder=zorder_point)
    plot_targets(show_start=True, show_final=False, target_coords=[target])
    plt.axis("equal")
    plt.xlabel(xlabel)
    plt.ylabel(ylabel)
    plt.title(title)


    

In [11]:

    

def plot_by_distance(df, experiment_type, cmap="C0", target=TARGET,
                     alpha_point=0.5, zorder_point=1, crosshair=False,
                     xlabel="$x$ (m)", ylabel="$y$ (m)"):
    df_ex = df[df.experiment_type == experiment_type]
    df_arr = df_ex[df_ex.arrived == 1]
    plt.scatter(df_arr.xn, df_arr.yn,
                c=df_arr.distance, cmap=cmap)
    plt.colorbar(label="distance (m)")
    plt.clim(df[df.arrived==1].distance.min(), df[df.arrived==1].distance.max())
    plot_targets(show_start=False, show_final=False, target_coords=[TARGET], crosshair=crosshair)
    plt.axis("equal")
    plt.xlabel(xlabel)
    plt.ylabel(ylabel)


    

In [12]:

    

def plot_detailed(df, experiment_type, color="C0", title=None, target=TARGET,
                  alpha_point=0.5, zorder_point=1, crosshair=False,
                  xlabel="$x$ (m)", ylabel="$y$ (m)"):
    df_ex = df[df.experiment_type == experiment_type]
    df_arr = df_ex[df_ex.arrived == 1]
    if title is None:
        title = df_ex.experiment.iloc[0]
    for order in np.arange(1, df.order.max()+1):
        df_run = df_arr[df_arr.order==order]
        plt.scatter(df_run.xn, df_run.yn,
                    label=f"Run {order}", color=shade_color(color, -50+25*(order-1)))
    plot_targets(show_start=False, show_final=False, target_coords=[TARGET], crosshair=crosshair)
    plt.title(title)
    plt.axis("equal")
    plt.xlabel(xlabel)
    plt.ylabel(ylabel)
    plt.legend()


    

In [13]:

    

def plot_distribution(df, experiment_type, color="C0", title=None,
                      target_color="C2", background_shade=-50, crosshair=False):
    df_ex = df[df.experiment_type == experiment_type]
    df_arr = df_ex[df_ex.arrived == 1]
    if title is None:
        title = df_ex.experiment.iloc[0]
    g = sns.jointplot(df_arr.xn, df_arr.yn, kind="kde", size=7, space=0, color=color)
    g.plot_marginals(sns.rugplot, height=0.1, color=color)
    g.ax_joint.get_children()[0].set_zorder(-1)
    for child in g.ax_joint.get_children()[1:]:
        if isinstance(child, mpl.collections.PathCollection):
            child.set_alpha(0.8)
    plt.sca(g.ax_joint)
    plot_targets(show_start=False, show_final=False, target_coords=[TARGET],
                 target_color=target_color, zorder=0, crosshair=crosshair)
    g.set_axis_labels("$x$", "$y$")
    plt.axis("equal")

    xmin, xmax = plt.xlim()
    ymin, ymax = plt.ylim()
    xsize = xmax - xmin
    ysize = ymax - ymin

    if xsize > ysize:
        ymin -= (xsize - ysize) / 2
        ymax += (xsize - ysize) / 2
        ysize = xsize
    else:
        xmin -= (ysize - xsize) / 2
        xmax += (ysize - xsize) / 2
        xsize = ysize

    plt.gca().add_patch(patches.Rectangle((xmin, ymin), xsize, ysize,
                                          color=saturate_color(color, background_shade), zorder=-1))
    g.fig.suptitle(title)


    

In [14]:

    

def plot_xy(df, x="x", y="y", invert_x=True, invert_y=True, s=None, c=None,
            cmap="viridis", alpha=1, show_cbar=True, label=None, line=False, zorder=0):
    """
    Coords in real frame. +x is towards doors, +y is away from table.
    
    """
    if s is not None:
        s = df[s]*25
    if c is not None:
        label = c
        try:
            df[c]
        except KeyError:
            pass
        else:
            c = df[c]
    else:
        if line:
            c = "C0"
        else:
            c = df.index
            label="time"
    
    if line:
        plt.plot(df[x] * (-1 if invert_x else 1), df[y] * (-1 if invert_y else 1), c=c, alpha=alpha, zorder=zorder)
    else:
        plt.scatter(df[x] * (-1 if invert_x else 1), df[y] * (-1 if invert_y else 1), s=s, c=c, cmap=cmap, alpha=alpha, zorder=zorder)
        if show_cbar:
            plt.colorbar(label=label)
    plt.axis("equal")


    

In [15]:

    

def plot_xy_conditional(df, condition=None, x="x", y="y", invert_x=True, invert_y=True,
                        s=None, c=None, c_condition=None, cmap_condition="viridis", cmap_not_condition="gray",
                        alpha_condition=1, alpha_not_condition=1, show_cbar=True, label=None, line=False,
                        zorder_condition=1, zorder_not_condition=0):
    if condition is None:
        cmap_not_condition = cmap_condition
    plot_xy(df, x=x, y=y, invert_x=invert_x, invert_y=invert_y,
            s=s, c=c, cmap=cmap_not_condition, alpha=alpha_not_condition, show_cbar=show_cbar,
            label=label, line=line, zorder=zorder_not_condition)
    if condition is not None:
        if line:
            show_cbar = False
            if c_condition is None:
                c = "C0"
            else:
                c = c_condition
        plot_xy(df[condition], x=x, y=y, invert_x=invert_x, invert_y=invert_y,
                s=s, c=c, cmap=cmap_condition, alpha=alpha_condition, show_cbar=show_cbar,
                label=label, zorder=zorder_condition)


    

In [16]:

    

def plot_targets(p_init=Coords(0, 0), p_final=Coords(0, 0), invert_x=False, invert_y=False,
                 target_coords=None, target_coord_offsets=None, target_color="C2",
                 target_size=Coords(0.525, 0.37), show_start=True, show_final=True,
                 scale=100, zorder=0, crosshair=False, background_shade=-50):
    if target_coords is not None and target_coord_offsets is not None:
        raise ValueError("Use either target_coords or target_coord_offsets")
    
    ax = plt.gca()
    
    if target_coords is None:
        if target_coord_offsets is None:
            target_coord_offsets = TARGET_COORD_OFFSETS
        target_coords = [Coords(p_init.x - offset.x, p_init.y - offset.y) for offset in target_coord_offsets]
    
    if show_start:
        plt.scatter(-p_init.x, -p_init.y, marker=(5, 0), s=100, c="g")
    for coord in target_coords:
        if crosshair:
            plt.axhline(coord.y, color=shade_color(target_color, background_shade/2), zorder=zorder)
            plt.axvline(coord.x, color=shade_color(target_color, background_shade/2), zorder=zorder)
        ax.add_patch(patches.Rectangle((coord.x * (-1 if invert_x else 1) - target_size.x / 2,
                                        coord.y * (-1 if invert_y else 1) - target_size.y / 2),
                                       target_size.x,
                                       target_size.y,
                                       color=target_color,
                                       zorder=zorder))
    if show_final:
        plt.scatter(p_final.x * (-1 if invert_x else 1), p_final.y * (-1 if invert_y else 1), marker=(3, 0), s=scale, c="r")


    

In [17]:

    

def tag_data(df):
    df["tag"] = (df.arrived.diff(1) != 0).astype('int').cumsum()


    

In [18]:

    

def distance(df, target):
    return np.sqrt((df.xn - target.x)**2 + (df.yn - target.y)**2)


    

In [41]:

    

def usable_filenames():
    filenames = sorted([filename for filename in glob.glob("csv/*.csv") if "user-99" not in filename])
    
    for filename in filenames:
        if not filename_regex.search(filename):
            continue
        if "user-99" not in filename:
            df = pd.read_csv(filename, parse_dates=["time"])
            if any(df.arrived):
                yield filename


    

In [42]:

    

def extract_run_data(filename):
    data = filename_regex.findall(filename)[0]
    return RunData(ExperimentType(int(data[0])), int(data[1]), int(data[2]))


    

In [43]:

    

def analyze_all():
    results = pd.DataFrame(columns="user experiment_type run dist_err x_err y_err "
                                    "dist_std x_std y_std rms rms_x rms_y duration".split())
    
    for i, filename in enumerate(usable_filenames()):
        data = extract_run_data(filename)
        df = pd.read_csv(filename, parse_dates=["time"])
        df.xn *= -1
        df.yn *= -1
        found = df[df.arrived == 1]

        distances = distance(found, TARGET)
        dist_err = distances.mean()
        dist_std = distances.std()

        dx = found.xn - TARGET.x
        x_err = dx.mean()
        x_std = dx.std()

        dy = found.yn - TARGET.y
        y_err = dy.mean()
        y_std = dy.std()

        rms = np.sqrt(np.mean(((found.xn - TARGET.x)**2 + (found.yn - TARGET.y)**2)))
        rms_x = np.sqrt(np.mean((dx)**2))
        rms_y = np.sqrt(np.mean((dy)**2))
        
        duration = (found.time.iloc[0] - df[df.z > 0.25].time.iloc[0]).total_seconds()

        results.loc[i] = [
            data.user, data.experiment, data.run,
            dist_err, x_err, y_err,
            dist_std, x_std, y_std,
            rms, rms_x, rms_y, duration
        ]    
    return results


    

In [148]:

    

def load():
    analyses = pd.DataFrame(columns="user experiment_type run dist_err x_err y_err "
                                    "dist_std x_std y_std rms rms_x rms_y "
                                    "idx_start idx_end t_start t_end duration "
                                    "path_length "
                                    "move_x move_l move_r "
                                    "move_y move_b move_f".split())
    
    records = []
    
    for i, filename in enumerate(usable_filenames()):
        data = extract_run_data(filename)
        df = pd.read_csv(filename, parse_dates=["time"])
        df.xn *= -1
        df.yn *= -1
        
        df["experiment_type"] = data.experiment
        df["user"] = data.user
        df["run"] = data.run
        records.append(df)
        
        found = df[df.arrived == 1]

        distances = distance(found, TARGET)
        dist_err = distances.mean()
        dist_std = distances.std()

        dx = found.xn - TARGET.x
        x_err = dx.mean()
        x_std = dx.std()

        dy = found.yn - TARGET.y
        y_err = dy.mean()
        y_std = dy.std()

        rms = np.sqrt(np.mean(((found.xn - TARGET.x)**2 + (found.yn - TARGET.y)**2)))
        rms_x = np.sqrt(np.mean((dx)**2))
        rms_y = np.sqrt(np.mean((dy)**2))
        
        t_start = df[df.z > 0.25].time.iloc[0]
        t_end = found.time.iloc[0]
        duration = (t_end - t_start).total_seconds()
        
        idx_start = df[df.time==t_start].index[0]
        idx_end = df[df.time==t_end].index[0]
        
        df_running = df[["xn", "yn"]].iloc[idx_start:idx_end+1]
        points = np.array(df_running)
        lengths = np.sqrt(np.sum(np.diff(points, axis=0)**2, axis=1))
        path = lengths.sum()
        
        diff_x = np.diff(points[:, 0])
        move_r = np.abs(np.sum(diff_x[diff_x > 0]))  # movement in negative direction
        move_l = np.abs(np.sum(diff_x[diff_x < 0]))  # movement in positive direction
        move_x = move_l + move_r

        diff_y = np.diff(points[:, 1])
        move_f = np.abs(np.sum(diff_y[diff_y > 0]))  # movement in negative direction
        move_b = np.abs(np.sum(diff_y[diff_y < 0]))  # movement in positive direction
        move_y = move_b + move_f

        analyses.loc[i] = [
            data.user, data.experiment, data.run,
            dist_err, x_err, y_err,
            dist_std, x_std, y_std,
            rms, rms_x, rms_y,
            idx_start, idx_end, t_start, t_end, duration,
            path,
            move_x, move_l, move_r,
            move_y, move_b, move_f,
        ]
        
    results = pd.concat(records, ignore_index=True)
    
    analyses["group"] = (analyses.user % 2).astype(int)
    analyses["start"] = [ExperimentType(e % 2 + 1) for e in analyses.user]
    analyses["experiment_int"] = [e.value for e in analyses.experiment_type]
    analyses["experiment"] = [e.name for e in analyses.experiment_type]
    analyses.experiment.replace("Spirit", "SPIRIT", inplace=True)

    results["group"] = (results.user % 2).astype(int)
    results["start"] = [ExperimentType(e % 2 + 1) for e in results.user]
    results["experiment_int"] = [e.value for e in results.experiment_type]
    results["experiment"] = [e.name for e in results.experiment_type]
    results.experiment.replace("Spirit", "SPIRIT", inplace=True)
    results.distance = distance(results, TARGET)
    results.dx = results.xn - TARGET.x
    results.dy = results.yn - TARGET.y
    results["total_ordering"] = ((results.run.diff(1) != 0)
                              | (results.experiment_int.diff(1) != 0)
                              | (results.user.diff(1) != 0)).astype('int').cumsum() - 1
    
    for user in set(analyses.user):
        df = analyses[analyses.user == user].sort_values(
            by="experiment_int", ascending=np.all(analyses[analyses.user==user]
                                             .start==ExperimentType.Onboard))
        df["order"] = range(1, len(df) + 1)
        for idx in df.index:
            analyses.loc[idx, "order"] = int(df.loc[idx, "order"])
            results.loc[results.total_ordering==idx, "order"] = int(df.loc[idx, "order"])
            
    for col in ["user", "run", "group", "order"]:
        analyses[col] = analyses[col].astype(int)
    for col in ["arrived", "order"]:
        results[col] = results[col].astype(int)
        
    return results, analyses


    

In [149]:

    

results, analyses = load()


    

In [134]:

    

analysis.move_x.plot()
analysis.move_y.plot()
analysis.path_length.plot()


    

    
Out[134]:





<matplotlib.axes._subplots.AxesSubplot at 0x7f66b35323c8>






    

In [136]:

    

sns.factorplot(data=analysis, hue="experiment", x="order", y="path_length")


    

    
Out[136]:





<seaborn.axisgrid.FacetGrid at 0x7f66b3625a58>






    

In [137]:

    

sns.factorplot(data=analysis, hue="experiment", x="order", y="move_x")


    

    
Out[137]:





<seaborn.axisgrid.FacetGrid at 0x7f66b3393908>






    

In [138]:

    

sns.factorplot(data=analysis, hue="experiment", x="order", y="move_y")


    

    
Out[138]:





<seaborn.axisgrid.FacetGrid at 0x7f66b3576ef0>






    

In [141]:

    

sns.factorplot(data=analysis, x="experiment", y="move_b", kind="bar", )


    

    
Out[141]:





<seaborn.axisgrid.FacetGrid at 0x7f66b315dbe0>






    

In [91]:

    

analysis[analysis.user==8].index[0]


    

    
Out[91]:





16

In [93]:

    

analysis.iloc[16]


    

    
Out[93]:





user                                    8
experiment_type    ExperimentType.Onboard
run                                     0
dist_err                         0.330663
x_err                           -0.329519
y_err                           0.0269535
dist_std                       0.00443956
x_std                          0.00399099
y_std                           0.0057639
rms                              0.330693
rms_x                            0.329543
rms_y                           0.0275549
duration                          24.8964
group                                   0
start              ExperimentType.Onboard
experiment_int                          1
experiment                        Onboard
order                                   1
Name: 16, dtype: object

In [ ]:

    

analysis[analysis.user==8].iloc


    

In [ ]:

    

analysis[analysis.user==8].loc


    

In [60]:

    

filenames = usable_filenames()


    

In [104]:

    

_df = pd.read_csv(next(filenames), parse_dates=["time"])
points = np.array(_df[["xn", "yn"]])
lengths = np.sqrt(np.sum(np.diff(points, axis=0)**2, axis=1))
print(lengths.sum())


    

    




15.139666224

In [105]:

    

plt.scatter(_df.xn, _df.yn)


    

    
Out[105]:





<matplotlib.collections.PathCollection at 0x7f66fd1bd898>






    

In [95]:

    

analysis[["rms_x", "rms_y"]].iloc[15:17]


    

    
Out[95]:






  

    

      

      
rms_x
      
rms_y
    
  
  

    

      
15
      
0.109587
      
0.362615
    
    

      
16
      
0.329543
      
0.027555
    
  

In [106]:

    

points


    

    
Out[106]:





array([[ 0.        ,  0.        ],
       [ 0.        ,  0.        ],
       [ 0.        ,  0.        ],
       ..., 
       [-0.42237988, -4.6361208 ],
       [-0.42237999, -4.63604355],
       [-0.42237999, -4.63604355]])

In [112]:

    

len(points[:, 0]


    

    
Out[112]:





array([ 0.        ,  0.        ,  0.        , ..., -0.42237988,
       -0.42237999, -0.42237999])

In [113]:

    

np.sum(np.diff(np.abs(points[:, 0])))


    

    
Out[113]:





0.42237998545200006

In [120]:

    

diff = np.diff(points[:, 1])
np.sum(diff[diff > 0])  # movement in negative direction
np.sum(diff[diff < 0])  # movement in positive direction


    

In [108]:

    

np.sum(np.diff(points[points[:, 0] > 0][:, 0]))


    

    
Out[108]:





0.00070208311080915964

In [95]:

    

def load_all():
    frames = []
    for filename in usable_filenames():
        df = pd.read_csv(filename, parse_dates=["time"])
        data = extract_run_data(filename)
        df["experiment_type"] = data.experiment
        df["user"] = data.user
        df["run"] = data.run
        frames.append(df)
    result = pd.concat(frames, ignore_index=True)
    result.xn *= -1
    result.yn *= -1
    return result


    

In [178]:

    

def parse_tlx_component(component):
    return TlxResponse(component.code, component.score, component.weight, component.weighted_score)


    

In [136]:

    

def best(sample1, sample2, σ_range, exponential_m, n_iter=2000, n_jobs=2):
    print(σ_range, exponential_m)
    y1 = np.array(sample1)
    y2 = np.array(sample2)
    y = pd.DataFrame(dict(value=np.r_[y1, y2],
                          group=np.r_[["onboard"]*len(sample1),
                                      ["spirit"]*len(sample2)]))
    μ_m = y.value.mean()
    μ_s = y.value.std() * 2

    with pm.Model() as model:
        group1_mean = pm.Normal("group1_mean", μ_m, sd=μ_s)
        group2_mean = pm.Normal("group2_mean", μ_m, sd=μ_s)
        σ_low, σ_high = σ_range
        group1_std = pm.Uniform("group1_std", lower=σ_low, upper=σ_high)
        group2_std = pm.Uniform("group2_std", lower=σ_low, upper=σ_high)
        ν = pm.Exponential("ν_minus_one", abs(1/(exponential_m-1))) + 1    
        
        λ1 = group1_std**-2
        λ2 = group2_std**-2

        group1 = pm.StudentT("onboard",
                             nu=ν, mu=group1_mean, lam=λ1, observed=y1)
        group2 = pm.StudentT("spirit",
                             nu=ν, mu=group2_mean, lam=λ2, observed=y2)
        
        diff_of_means = pm.Deterministic("difference of means",
                                         group1_mean - group2_mean)
        diff_of_stds = pm.Deterministic("difference of stds",
                                        group1_std - group2_std)
        effect_size = pm.Deterministic("effect size",
                                       diff_of_means / np.sqrt((group1_std**2
                                                                + group2_std**2)
                                                                / 2))
        trace = pm.sample(n_iter, init=None, njobs=n_jobs)
    return BestResult(trace, model)


    

In [130]:

    

def summarize(best_result, kde=True, plot=True):
    trace, model = best_result
    if plot:
        ax = pm.plot_posterior(trace[100:],
                               varnames=[r"group1_mean", r"group2_mean",
                                         r"group1_std", "group2_std",
                                         r"ν_minus_one"],
                               kde_plot=kde, color="C0");
        if kde:
            for a in (1, 3):
                ax[a].lines[0].set_color("C1")
        plt.figure()
        pm.plot_posterior(trace[1000:],
                          varnames=["difference of means", "difference of stds",
                                    "effect size"],
                          ref_val=0, kde_plot=True, color="C2");
        plt.figure()
        pm.forestplot(trace[1000:], varnames=[v.name for v in model.vars[:2]]);
        plt.figure()
        pm.forestplot(trace[1000:], varnames=[v.name for v in model.vars[2:]])

    pm.summary(trace[1000:],
               varnames=["difference of means", "difference of stds",
                         "effect size"])


    

In [138]:

    

def analyze_differences(df, columns, params, n_iter=2000, n_jobs=2,
                        show_summaries=True, plot=False):
    traces = {}
    for column, param in zip(columns, params):
        sample1 = df[df.experiment_type==ExperimentType.Onboard][column]
        sample2 = df[df.experiment_type==ExperimentType.Spirit][column]
        best_result = best(sample1, sample2, *param,
                           n_iter=n_iter, n_jobs=n_jobs)
        traces[column] = best_result
        if show_summaries:
            summarize(best_result, plot=plot)


    

In [143]:

    

analyze_differences(analyses, ["dist_err", "duration"], [[(0, 2), 0.5], [(5, 50), 50]])


    

    




(0, 2) 0.5






    




Assigned NUTS to group1_mean
Assigned NUTS to group2_mean
Assigned NUTS to group1_std_interval_
Assigned NUTS to group2_std_interval_
Assigned NUTS to ν_minus_one_log_
100%|██████████| 2000/2000 [00:22<00:00, 88.10it/s] 






    




difference of means:

  Mean             SD               MC Error         95% HPD interval
  -------------------------------------------------------------------
  
  0.262            0.115            0.003            [0.057, 0.495]

  Posterior quantiles:
  2.5            25             50             75             97.5
  |--------------|==============|==============|--------------|
  
  0.045          0.183          0.256          0.343          0.486


difference of stds:

  Mean             SD               MC Error         95% HPD interval
  -------------------------------------------------------------------
  
  0.048            0.099            0.003            [-0.154, 0.242]

  Posterior quantiles:
  2.5            25             50             75             97.5
  |--------------|==============|==============|--------------|
  
  -0.149         -0.014         0.047          0.110          0.255


effect size:

  Mean             SD               MC Error         95% HPD interval
  -------------------------------------------------------------------
  
  1.035            0.521            0.017            [0.116, 2.131]

  Posterior quantiles:
  2.5            25             50             75             97.5
  |--------------|==============|==============|--------------|
  
  0.155          0.674          0.985          1.372          2.201

(5, 50) 50






    




Assigned NUTS to group1_mean
Assigned NUTS to group2_mean
Assigned NUTS to group1_std_interval_
Assigned NUTS to group2_std_interval_
Assigned NUTS to ν_minus_one_log_
100%|██████████| 2000/2000 [01:53<00:00, 17.67it/s]






    




difference of means:

  Mean             SD               MC Error         95% HPD interval
  -------------------------------------------------------------------
  
  -5.216           6.083            0.185            [-16.882, 6.862]

  Posterior quantiles:
  2.5            25             50             75             97.5
  |--------------|==============|==============|--------------|
  
  -16.996        -9.160         -5.314         -1.176         6.823


difference of stds:

  Mean             SD               MC Error         95% HPD interval
  -------------------------------------------------------------------
  
  3.688            4.951            0.155            [-6.130, 13.679]

  Posterior quantiles:
  2.5            25             50             75             97.5
  |--------------|==============|==============|--------------|
  
  -5.904         0.542          3.696          6.579          14.144


effect size:

  Mean             SD               MC Error         95% HPD interval
  -------------------------------------------------------------------
  
  -0.318           0.368            0.012            [-1.067, 0.385]

  Posterior quantiles:
  2.5            25             50             75             97.5
  |--------------|==============|==============|--------------|
  
  -1.084         -0.566         -0.315         -0.067         0.375

In [488]:

    

ax1 = plt.subplot("121")
for filename in glob.glob("csv/experiment-1_*.csv"):
    if "user-99" not in filename:
        df = pd.read_csv(filename, parse_dates=["time"])
        if any(df.arrived):
            plot_xy_conditional(df, df.arrived==1, x="xn", y="yn", c="C0", c_condition="C0",
                                alpha_not_condition=0.2, alpha_condition=0.5, line=True,
                                zorder_condition=1, zorder_not_condition=0)
plot_targets(target_coords=[TARGET], show_final=False, zorder=-1)
plt.title("Onboard")

ax2 = plt.subplot("122", sharex=ax1, sharey=ax1)
for filename in glob.glob("csv/experiment-2_*.csv"):
    if "user-99" not in filename:
        df = pd.read_csv(filename, parse_dates=["time"])
        if any(df.arrived):
            plot_xy_conditional(df, df.arrived==1, x="xn", y="yn", c="C1", c_condition="C1",
                                alpha_not_condition=0.2, alpha_condition=0.5, line=True,
                                zorder_condition=1, zorder_not_condition=0)
plot_targets(target_coords=[TARGET], show_final=False, zorder=-1)
plt.title("SPIRIT")


    

    
Out[488]:





<matplotlib.text.Text at 0x7feef4cac518>






    

In [489]:

    

for filename in glob.glob("csv/experiment-1_*.csv"):
    if "user-99" not in filename:
        df = pd.read_csv(filename, parse_dates=["time"])
        if any(df.arrived):
            plot_xy_conditional(df, df.arrived==1, x="xn", y="yn", c="C0", c_condition="C0",
                                alpha_not_condition=0.2, alpha_condition=0.5, line=True,
                                zorder_condition=1, zorder_not_condition=0)
onboard_path, = plt.plot([], [], color="C0", label="Onboard path")
onboard_arrival, = plt.plot([], [], linestyle="none", color="C0", marker="o", label="Onboard arrival")
for filename in glob.glob("csv/experiment-2_*.csv"):
    if "user-99" not in filename:
        df = pd.read_csv(filename, parse_dates=["time"])
        if any(df.arrived):
            plot_xy_conditional(df, df.arrived==1, x="xn", y="yn", c="C1", c_condition="C1",
                                alpha_not_condition=0.2, alpha_condition=0.5, line=True,
                                zorder_condition=1, zorder_not_condition=0)
spirit_path, = plt.plot([], [], color="C1", label="SPIRIT path")
spirit_arrival, = plt.plot([], [], linestyle="none", color="C1", marker="o", label="SPIRIT arrival")
plot_targets(target_coords=[TARGET], show_final=False, zorder=-1)
plt.xlabel(r"$x$")
plt.ylabel(r"$y$")
plt.legend(handles=[onboard_path, onboard_arrival, spirit_path, spirit_arrival])


    

    
Out[489]:





<matplotlib.legend.Legend at 0x7feef4a25e80>






    

In [96]:

    

filenames = list(usable_filenames())
filenames


    

    
Out[96]:





['csv/experiment-1_user-00_run-00.csv',
 'csv/experiment-1_user-00_run-01.csv',
 'csv/experiment-1_user-01_run-00.csv',
 'csv/experiment-1_user-01_run-01.csv',
 'csv/experiment-1_user-02_run-00.csv',
 'csv/experiment-1_user-02_run-02.csv',
 'csv/experiment-1_user-03_run-00.csv',
 'csv/experiment-1_user-03_run-01.csv',
 'csv/experiment-1_user-04_run-00.csv',
 'csv/experiment-1_user-04_run-01.csv',
 'csv/experiment-1_user-05_run-01.csv',
 'csv/experiment-1_user-05_run-02.csv',
 'csv/experiment-1_user-06_run-00.csv',
 'csv/experiment-1_user-06_run-01.csv',
 'csv/experiment-1_user-07_run-00.csv',
 'csv/experiment-1_user-07_run-01.csv',
 'csv/experiment-1_user-08_run-00.csv',
 'csv/experiment-1_user-08_run-01.csv',
 'csv/experiment-2_user-00_run-00.csv',
 'csv/experiment-2_user-00_run-01.csv',
 'csv/experiment-2_user-01_run-00.csv',
 'csv/experiment-2_user-01_run-01.csv',
 'csv/experiment-2_user-02_run-00.csv',
 'csv/experiment-2_user-02_run-01.csv',
 'csv/experiment-2_user-03_run-00.csv',
 'csv/experiment-2_user-03_run-03.csv',
 'csv/experiment-2_user-04_run-00.csv',
 'csv/experiment-2_user-04_run-02.csv',
 'csv/experiment-2_user-05_run-00.csv',
 'csv/experiment-2_user-05_run-02.csv',
 'csv/experiment-2_user-06_run-02.csv',
 'csv/experiment-2_user-06_run-03.csv',
 'csv/experiment-2_user-07_run-00.csv',
 'csv/experiment-2_user-07_run-01.csv',
 'csv/experiment-2_user-08_run-00.csv',
 'csv/experiment-2_user-08_run-01.csv']

In [499]:

    

for filename in glob.glob("csv/experiment-*_user-08*.csv"):
    df = pd.read_csv(filename, parse_dates=["time"])
    plot_targets(target_coords=[TARGET], show_final=False, zorder=0, crosshair=True)
    color = "C0" if filename[15]=="1" else "C1"
    plot_xy_conditional(df, df.arrived==1, x="xn", y="yn", c=color, c_condition=color,
                        alpha_not_condition=0.5, alpha_condition=0.5, line=True)


    

In [40]:

    

analyses = analyze_all()
results = load_all()


    

    




---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-40-ecc79e51f3e5> in <module>()
----> 1 analyses = analyze_all()
      2 results = load_all()

<ipython-input-21-7b307c055f08> in analyze_all()
      4 
      5     for i, filename in enumerate(usable_filenames()):
----> 6         data = extract_run_data(filename)
      7         df = pd.read_csv(filename, parse_dates=["time"])
      8         df.xn *= -1

<ipython-input-20-bf8b637ca0c2> in extract_run_data(filename)
      1 def extract_run_data(filename):
----> 2     data = filename_regex.findall(filename)[0]
      3     return RunData(ExperimentType(int(data[0])), int(data[1]), int(data[2]))

IndexError: list index out of range

In [217]:

    

results, analyses = load()
analyses.head()


    

    




---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-217-ba2d0a7fff3d> in <module>()
----> 1 results, analyses = load()
      2 analyses.head()

<ipython-input-215-b255fad8769b> in load()
      5     records = []
      6 
----> 7     for i, filename in enumerate(usable_filenames()):
      8         data = extract_run_data(filename)
      9         df = pd.read_csv(filename, parse_dates=["time"])

<ipython-input-91-b7e7553e13d1> in usable_filenames()
      4     for filename in filenames:
      5         if "user-99" not in filename:
----> 6             df = pd.read_csv(filename, parse_dates=["time"])
      7             if any(df.arrived):
      8                 yield filename

/home/masasin/.pyenv/versions/3.6.0/envs/scipy_stack/lib/python3.6/site-packages/pandas/io/parsers.py in parser_f(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, squeeze, prefix, mangle_dupe_cols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, dayfirst, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, escapechar, comment, encoding, dialect, tupleize_cols, error_bad_lines, warn_bad_lines, skipfooter, skip_footer, doublequote, delim_whitespace, as_recarray, compact_ints, use_unsigned, low_memory, buffer_lines, memory_map, float_precision)
    644                     skip_blank_lines=skip_blank_lines)
    645 
--> 646         return _read(filepath_or_buffer, kwds)
    647 
    648     parser_f.__name__ = name

/home/masasin/.pyenv/versions/3.6.0/envs/scipy_stack/lib/python3.6/site-packages/pandas/io/parsers.py in _read(filepath_or_buffer, kwds)
    387 
    388     # Create the parser.
--> 389     parser = TextFileReader(filepath_or_buffer, **kwds)
    390 
    391     if (nrows is not None) and (chunksize is not None):

/home/masasin/.pyenv/versions/3.6.0/envs/scipy_stack/lib/python3.6/site-packages/pandas/io/parsers.py in __init__(self, f, engine, **kwds)
    728             self.options['has_index_names'] = kwds['has_index_names']
    729 
--> 730         self._make_engine(self.engine)
    731 
    732     def close(self):

/home/masasin/.pyenv/versions/3.6.0/envs/scipy_stack/lib/python3.6/site-packages/pandas/io/parsers.py in _make_engine(self, engine)
    921     def _make_engine(self, engine='c'):
    922         if engine == 'c':
--> 923             self._engine = CParserWrapper(self.f, **self.options)
    924         else:
    925             if engine == 'python':

/home/masasin/.pyenv/versions/3.6.0/envs/scipy_stack/lib/python3.6/site-packages/pandas/io/parsers.py in __init__(self, src, **kwds)
   1434                 raise ValueError("Usecols do not match names.")
   1435 
-> 1436         self._set_noconvert_columns()
   1437 
   1438         self.orig_names = self.names

/home/masasin/.pyenv/versions/3.6.0/envs/scipy_stack/lib/python3.6/site-packages/pandas/io/parsers.py in _set_noconvert_columns(self)
   1484                         _set(k)
   1485                 else:
-> 1486                     _set(val)
   1487 
   1488         elif isinstance(self.parse_dates, dict):

/home/masasin/.pyenv/versions/3.6.0/envs/scipy_stack/lib/python3.6/site-packages/pandas/io/parsers.py in _set(x)
   1474 
   1475             if not is_integer(x):
-> 1476                 x = names.index(x)
   1477 
   1478             self._reader.set_noconvert(x)

ValueError: 'time' is not in list

In [ ]:

    

analyses["group"] = (analyses.user % 2).astype(int)
analyses["start"] = [ExperimentType(e % 2 + 1) for e in analyses.user]
analyses["experiment_int"] = [e.value for e in analyses.experiment_type]
analyses["experiment"] = [e.name for e in analyses.experiment_type]
analyses.experiment.replace("Spirit", "SPIRIT", inplace=True)

results["group"] = (results.user % 2).astype(int)
results["start"] = [ExperimentType(e % 2 + 1) for e in results.user]
results["experiment_int"] = [e.value for e in results.experiment_type]
results["experiment"] = [e.name for e in results.experiment_type]
results.experiment.replace("Spirit", "SPIRIT", inplace=True)
results["distance"] = distance(results, TARGET)
results["dx"] = results.xn - TARGET.x
results["dy"] = results.yn - TARGET.y
results["total_ordering"] = ((results.run.diff(1) != 0)
                             | (results.experiment_int.diff(1) != 0)
                             | (results.user.diff(1) != 0)).astype('int').cumsum() - 1


    

In [27]:

    

for user in set(analyses.user):
    _df = analyses[analyses.user == user].sort_values(by="experiment_int", ascending=np.all(analyses[analyses.user==user].start==ExperimentType.Onboard))
    _df["order"] = range(1, len(_df) + 1)
    for idx in _df.index:
        analyses.loc[idx, "order"] = int(_df.loc[idx, "order"])
        results.loc[results.total_ordering==idx, "order"] = int(_df.loc[idx, "order"])


    

In [28]:

    

for col in ["user", "run", "group", "order"]:
    analyses[col] = analyses[col].astype(int)
for col in ["arrived", "order"]:
    results[col] = results[col].astype(int)


    

In [29]:

    

spirit_arrived = results[(results.arrived==1) & (results.experiment_type==ExperimentType.Spirit)]
onboard_arrived = results[(results.arrived==1) & (results.experiment_type==ExperimentType.Onboard)]


    

In [1160]:

    

plt.scatter(onboard_arrived.xn, onboard_arrived.yn, label="Onboard")
plt.scatter(spirit_arrived.xn, spirit_arrived.yn, label="SPIRIT")
plot_targets(show_start=False, show_final=False, target_coords=[TARGET])
plt.legend()


    

    
Out[1160]:





<matplotlib.legend.Legend at 0x7fee521dfb38>






    

In [632]:

    

plt.scatter(spirit_arrived[spirit_arrived.start==ExperimentType.Onboard].xn,
            spirit_arrived[spirit_arrived.start==ExperimentType.Onboard].yn,
            c="C1", label="Group 0")
plt.scatter(spirit_arrived[spirit_arrived.start==ExperimentType.Spirit].xn,
            spirit_arrived[spirit_arrived.start==ExperimentType.Spirit].yn,
            c=shade_color("C1", -50), label="Group 1")
plot_targets(show_start=False, show_final=False, target_coords=[TARGET])
plt.title("SPIRIT")
plt.legend()


    

    
Out[632]:





<matplotlib.legend.Legend at 0x7feee2736048>






    

In [633]:

    

plt.scatter(onboard_arrived[onboard_arrived.group==0].xn,
            onboard_arrived[onboard_arrived.group==0].yn,
            c=shade_color("C0", -50), label="Group 0")
plt.scatter(onboard_arrived[onboard_arrived.group==1].xn,
            onboard_arrived[onboard_arrived.group==1].yn,
            c="C0", label="Group 1")
plot_targets(show_start=False, show_final=False, target_coords=[TARGET])
plt.title("Onboard")
plt.legend()


    

    
Out[633]:





<matplotlib.legend.Legend at 0x7feee2523da0>






    

In [101]:

    

plt.scatter(spirit_arrived[spirit_arrived.order==1].xn, spirit_arrived[spirit_arrived.order==1].yn, label="Run 1", c=saturate_color("C1", -50))
plt.scatter(spirit_arrived[spirit_arrived.order==2].xn, spirit_arrived[spirit_arrived.order==2].yn, label="Run 2", c=saturate_color("C1", -25))
plt.scatter(spirit_arrived[spirit_arrived.order==3].xn, spirit_arrived[spirit_arrived.order==3].yn, label="Run 3", c=saturate_color("C1", 10))
plt.scatter(spirit_arrived[spirit_arrived.order==4].xn, spirit_arrived[spirit_arrived.order==4].yn, label="Run 4", c=saturate_color("C1", 50))
plot_targets(show_start=False, show_final=False, target_coords=[TARGET])
plt.title("SPIRIT")
plt.legend()
plt.axis("equal")


    

    
Out[101]:





(-0.35671556917940106,
 0.83579532867796602,
 4.7432750819855078,
 7.253605687744491)






    

In [640]:

    

plt.scatter(onboard_arrived[onboard_arrived.order==1].xn, onboard_arrived[onboard_arrived.order==1].yn, label="Run 1", c=shade_color("C0", -50))
plt.scatter(onboard_arrived[onboard_arrived.order==2].xn, onboard_arrived[onboard_arrived.order==2].yn, label="Run 2", c=shade_color("C0", -25))
plt.scatter(onboard_arrived[onboard_arrived.order==3].xn, onboard_arrived[onboard_arrived.order==3].yn, label="Run 3", c=shade_color("C0", 0))
plt.scatter(onboard_arrived[onboard_arrived.order==4].xn, onboard_arrived[onboard_arrived.order==4].yn, label="Run 4", c=shade_color("C0", 25))
plot_targets(show_start=False, show_final=False, target_coords=[TARGET])
plt.title("Onboard")
plt.legend()


    

    
Out[640]:





<matplotlib.legend.Legend at 0x7feee1f9a5c0>






    

In [642]:

    

analyses[analyses.user == 6].sort_values


    

    
Out[642]:





<bound method DataFrame.sort_values of     user              experiment  run   dist_err     x_err     y_err  \
12   6.0  ExperimentType.Onboard  0.0  11.322550 -0.611649  0.693983   
13   6.0  ExperimentType.Onboard  1.0  11.728489  0.252302  0.274229   
28   6.0   ExperimentType.Spirit  2.0  11.754809 -0.087296  0.245515   
29   6.0   ExperimentType.Spirit  3.0  11.920676 -0.270667  0.082450   

    dist_std     x_std     y_std       rms     rms_x     rms_y   duration  \
12  0.003611  0.003397  0.003434  0.925068  0.611658  0.693991  23.331129   
13  0.001770  0.008907  0.001584  0.372745  0.252457  0.274233  45.919718   
28  0.004243  0.003775  0.004216  0.260633  0.087376  0.245551  61.347842   
29  0.010691  0.035311  0.011451  0.285352  0.272942  0.083235  40.722825   

    group                   start  experiment_int  order  
12    0.0  ExperimentType.Onboard               1    1.0  
13    0.0  ExperimentType.Onboard               1    2.0  
28    0.0  ExperimentType.Onboard               2    3.0  
29    0.0  ExperimentType.Onboard               2    4.0  >

In [643]:

    

analyses[analyses.group == 0].rms.mean()


    

    
Out[643]:





0.67435106579040993

In [644]:

    

analyses[analyses.group == 1].rms.mean()


    

    
Out[644]:





0.63270993517112506

In [645]:

    

analyses[analyses.experiment_type == ExperimentType.Spirit].dist_err.mean()


    

    
Out[645]:





11.966150697499852

In [646]:

    

analyses[analyses.experiment_type == ExperimentType.Onboard].rms.mean()


    

    
Out[646]:





0.83362377161648848

In [647]:

    

analyses[(analyses.experiment_type == ExperimentType.Spirit) & (analyses.group == 0)].rms.mean()


    

    
Out[647]:





0.32309553774994576

In [648]:

    

analyses[(analyses.experiment_type == ExperimentType.Spirit) & (analyses.group == 1)].rms.mean()


    

    
Out[648]:





0.6237789209401472

In [649]:

    

analyses[(analyses.experiment_type == ExperimentType.Onboard) & (analyses.group == 0)].rms.mean()


    

    
Out[649]:





1.0256065938308743

In [650]:

    

analyses[(analyses.experiment_type == ExperimentType.Onboard) & (analyses.group == 1)].rms.mean()


    

    
Out[650]:





0.64164094940210281

In [651]:

    

plt.get_cmap("Dark2").colors


    

    
Out[651]:





((0.10588235294117647, 0.6196078431372549, 0.4666666666666667),
 (0.8509803921568627, 0.37254901960784315, 0.00784313725490196),
 (0.4588235294117647, 0.4392156862745098, 0.7019607843137254),
 (0.9058823529411765, 0.1607843137254902, 0.5411764705882353),
 (0.4, 0.6509803921568628, 0.11764705882352941),
 (0.9019607843137255, 0.6705882352941176, 0.00784313725490196),
 (0.6509803921568628, 0.4627450980392157, 0.11372549019607843),
 (0.4, 0.4, 0.4))

In [652]:

    

dt=analyses.duration.iloc[0]


    

In [227]:

    

g = sns.factorplot(x="experiment", y="duration", data=analyses, hue="group",
                   size=6, aspect=.75, kind="box")
sns.swarmplot(x="experiment", y="duration", data=analyses, hue="group", split=True, palette="Set2")
plt.ylim(0, 80)
g.despine(left=True)


    

    
Out[227]:





<seaborn.axisgrid.FacetGrid at 0x7f2d0b48bac8>






    

In [655]:

    

g = sns.factorplot(x="experiment", y="duration", data=analyses, hue="group",
                   capsize=.2, size=6, aspect=.75, kind="bar")
g.despine(left=True)