diff --git a/docs/example-analyses/simulation-finding-funniest.py b/docs/example-analyses/simulation-finding-funniest.py
new file mode 100644
index 0000000..64f7989
--- /dev/null
+++ b/docs/example-analyses/simulation-finding-funniest.py
@@ -0,0 +1,427 @@
+import numpy as np
+from typing import List, Dict, Any
+
+# R is half of the range of possible values. Here, it's (3-1)/2 = 2/2 = 1.
+R = 1.0
+
+# delta is the failure probability -- i.e. set delta = 0.05 for 1-delta = 95% success probability.
+delta = 0.05
+
+# ------------------- DEFINE CLASSES FOR DIFFERENT SAMPLERS -------------------
+
+class Random:
+    def __init__(self, n:int):
+        """
+        Parameters
+        ----------
+        - n:int, number of targets (captions/videos/etc)
+        
+        Vars in function
+        ----------------
+        - self._initialized tracks whether some lists, other variables have been created yet
+        - self.name gives the model a name for purposes of tracking simulation results,
+            in case we want to plot simulation results for multiple models 
+        """
+        self.n = n
+        self.name = self.model_name() + " " + str(n)
+        self._initialized = False
+        
+    def model_name(self):
+        return "Random"
+    
+    def get_queries(self, n_queries=100):
+        """
+        Parameters
+        ----------
+        n_queries: int
+            Number of queries to queue up for a user
+        
+        Returns
+        -------
+        indices:List[int], len(indices) = n
+            uniformly random permutation of values from 0 to "number of targets - 1" (i.e. n-1)
+        scores:List[float], len(scores) = n
+            List of n scores (where the score at index i corresponds to caption i) between 0 and 1.
+            Represents quality of the query that can be posed to the user.
+            Note that, for class Random, scores are just assigned randomly, so they don't really represent quality here.
+        """
+        indices = np.arange(self.n).astype(int)
+        scores = np.random.uniform(0, 1, size=len(indices))
+        
+        return indices, scores
+
+    def _initialize(self):
+        """
+        Initializes lists for storing info about user ratings of captions.
+            Index i of self._reward_ stores the sum of user-provided ratings for caption i.
+            Index i of self._reward_squared_ stores the sum of the squares of user-provided ratings for caption i.
+            Index i of self._hits_ stores the number of times users have rated caption i.
+            Set self._initialized = True so this initialization does not overwrite things every time.
+            Index i of self.emp_avg_ratings_ stores the average user-provided rating for caption i.
+            Index i of self.ucbs_ stores the distance from caption i to its upper (lower) "delta"-width confidence bound.
+        """
+        self._reward_ = np.zeros(self.n)
+        self._reward_squared_ = np.zeros(self.n)
+        self._hits_ = np.zeros(self.n)
+        self.emp_avg_ratings_ = self._reward_ / np.maximum(self._hits_, 1)
+        self.ucbs_ = self.calculate_ucbs(self._hits_,self.emp_avg_ratings_,np.arange(self.n),np.zeros(self.n))
+        self.cis_ = self.calculate_95_ci(self._reward_squared_, self.emp_avg_ratings_, self._hits_)
+        self._initialized = True
+    
+    def partial_fit(self, answers:List[Dict[str, int]]):
+        """
+        Parameters
+        ----------
+        answers:List[Dict[str, int]]
+            A list of user-provided ratings of captions; each dict stores a single rating.
+            Format of each dictionary is {"index": caption index, "rating": 1 <= rating <= 3}.
+            
+        Returns
+        -------
+        self, which is the model
+            self.emp_avg_ratings_ is a list of ratings, where index i contains the average rating for caption i
+            self.ucbs_ is a list of numbers related to confidence intervals, where index i contains self.ucbs_,
+                where self.emp_avg_ratings_ \pm self.ucbs_ is the "delta" CI for the rating for caption i
+        """
+        if not self._initialized:
+            self._initialize()
+        for answer in answers:
+            self._reward_[answer["index"]] += answer["rating"]
+            self._reward_squared_[answer["index"]] += answer["rating"]**2
+            self._hits_[answer["index"]] += 1
+        self.emp_avg_ratings_ = self._reward_ / np.maximum(self._hits_, 1)
+        answer_indices = [answer["index"] for answer in answers]
+        self.ucbs_ = self.calculate_ucbs(self._hits_, self.emp_avg_ratings_, answer_indices, self.ucbs_)
+        self.cis_ = self.calculate_95_ci(self._reward_squared_, self.emp_avg_ratings_, self._hits_)
+
+        return self
+    
+    def calculate_ucbs(self, num_hits:List[int], emp_avg_ratings, answer_indices:List[int], old_ucbs:List[float]):
+        """
+        Parameters
+        ----------
+        num_hits:List[int]
+            A list of the number of user-provided ratings for a caption, where index i contains the 
+            number of user-provided ratings received for caption i.
+        emp_avg_ratings
+            A list of average user-provided ratings, where index i contains the average rating for caption i.
+        answer_indices:List[int]
+            List of caption numbers that received a user rating in the most recent round. Permits more efficient calculation
+            of UCBS when using lil_KLUCB.
+        old_ucbs:List[float]
+            List of old ucbs, where index i refers to the old ucb for caption i. Used for more efficiently
+            calculating ucbs for lil_KLUCB.
+            
+        Returns
+        -------
+        dist_to_upper:List[float]
+            A list of the distances from the average ratings for captions to the upper confidence bound on each caption's rating.
+            For caption i, index i is the distance from self.emp_avg_ratings_[i] to the upper confidence bound on the rating for caption i.
+            Note that the calculation of the UCB depends on "delta", where we want to find the best caption w.p. 1-delta.
+            This is done according to the lil-UCB algorithm.
+            See https://proceedings.neurips.cc/paper/2017/file/c02f9de3c2f3040751818aacc7f60b74-Paper.pdf.
+        """            
+        # Formula from
+        # https://github.com/nextml/NEXT/blob/4c8f4d5a66376a18c047f4c9409f73c75925bf07/apps/CardinalBanditsPureExploration/algs/LilUCB.py#L103
+        dist_to_upper = np.zeros(len(num_hits)) + 1e8
+        dist_to_upper[np.nonzero(num_hits)] = 2.0*R*R*np.log(4*num_hits[np.nonzero(num_hits)]*
+                                                             num_hits[np.nonzero(num_hits)]/delta ) / num_hits[np.nonzero(num_hits)]
+        return dist_to_upper
+    
+    def calculate_95_ci(self, sum_rewards_squared, empirical_mean, num_hits):
+        '''
+        Parameters
+        ----------
+        sum_rewards_squared
+            A list of ints, where index j stores Sum_i(rating_i^2) for caption j.
+            (We need to store this because Sum_i(rating_i^2) can't be computed directly from Sum_i(rating_i).)
+        empirical_mean
+            A list of floats, where index j stores [Sum_i(rating_i)]/n for caption j, where n is num_hits.
+        num_hits
+            A list of ints, where index j stores the number of user ratings for caption j.
+            
+        Returns
+        -------
+        A list of floats, where index j stores 1.96 times the standard deviation of the user-provided ratings for caption j.
+        (The 95% CI for caption j, then, is its empirical mean \pm this value.)
+        '''
+           
+        '''
+        Want to calculate
+        1.96 * sqrt{ \frac{ 1/n * (Sum_i (reward_i^2) - n * empirical_mean^2) } { (n-1) * n } }.
+        See https://github.com/nextml/NEXT/blob/4c8f4d5a66376a18c047f4c9409f73c75925bf07/apps/CardinalBanditsPureExploration/algs/LilUCB.py#L73
+        '''
+        ci_95 = np.zeros(len(num_hits)) + 1e8
+        numerator = sum_rewards_squared - num_hits * empirical_mean**2
+        denominator = (num_hits - 1) * num_hits ** 2
+
+        ci_95[np.argwhere(num_hits > 1)] = 1.96 * np.sqrt(numerator[np.argwhere(num_hits > 1)] / denominator[np.argwhere(num_hits > 1)])
+        return ci_95
+    
+class Active(Random):
+    def model_name(self):
+        return "Active"
+        
+    def get_queries(self, n_queries=100):
+        """
+        Parameters
+        ----------
+        n_queries:int
+            Number of queries to queue up for a user
+        
+        Returns
+        -------
+        indices:List[int], len(indices) = min(n_queries, n)
+            uniformly random permutation of values from 0 to "number of targets - 1" (i.e. n-1)
+        scores:List[float], len(scores) = n_queries
+            list of n_queries decimal values between 0 and 1. Represents quality of the query that can be posed to the user
+        """
+        if not self._initialized:
+            self._initialize()
+        
+        indices = np.arange(self.n).astype(int)
+        scores = self.emp_avg_ratings_ + self.ucbs_
+        
+        return indices, scores
+    
+class lil_KLUCB(Active):
+    def model_name(self):
+        return "lil_KLUCB"
+    
+    def calculate_ucbs(self, num_hits:List[int], emp_avg_ratings, answer_indices:List[int], old_ucbs:List[float]):
+        """
+        Parameters
+        ----------
+        num_hits:List[int]
+            A list of the number of user-provided ratings for a caption, where index i contains the 
+            number of user-provided ratings received for caption i.
+        emp_avg_ratings
+            A list of average user-provided ratings, where index i contains the average rating for caption i.
+        answer_indices:List[int]
+            List of caption numbers that received a user rating in the most recent round. Permits more efficient calculation
+            of UCBS when using lil_KLUCB.
+        old_ucbs:List[float]
+            List of old ucbs, where index i refers to the old ucb for caption i. Used for more efficiently
+            calculating ucbs for lil_KLUCB.            
+            
+        Returns
+        -------
+        dist_to_upper:List[float]
+            A list of the distances from the average ratings for captions to the upper "delta"-width confidence bound on each caption's rating.
+            For caption i, index i is the distance from self.emp_avg_ratings_[i] to the upper "delta"-width
+            confidence bound on the rating for caption i.
+            This is done according to the lil-KLUCB algorithm as stated in
+                https://proceedings.neurips.cc/paper/2017/file/c02f9de3c2f3040751818aacc7f60b74-Paper.pdf.
+        """
+        mu = emp_avg_ratings
+        UCB = old_ucbs
+        for i in answer_indices:
+            if num_hits[i]==0:
+                # mu[i] = float('inf')
+                UCB[i] = 1e8
+            else:
+                # UCB[i] = mu[i] + np.sqrt( 2.0*R*R*np.log( 4*T[i]*T[i]/delta ) / T[i] )
+                # Note that the line below only makes sense when the responses take values in {1,2,3}
+                # UCB[i] = self.computeUCB(muhat=(mu[i]-1)/2,threshold=(np.log(2*num_hits[i]*num_hits[i]/delta)/num_hits[i]))
+                UCB[i] = ( self.computeUCB(muhat=(mu[i]-1)/2,threshold=(np.log(2*num_hits[i]*num_hits[i]/delta)/num_hits[i])) )*2+1 - mu[i]
+        return UCB# - emp_avg_ratings  
+    
+    # Inspired by code at
+    # https://github.com/nextml/NEXT/blob/4c8f4d5a66376a18c047f4c9409f73c75925bf07/apps/CardinalBanditsPureExploration/algs/KLUCB.py#L128-L157
+    def computeUCB(self,muhat,threshold,accuracy=(10**(-6))):
+        lower=muhat
+        upper=1
+        UCB=(lower+upper)/2
+        while (upper-lower)>accuracy:
+            new=self.leftright(muhat,lower,upper,threshold)
+            lower=new[0]
+            upper=new[1]
+            UCB=new[2]
+        return UCB
+    
+    # Also inspired by code at
+    # https://github.com/nextml/NEXT/blob/4c8f4d5a66376a18c047f4c9409f73c75925bf07/apps/CardinalBanditsPureExploration/algs/KLUCB.py#L128-L157
+    def leftright(self,muhat,lower,upper,threshold):
+        if muhat*(1-muhat)!=0:
+            silly=(upper+lower)/2
+            KL=(muhat*np.log(muhat/silly))+((1-muhat)*np.log((1-muhat)/(1-silly)))
+            if KL>=threshold:
+                return [lower,silly,(silly+lower)/2]
+            if KL<threshold:
+                return [silly,upper,(silly+upper)/2]
+        if muhat==0:
+            silly=(upper+lower)/2
+            KL=(1-muhat)*np.log((1-muhat)/(1-silly))
+            if KL>=threshold:
+                return [lower,silly,(silly+lower)/2]
+            if KL<threshold:
+                return [silly,upper,(silly+upper)/2]
+        if muhat==1:
+            return [1,1,1]
+        
+# ------------------- END OF CLASSES FOR DIFFERENT SAMPLERS -------------------
+        
+    
+# ------------------- FUNCTIONS FOR RUNNING THE SIMULATION -------------------
+
+from typing import List
+
+def simulate_human_answer(index:int, captions:List[List[int]]) -> int:
+    """
+    Parameters
+    -----------
+    index:int
+        Which index do we want the score for?
+    captions:List[List[int]]
+        A list of caption scores. For any `i`, `len(captions[i]) == 3` because
+        it represents the number of unfunny, somewhat funny and funny ratings.
+
+    Returns
+    -------
+    rating:int
+        A rating of 1, 2 or 3 representing the "funniness" of a caption.
+    """
+    assert 0 <= index < len(captions)
+    ratings = np.asarray(captions[index]).astype(float)
+    ratings /= ratings.sum()
+    return np.random.choice([1, 2, 3], p=ratings)
+
+def num_potential_funniest(emp_avg_ratings, ucbs):
+    """
+    Parameters
+    ----------
+    emp_avg_ratings
+        Index i of emp_avg_ratings stores the average user-provided rating for caption i.
+    ucbs
+        Index i of ucbs stores the distance from caption i to its upper confidence bound for finding the best caption w.p. 1-delta.
+        
+    Returns
+    -------
+    Let j be the index of the caption with the highest empirical average rating.
+        This returns $Sum_i (emp_avg_ratings[i] + ucbs[i] > emp_avg_ratings[j] - ucbs[j])$
+    """
+    best_caption_index = np.argmax(emp_avg_ratings)
+    c = 1
+    best_avg_lower = emp_avg_ratings[best_caption_index] - c * ucbs[best_caption_index]
+    upper_bounds = emp_avg_ratings + c * ucbs
+    return (upper_bounds > best_avg_lower).sum()
+            
+def num_geq_funniest(emp_avg_ratings):
+    """
+    Parameters
+    ----------
+    emp_avg_ratings
+        Index i of emp_avg_ratings stores the average user-provided rating for caption i.
+        
+    Returns
+    -------
+    Let j be the index of the caption with the highest empirical average rating.
+        This returns $Sum_i (emp_avg_ratings[i] + ucbs[i] > emp_avg_ratings[j] - ucbs[j])$
+    """
+    return (emp_avg_ratings >= emp_avg_ratings[0]).sum()
+
+# simulation as a function
+def simulate_model(model_name, top_n_scores:int, total_queries:int):
+    '''
+    Parameters
+    ----------
+    model_name:str
+        The name with which we want to associate simulation results for that model.
+    top_n_scores:int
+        The number of captions each user should respond to. For example, top_n_scores = 5 simulates
+        the case in which each user rates 5 captions.
+    total_queries:int
+        The number of ratings to collect from users in a given caption contest. For example, total_queries = 400_000
+        simulates a caption contest with a total of 400,000 user-provided ratings.
+    
+    Returns
+    -------
+    A list of flat data with the items listed below in 'datum'
+    '''
+    data = []
+    for query_batch_num in range(total_queries//top_n_scores):
+        list_of_dicts = []
+        query_indices, query_scores = the_model.get_queries()
+
+        top_score_indices = np.argpartition(query_scores, -top_n_scores)[-top_n_scores:]
+
+        # pose queries to the human, and store in dict_ans
+        for index in query_indices[top_score_indices]:
+            # dictionary of answers
+            dict_ans = {}
+            index_rating = simulate_human_answer(index, no_header[:,-3:])
+            dict_ans["index"] = index
+            dict_ans["rating"] = index_rating
+            list_of_dicts.append(dict_ans)
+
+        the_model.partial_fit(list_of_dicts) 
+        datum = {"num_funniest":  num_potential_funniest(the_model.emp_avg_ratings_, the_model.cis_),
+                 "num_queries": (query_batch_num+1)*top_n_scores,
+                 "query_batch": query_batch_num,
+                 "top_n_scores": top_n_scores,
+                 "sampler": the_model.name,
+                 "num_geq_funniest": num_geq_funniest(the_model.emp_avg_ratings_)
+                }
+        data.append(datum)
+        
+    return data
+
+# ------------------- END OF FUNCTIONS FOR RUNNING THE SIMULATION -------------------
+
+# ------------------- RUN THE SIMULATION -------------------
+
+# Read CSV
+import pandas as pd
+# # Read dataset from download
+# df = pd.read_csv('803.csv')
+
+# Read dataset from online
+contest = 803
+dfs = pd.read_html(f"https://nextml.github.io/caption-contest-data/dashboards/{contest}.html")
+# Get the last table in the webpage
+df = dfs[-1]
+
+# .values removes the header row. (In this specific case, also want to remove first column.)
+no_header = df.values[:,1:]
+
+# PARAMETRIZE THE SIMULATION
+
+total_queries = 400_000
+
+# Create model and get queries
+the_model = lil_KLUCB(len(no_header))
+
+list_of_models = [lil_KLUCB(len(no_header)), Active(len(no_header)), Random(len(no_header))]
+list_of_models = ["lil_KLUCB", "Active", "Random"]
+
+top_n_scores = 5
+
+data = []
+num_samples = 10
+for _ in range(num_samples):
+    the_model = 0
+    for model_name in list_of_models:
+        if model_name == "lil_KLUCB":
+            the_model = lil_KLUCB(len(no_header))
+        elif model_name == "Active":
+            the_model = Active(len(no_header))
+        elif model_name == "Random":
+            the_model = Random(len(no_header))
+        data = data + simulate_model(the_model, top_n_scores, total_queries)
+        
+# WRITE SIMULATION RESULTS TO CSV
+
+import pandas as pd
+def list_to_csv(input_list, save_name):
+    df = pd.DataFrame(input_list)
+    df.to_csv(save_name)
+    
+def csv_to_dataframe(input_csv):
+    return pd.read_csv(input_csv)
+
+import datetime
+
+current_datetime = datetime.datetime.now()
+current_datetime = current_datetime.strftime('%Y%m%d%T').replace(":","")
+# list_to_csv(data, "seaborn" + str(current_datetime) + ".csv")
+list_to_csv(data, "seaborn_test_huge2.csv")
diff --git a/docs/example-analyses/stats_next.py b/docs/example-analyses/stats_next.py
new file mode 100644
index 0000000..d0aae53
--- /dev/null
+++ b/docs/example-analyses/stats_next.py
@@ -0,0 +1,246 @@
+"""
+From https://github.com/stsievert/salmon-experiments/blob/8daa4e23ca9960bc585a83828ff6ab71f1b90584/response-rate-next2/stats_next.py
+
+This file is a collection of various stat functions.
+Input: embedding filenames.
+Output: stats for each embedding.
+The following stats are collected:
+* Accuracy
+* Distance from ground truth embedding
+* Nearest neighbor accuracy
+"""
+
+from time import time
+from typing import Tuple, Union, Dict, List, Tuple
+from numbers import Number as NumberType
+import msgpack
+import pandas as pd
+from pprint import pprint
+
+import numpy as np
+from scipy.spatial import procrustes
+from scipy.spatial.distance import pdist, squareform
+from sklearn.manifold import SpectralEmbedding
+import numpy.linalg as LA
+
+ArrayLike = Union[list, np.ndarray]
+Number = Union[NumberType, int, float, np.integer, np.floating]
+
+
+def collect(
+    embedding: ArrayLike, targets: List[int], X_test: ArrayLike
+) -> Dict[str, float]:
+    embedding = np.asarray(embedding)
+    X_test = np.asarray(X_test)
+
+    accuracy = _get_acc(embedding, X_test)
+    nn_acc, nn_diffs = _get_nn_diffs(embedding, targets)
+
+    diff_stats = {
+        f"nn_diff_p{k}": np.percentile(nn_diffs, k)
+        for k in [99, 98, 95, 90, 80, 70, 60, 50, 40, 30, 20, 10, 5, 2, 1]
+    }
+    nn_dists = {f"nn_acc_radius_{k}": (nn_diffs <= k).mean() for k in range(30)}
+
+    n, d = embedding.shape
+    stats = {}
+    if d > 1:
+        reduce = SpectralEmbedding(n_components=1, affinity="nearest_neighbors")
+        embedding = reduce.fit_transform(embedding)
+    norm = np.linalg.norm
+    if targets:
+        ground_truth = np.array(targets)
+        assert (np.diff(ground_truth) > 0).all()
+        ground_truth = ground_truth.reshape(-1, 1)
+    else:
+        ground_truth = np.arange(n).reshape(-1, 1)
+    Y1, Y2, disparity = procrustes(ground_truth, embedding)
+    stats = {
+        "embedding_error": norm(Y1 - Y2),
+        "embedding_rel_error": norm(Y1 - Y2) / norm(Y1),
+        "procrustes_disparity": disparity,
+    }
+
+    return {
+        "accuracy": accuracy,
+        "nn_diff_median": np.median(nn_diffs),
+        "nn_diff_mean": nn_diffs.mean(),
+        "nn_acc": nn_acc,
+        "avg_items_closer_than_NN": np.mean(items_closer_than_true_NN(embedding, targets)),
+        **diff_stats,
+        **stats,
+        **nn_dists,
+        **_dist_stats(ground_truth, embedding),
+    }
+
+
+def _dist_stats(ground_truth: np.ndarray, em: np.ndarray) -> Dict[str, Number]:
+    D_star = pdist(ground_truth)
+    D_hat = pdist(em)
+    D_star /= D_star.max()
+    D_hat /= D_hat.max()
+    return {"dist_rel_error": LA.norm(D_hat - D_star) / LA.norm(D_star)}
+
+
+def _get_acc(embedding: np.ndarray, X: np.ndarray) -> float:
+    assert isinstance(embedding, np.ndarray)
+    n, d = embedding.shape
+    # X[i] is always [h, w, l] so zero is the right choice.
+    y = np.zeros(len(X)).astype("int")
+    assert X.ndim == 2 and X.shape[1] == 3, f"{type(X)}, {X.shape}"
+    y_hat = TSTE_predict(X, embedding=embedding)
+    assert all(_.dtype.kind in ["u", "i"] for _ in [y, y_hat])
+    acc = (y == y_hat).mean()
+    return acc
+
+
+def nn_accs(em: np.ndarray, targets: List[int]):
+    nn_acc, nn_diffs = _get_nn_diffs(embedding, targets)
+
+    diff_stats = {
+        f"nn_diff_p{k}": np.percentile(nn_diffs, k)
+        for k in [99, 98, 95, 90, 80, 70, 60, 50, 40, 30, 20, 10, 5, 2, 1]
+    }
+    nn_dists = {f"nn_acc_radius_{k}": (nn_diffs <= k).mean() for k in range(30)}
+    return nn_dists
+
+def _get_nn_diffs(embedding, targets: List[int]) -> Tuple[float, np.ndarray]:
+    """
+    Get the NN accuracy and the number of objects that are closer than the
+    true NN.
+    """
+    true_nns = []
+    t = np.array(targets)
+    for ti in targets:
+        true_dist = np.abs(t - ti).astype("float32")
+        true_dist[true_dist <= 0] = np.inf
+        true_nns.append(true_dist.argmin())
+    true_nns = np.array(true_nns).astype("int")
+
+    dists = distances(gram_matrix(embedding))
+    dists[dists <= 0] = np.inf
+
+    neighbors = dists.argmin(axis=1)
+    neighbor_dists = np.abs(neighbors - true_nns)
+    nn_acc = (neighbor_dists == 0).mean()
+    return nn_acc, neighbor_dists
+
+def items_closer_than_true_NN(embedding, targets) -> List[int]:
+    # find true nearest neighbors
+    true_nns = []
+    t = np.array(targets)
+    for ti in targets:
+        true_dist = np.abs(t - ti).astype("float32")
+        true_dist[np.abs(true_dist) < 1e-3] = np.inf
+        true_nns.append(true_dist.argmin())
+
+    # for each item in the embedding, how many items are between
+    # it and the true NN?
+
+    ## so, get distance matrix
+    dists = distances(gram_matrix(embedding))
+    dists[dists <= 0] = np.inf
+
+    items_closer_than_NNs = []
+    for dist, true_nn in zip(dists, true_nns):
+        true_nn_dist = dist[true_nn]
+        items_closer_than_NN = (dist < true_nn_dist).sum()
+        items_closer_than_NNs.append(items_closer_than_NN)
+    return items_closer_than_NNs
+
+
+#################################################################
+## everything from here down copied from Salmon
+# salmon/triplets/samplers/_adaptive_runners.py#Adaptive.predict
+# salmon/triplets/samplers/adaptive/search/gram_utils.py
+#################################################################
+Array = np.ndarray
+def gram_matrix(X: Array) -> Array:
+    """
+    Get Gram matrix from embedding
+    Arguments
+    ---------
+    X : Array
+        Embedding. X.shape == (num_items, item_dim)
+    Returns
+    -------
+    G : Array
+        Gram matrix. G.shape == (n, n)
+    """
+#     if isinstance(X, torch.Tensor):
+#         return X @ X.transpose(0, 1)
+    return X @ X.T
+
+
+def distances(G: Array) -> Array:
+    """
+    Get distance matrix from gram matrix
+    Arguments
+    ---------
+    G : Array
+        Gram matrix. G.shape == (n, n) for n objects
+    Returns
+    -------
+    D : Array
+        Distance matrix. D.shape == (n, n)
+    """
+    G1 = np.diag(G).reshape(1, -1)
+    G2 = np.diag(G).reshape(-1, 1)
+
+    D = -2 * G + G1 + G2
+    return D
+
+def TSTE_predict(X, embedding=None):
+    """
+    Predict the answers of queries from the current embedding.
+    Parameters
+    ----------
+    X : array-like
+        Each row is ``[head, left, right]``. Each element in ``X`` or
+        ``X[i, j]`` is an index of the current embedding.
+    Returns
+    -------
+    y : array-like
+        The winner of each query. An element of ``y`` is 0 if the left
+        item is the predicted winner, and 1 if the right element is the
+        predicted winner.
+    """
+    head_idx = X[:, 0].flatten()
+    left_idx = X[:, 1].flatten()
+    right_idx = X[:, 2].flatten()
+
+    head = embedding[head_idx]
+    left = embedding[left_idx]
+    right = embedding[right_idx]
+
+    ldiff = LA.norm(head - left, axis=1)
+    rdiff = LA.norm(head - right, axis=1)
+
+    # 1 if right closer; 0 if left closer
+    # (which matches the labeling scheme)
+    right_closer = rdiff < ldiff
+    return right_closer.astype("uint8")
+
+if __name__ == "__main__":
+    file = "salmon/io/2021-05-18/ARR-1_history.msgpack"
+    file = "next/io/2021-05-18/rate=1_history.msgpack"
+    with open(file, "rb") as f:
+        history = msgpack.load(f)
+    datum = history[-1]
+    em = datum["embedding"]
+    n_responses = datum["meta"]["n_responses"]
+    fnames = pd.read_csv("targets.csv.zip", header=None)[0].tolist()
+    targets = [int(f.strip("i.png")) for f in fnames]
+    targets = list(sorted(targets))
+
+    X_test = [
+        [i_h, i_l, i_r] if abs(h - l) < abs(h - r) else [i_h, i_r, i_l]
+        for i_h, h in enumerate(targets)
+        for i_l, l in enumerate(targets)
+        for i_r, r in enumerate(targets)
+        if h not in [l, r] and l != r
+    ]
+
+    s = collect(em, targets, X_test)
+    print(len(history))
+    print(n_responses, s["accuracy"])
diff --git a/docs/example-analyses/visualization-finding-funniest.ipynb b/docs/example-analyses/visualization-finding-funniest.ipynb
new file mode 100644
index 0000000..b9fd9fa
--- /dev/null
+++ b/docs/example-analyses/visualization-finding-funniest.ipynb
@@ -0,0 +1,181 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b29449d7-13d2-4a80-b5d0-c706f9a4bd9a",
+   "metadata": {},
+   "source": [
+    "# Finding the funniest caption\n",
+    "\n",
+    "The visualizations in this notebook attempt to show how quickly a \"best caption\" rises to the top of the rankings. We perform two visualizations.\n",
+    "1. The graph titled \"# Captions within 95% CI of Current Funniest\" provides a visualization for how soon *a* caption (not necessarily the *true* funniest caption) can plausibly be identified as the funniest. First, the average user-provided rating is computed for each caption. Then, a 95% CI is computed for each of these average user-provided ratings (basically using the central limit theorem). The corresponding graph displays the number of captions with a 95% CI intersecting the 95% CI around the caption with the highest average user-provided rating.\n",
+    "1. The graph titled \"# Captions with Simulated Rating Higher than True Funniest\" provides a visualization for how quickly the funniest caption can be correctly identified. the following. Recall that we have access to the ground truth for which caption is funniest. This graph displays how many captions, after a given number of queries, have recieved an average user-provided rating that is better than the average user-provided rating received by the true funniest caption.\n",
+    "\n",
+    "Each visualization is performed for three different learning strategies.\n",
+    "1. \"Random\" randomly selects captions for users to rate.\n",
+    "1. \"Active\" adaptively chooses captions for users to rate according to the upper confidence bound strategy described in https://arxiv.org/abs/1312.7308.\n",
+    "1. \"lil_KLUCB\" adaptively chooses captions for users to rate according to the upper confidence bound strategy described in https://arxiv.org/abs/1709.03570.\n",
+    "\n",
+    "The line on each graph is a plot of the mean, taken over 10 samples. The shaded region around each line is the standard deviation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f102aef8-fa04-43e7-8390-a37880067ef3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python simulation-finding-funniest.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "60a0aac3-b89f-4c1c-92fd-9e1709366c5a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "import viz"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "1e88d592-f52d-4128-8552-82edc83cad42",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "def list_to_csv(input_list, save_name):\n",
+    "    df = pd.DataFrame(input_list)\n",
+    "    df.to_csv(save_name)\n",
+    "    \n",
+    "def csv_to_dataframe(input_csv):\n",
+    "    return pd.read_csv(input_csv)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d373c4e3-15a7-4871-9fb5-cca15aeafc00",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = csv_to_dataframe(\"seaborn_test_huge2.csv\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "864c5d01-4f90-4a20-847e-37da471e0038",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.8, 11867.903583496167)"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ax = viz.lineplot(\n",
+    "    x=\"num_queries\",\n",
+    "    y=\"num_funniest\",\n",
+    "    hue=\"sampler\",\n",
+    "    ci=.25,\n",
+    "    data=df,\n",
+    "    palette = sns.color_palette()\n",
+    ")\n",
+    "ax.set_yscale(\"log\")\n",
+    "# ax.set_xscale(\"log\")\n",
+    "ax.set_title(\"# Captions within 95% CI of Current Funniest\")\n",
+    "ax.set_ylim(bottom=.8)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "1119e1a9-8127-444a-ba18-cac4d693210a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.8, 11867.903583496167)"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ax = viz.lineplot(\n",
+    "    x=\"num_queries\",\n",
+    "    y=\"num_geq_funniest\",\n",
+    "    hue=\"sampler\",\n",
+    "    ci=.25,\n",
+    "    data=df,\n",
+    "    palette = sns.color_palette()\n",
+    ")\n",
+    "ax.set_yscale(\"log\")\n",
+    "# ax.set_xscale(\"log\")\n",
+    "ax.set_title(\"# Captions with Simulated Rating Higher than True Funniest\")\n",
+    "ax.set_ylim(bottom=.8)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/example-analyses/viz.py b/docs/example-analyses/viz.py
new file mode 100644
index 0000000..04e47ca
--- /dev/null
+++ b/docs/example-analyses/viz.py
@@ -0,0 +1,49 @@
+"""
+From https://github.com/stsievert/salmon-experiments/blob/8daa4e23ca9960bc585a83828ff6ab71f1b90584/response-rate-next2/viz.py
+"""
+
+import stats_next as stats
+import pandas as pd
+import msgpack
+import warnings
+
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+import numpy as np
+
+def lineplot(
+    data, x, y, hue, style="-", hue_order=None, ci=0.25, ax=None, estimator="median", palette="copper"
+):
+    if ax is None:
+        fig, ax = plt.subplots()
+    if hue_order is None:
+        hue_order = sorted(data[hue].unique())
+    if isinstance(palette, list):
+        colors = palette
+    else:
+        cmap = mpl.cm.get_cmap(palette)
+        colors = [cmap(x) for x in np.linspace(0, 1, num=len(hue_order))]
+    for k, (h, color) in enumerate(zip(hue_order, colors)):
+        show = data[data[hue] == h]
+        kwargs = dict(index=x, values=y)
+        middle = show.pivot_table(aggfunc=estimator, **kwargs)
+        if not len(middle):
+            continue
+        _style = style if "C" not in style else style.format(k=k)
+        if isinstance(style, list):
+            _style = style[k]
+        
+        ax.plot(middle, _style, label=h, color=color)
+        if ci > 0:
+            lower = show.pivot_table(aggfunc=lambda x: x.quantile(q=ci), **kwargs)
+            upper = show.pivot_table(aggfunc=lambda x: x.quantile(q=1 - ci), **kwargs)
+            assert (lower.index == upper.index).all()
+            ax.fill_between(
+                lower.index.values,
+                y1=lower.values.flatten(),
+                y2=upper.values.flatten(),
+                color=color,
+                alpha=0.2,
+            )
+    ax.legend(loc="best")
+    return ax