redisbench-admin 0.11.65__py3-none-any.whl → 0.11.67__py3-none-any.whl

redisbench_admin/run/ann/pkg/ann_benchmarks/main.py

@@ -1,325 +0,0 @@
-from __future__ import absolute_import
-import argparse
-import logging
-import logging.config
-
-import docker
-import multiprocessing.pool
-import os
-import psutil
-import random
-import shutil
-import sys
-import traceback
-import time
-
-from ann_benchmarks.datasets import get_dataset, DATASETS
-from ann_benchmarks.constants import INDEX_DIR
-from ann_benchmarks.algorithms.definitions import (get_definitions,
-                                                   list_algorithms,
-                                                   algorithm_status,
-                                                   InstantiationStatus)
-from ann_benchmarks.results import get_result_filename
-from ann_benchmarks.runner import run, run_docker
-
-
-def positive_int(s):
-    i = None
-    try:
-        i = int(s)
-    except ValueError:
-        pass
-    if not i or i < 1:
-        raise argparse.ArgumentTypeError("%r is not a positive integer" % s)
-    return i
-
-
-def run_worker(cpu, args, queue):
-    while not queue.empty():
-        definition = queue.get()
-        if args.local:
-            run(definition, args.dataset, args.count, args.runs, args.batch,
-                args.build_only, args.test_only, args.total_clients, args.client_id)
-        else:
-            memory_margin = 500e6  # reserve some extra memory for misc stuff
-            mem_limit = int((psutil.virtual_memory().available - memory_margin) / args.parallelism)
-            cpu_limit = str(cpu)
-            if args.batch:
-                cpu_limit = "0-%d" % (multiprocessing.cpu_count() - 1)
-
-            run_docker(definition, args.dataset, args.count,
-                       args.runs, args.timeout, args.batch, cpu_limit, mem_limit)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument(
-        '--dataset',
-        metavar='NAME',
-        help='the dataset to load training points from',
-        default='glove-100-angular',
-        choices=DATASETS.keys())
-    parser.add_argument(
-        "-k", "--count",
-        default=10,
-        type=positive_int,
-        help="the number of near neighbours to search for")
-    parser.add_argument(
-        '--definitions',
-        metavar='FILE',
-        help='load algorithm definitions from FILE',
-        default='algos.yaml')
-    parser.add_argument(
-        '--algorithm',
-        metavar='NAME',
-        help='run only the named algorithm',
-        default=None)
-    parser.add_argument(
-        '--run-group',
-        metavar='NAME',
-        help='run only the named run group',
-        default=None)
-    parser.add_argument(
-        '--docker-tag',
-        metavar='NAME',
-        help='run only algorithms in a particular docker image',
-        default=None)
-    parser.add_argument(
-        '--list-algorithms',
-        help='print the names of all known algorithms and exit',
-        action='store_true')
-    parser.add_argument(
-        '--force',
-        help='re-run algorithms even if their results already exist',
-        action='store_true')
-    parser.add_argument(
-        '--runs',
-        metavar='COUNT',
-        type=positive_int,
-        help='run each algorithm instance %(metavar)s times and use only'
-             ' the best result',
-        default=5)
-    parser.add_argument(
-        '--timeout',
-        type=int,
-        help='Timeout (in seconds) for each individual algorithm run, or -1'
-             'if no timeout should be set',
-        default=2 * 3600)
-    parser.add_argument(
-        '--local',
-        action='store_true',
-        help='If set, then will run everything locally (inside the same '
-             'process) rather than using Docker')
-    parser.add_argument(
-        '--batch',
-        action='store_true',
-        help='If set, algorithms get all queries at once')
-    parser.add_argument(
-        '--max-n-algorithms',
-        type=int,
-        help='Max number of algorithms to run (just used for testing)',
-        default=-1)
-    parser.add_argument(
-        '--run-disabled',
-        help='run algorithms that are disabled in algos.yml',
-        action='store_true')
-    parser.add_argument(
-        '--parallelism',
-        type=positive_int,
-        help='Number of Docker containers in parallel',
-        default=1)
-    parser.add_argument(
-        '--build-only',
-        action='store_true',
-        help='building index only, not testing with queries')
-    parser.add_argument(
-        '--test-only',
-        action='store_true',
-        help='querying index only, not building it (should be built first)')
-    parser.add_argument(
-        '--cluster',
-        action='store_true',
-        help='working with a cluster')
-    parser.add_argument(
-        '--host',
-        metavar='NAME',
-        help='host name or IP',
-        default=None)
-    parser.add_argument(
-        '--port',
-        type=positive_int,
-        help='the port "host" is listening on',
-        default=None)
-    parser.add_argument(
-        '--auth', '-a',
-        metavar='PASSWORD',
-        help='password for connection',
-        default=None)
-    parser.add_argument(
-        '--user',
-        metavar='NAME',
-        help='user name for connection',
-        default=None)
-    parser.add_argument(
-        '--total-clients',
-        metavar='NUM',
-        type=positive_int,
-        help='total number of clients running in parallel',
-        default=1)
-    parser.add_argument(
-        '--client-id',
-        metavar='NUM',
-        type=positive_int,
-        help='specific client id (among the total clients)',
-        default=1)
-    parser.add_argument(
-        '--shards',
-        type=str,
-        metavar='NUM',
-        default="1",
-        help='specify number of shards')
-
-    args = parser.parse_args()
-    if args.timeout == -1:
-        args.timeout = None
-
-    if args.list_algorithms:
-        list_algorithms(args.definitions)
-        sys.exit(0)
-
-    if args.build_only and args.test_only:
-        raise Exception('Nothing to run (build only and test only was specified)')
-    if (args.build_only or args.test_only) and not args.local:
-        raise Exception('Can\'t run build or test only on docker')
-
-    conn_params = {'host': args.host, 'port': args.port, 'auth': args.auth, 'user': args.user, 'cluster': args.cluster, 'shards': args.shards}
-
-    if args.total_clients < args.client_id:
-        raise Exception('must satisfy 1 <= client_id <= total_clients')
-
-    logging.config.fileConfig("logging.conf")
-    logger = logging.getLogger("annb")
-
-    # Nmslib specific code
-    # Remove old indices stored on disk
-    if os.path.exists(INDEX_DIR):
-        shutil.rmtree(INDEX_DIR)
-
-    dataset, dimension = get_dataset(args.dataset)
-    point_type = dataset.attrs.get('point_type', 'float')
-    distance = dataset.attrs['distance']
-    definitions = get_definitions(
-        args.definitions, dimension, point_type, distance, args.count, conn_params)
-
-    # Filter out, from the loaded definitions, all those query argument groups
-    # that correspond to experiments that have already been run. (This might
-    # mean removing a definition altogether, so we can't just use a list
-    # comprehension.)
-    filtered_definitions = []
-    for definition in definitions:
-        query_argument_groups = definition.query_argument_groups
-        if not query_argument_groups:
-            query_argument_groups = [[]]
-        not_yet_run = []
-        for query_arguments in query_argument_groups:
-            fn = get_result_filename(args.dataset,
-                                     args.count, definition,
-                                     query_arguments, args.batch)
-            if args.force or not os.path.exists(fn):
-                not_yet_run.append(query_arguments)
-        if not_yet_run:
-            if definition.query_argument_groups:
-                definition = definition._replace(
-                    query_argument_groups=not_yet_run)
-            filtered_definitions.append(definition)
-    definitions = filtered_definitions
-
-    random.shuffle(definitions)
-
-    if args.algorithm:
-        logger.info(f'running only {args.algorithm} algorithms')
-        definitions = [d for d in definitions if d.algorithm == args.algorithm]
-
-    if args.run_group:
-        logger.info(f'running only {args.run_group} run groups')
-        definitions = [d for d in definitions if d.run_group == args.run_group]
-
-    if not args.local:
-        # See which Docker images we have available
-        docker_client = docker.from_env()
-        docker_tags = set()
-        for image in docker_client.images.list():
-            for tag in image.tags:
-                tag = tag.split(':')[0]
-                docker_tags.add(tag)
-
-        if args.docker_tag:
-            logger.info(f'running only {args.docker_tag}')
-            definitions = [
-                d for d in definitions if d.docker_tag == args.docker_tag]
-
-        if set(d.docker_tag for d in definitions).difference(docker_tags):
-            logger.info(f'not all docker images available, only: {set(docker_tags)}')
-            logger.info(f'missing docker images: '
-                        f'{str(set(d.docker_tag for d in definitions).difference(docker_tags))}')
-            definitions = [
-                d for d in definitions if d.docker_tag in docker_tags]
-    else:
-        def _test(df):
-            status = algorithm_status(df)
-            # If the module was loaded but doesn't actually have a constructor
-            # of the right name, then the definition is broken
-            if status == InstantiationStatus.NO_CONSTRUCTOR:
-                raise Exception("%s.%s(%s): error: the module '%s' does not"
-                                " expose the named constructor" % (
-                                    df.module, df.constructor,
-                                    df.arguments, df.module))
-
-            if status == InstantiationStatus.NO_MODULE:
-                # If the module couldn't be loaded (presumably because
-                # of a missing dependency), print a warning and remove
-                # this definition from the list of things to be run
-                logging.warning("%s.%s(%s): the module '%s' could not be "
-                      "loaded; skipping" % (df.module, df.constructor,
-                                            df.arguments, df.module))
-                return False
-            else:
-                return True
-        definitions = [d for d in definitions if _test(d)]
-
-    if not args.run_disabled:
-        if len([d for d in definitions if d.disabled]):
-            logger.info(f'Not running disabled algorithms {[d for d in definitions if d.disabled]}')
-        definitions = [d for d in definitions if not d.disabled]
-
-    if args.max_n_algorithms >= 0:
-        definitions = definitions[:args.max_n_algorithms]
-
-    if len(definitions) == 0:
-        raise Exception('Nothing to run')
-    else:
-        logger.info(f'Order: {definitions}')
-
-    if args.parallelism > multiprocessing.cpu_count() - 1:
-        raise Exception('Parallelism larger than %d! (CPU count minus one)' % (multiprocessing.cpu_count() - 1))
-
-    # Multiprocessing magic to farm this out to all CPUs
-    queue = multiprocessing.Queue()
-    for definition in definitions:
-        queue.put(definition)
-
-    if args.parallelism == 1:
-        # Wait for some jobs to be inserted into the queue
-        while queue.empty(): time.sleep(0.01)
-        # If we're only running one worker, then we can just run it in the same process
-        run_worker(1, args, queue)
-    else:
-        if args.batch:
-            raise Exception(f"Batch mode uses all available CPU resources, --parallelism should be set to 1. (Was: {args.parallelism})")
-        workers = [multiprocessing.Process(target=run_worker, args=(i+1, args, queue))
-                   for i in range(args.parallelism)]
-        [worker.start() for worker in workers]
-        [worker.join() for worker in workers]
-
-    # TODO: need to figure out cleanup handling here

redisbench_admin/run/ann/pkg/ann_benchmarks/plotting/__init__.py

@@ -1,2 +0,0 @@
-from __future__ import absolute_import
-from ann_benchmarks.plotting import *

redisbench_admin/run/ann/pkg/ann_benchmarks/plotting/metrics.py

@@ -1,183 +0,0 @@
-from __future__ import absolute_import
-import numpy as np
-
-
-def knn_threshold(data, count, epsilon):
-    return data[count - 1] + epsilon
-
-
-def epsilon_threshold(data, count, epsilon):
-    return data[count - 1] * (1 + epsilon)
-
-
-def get_recall_values(dataset_distances, run_distances, count, threshold,
-                      epsilon=1e-3):
-    recalls = np.zeros(len(run_distances))
-    for i in range(len(run_distances)):
-        t = threshold(dataset_distances[i], count, epsilon)
-        actual = 0
-        for d in run_distances[i][:count]:
-            if d <= t:
-                actual += 1
-        recalls[i] = actual
-    return (np.mean(recalls) / float(count),
-            np.std(recalls) / float(count),
-            recalls)
-
-
-def knn(dataset_distances, run_distances, count, metrics, epsilon=1e-3):
-    if 'knn' not in metrics:
-        print('Computing knn metrics')
-        knn_metrics = metrics.create_group('knn')
-        mean, std, recalls = get_recall_values(dataset_distances,
-                                               run_distances, count,
-                                               knn_threshold, epsilon)
-        knn_metrics.attrs['mean'] = mean
-        knn_metrics.attrs['std'] = std
-        knn_metrics['recalls'] = recalls
-    else:
-        print("Found cached result")
-    return metrics['knn']
-
-
-def epsilon(dataset_distances, run_distances, count, metrics, epsilon=0.01):
-    s = 'eps' + str(epsilon)
-    if s not in metrics:
-        print('Computing epsilon metrics')
-        epsilon_metrics = metrics.create_group(s)
-        mean, std, recalls = get_recall_values(dataset_distances,
-                                               run_distances, count,
-                                               epsilon_threshold, epsilon)
-        epsilon_metrics.attrs['mean'] = mean
-        epsilon_metrics.attrs['std'] = std
-        epsilon_metrics['recalls'] = recalls
-    else:
-        print("Found cached result")
-    return metrics[s]
-
-
-def rel(dataset_distances, run_distances, metrics):
-    if 'rel' not in metrics.attrs:
-        print('Computing rel metrics')
-        total_closest_distance = 0.0
-        total_candidate_distance = 0.0
-        for true_distances, found_distances in zip(dataset_distances,
-                                                   run_distances):
-            for rdist, cdist in zip(true_distances, found_distances):
-                total_closest_distance += rdist
-                total_candidate_distance += cdist
-        if total_closest_distance < 0.01:
-            metrics.attrs['rel'] = float("inf")
-        else:
-            metrics.attrs['rel'] = total_candidate_distance / \
-                total_closest_distance
-    else:
-        print("Found cached result")
-    return metrics.attrs['rel']
-
-
-def queries_per_second(queries, attrs):
-    return 1.0 / attrs["best_search_time"]
-
-def percentile_50(times):
-    return np.percentile(times, 50.0) * 1000.0
-
-def percentile_95(times):
-    return np.percentile(times, 95.0) * 1000.0
-
-def percentile_99(times):
-    return np.percentile(times, 99.0) * 1000.0
-
-def percentile_999(times):
-    return np.percentile(times, 99.9) * 1000.0
-
-def index_size(queries, attrs):
-    # TODO(erikbern): should replace this with peak memory usage or something
-    return attrs.get("index_size", 0)
-
-
-def build_time(queries, attrs):
-    return attrs["build_time"]
-
-
-def candidates(queries, attrs):
-    return attrs["candidates"]
-
-
-def dist_computations(queries, attrs):
-    return attrs.get("dist_comps", 0) / (attrs['run_count'] * len(queries))
-
-
-all_metrics = {
-    "k-nn": {
-        "description": "Recall",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: knn(true_distances, run_distances, run_attrs["count"], metrics).attrs['mean'],  # noqa
-        "worst": float("-inf"),
-        "lim": [0.0, 1.03]
-    },
-    "epsilon": {
-        "description": "Epsilon 0.01 Recall",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: epsilon(true_distances, run_distances, run_attrs["count"], metrics).attrs['mean'],  # noqa
-        "worst": float("-inf")
-    },
-    "largeepsilon": {
-        "description": "Epsilon 0.1 Recall",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: epsilon(true_distances, run_distances, run_attrs["count"], metrics, 0.1).attrs['mean'],  # noqa
-        "worst": float("-inf")
-    },
-    "rel": {
-        "description": "Relative Error",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: rel(true_distances, run_distances, metrics),  # noqa
-        "worst": float("inf")
-    },
-    "qps": {
-        "description": "Queries per second (1/s)",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: queries_per_second(true_distances, run_attrs),  # noqa
-        "worst": float("-inf")
-    },
-    "p50": {
-        "description": "Percentile 50 (millis)",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: percentile_50(times),  # noqa
-        "worst": float("inf")
-    },
-    "p95": {
-        "description": "Percentile 95 (millis)",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: percentile_95(times),  # noqa
-        "worst": float("inf")
-    },
-    "p99": {
-        "description": "Percentile 99 (millis)",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: percentile_99(times),  # noqa
-        "worst": float("inf")
-    },
-    "p999": {
-        "description": "Percentile 99.9 (millis)",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: percentile_999(times),  # noqa
-        "worst": float("inf")
-    },
-    "distcomps": {
-        "description": "Distance computations",
-        "function": lambda true_distances, run_distances,  metrics, times, run_attrs: dist_computations(true_distances, run_attrs), # noqa
-        "worst": float("inf")
-    },
-    "build": {
-        "description": "Build time (s)",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: build_time(true_distances, run_attrs), # noqa
-        "worst": float("inf")
-    },
-    "candidates": {
-        "description": "Candidates generated",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: candidates(true_distances, run_attrs), # noqa
-        "worst": float("inf")
-    },
-    "indexsize": {
-        "description": "Index size (kB)",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: index_size(true_distances, run_attrs),  # noqa
-        "worst": float("inf")
-    },
-    "queriessize": {
-        "description": "Index size (kB)/Queries per second (s)",
-        "function": lambda true_distances, run_distances, metrics, times, run_attrs: index_size(true_distances, run_attrs) / queries_per_second(true_distances, run_attrs), # noqa
-        "worst": float("inf")
-    }
-}

redisbench_admin/run/ann/pkg/ann_benchmarks/plotting/plot_variants.py

@@ -1,17 +0,0 @@
-from ann_benchmarks.plotting.metrics import all_metrics as metrics
-
-all_plot_variants = {
-    "recall/time": ("k-nn", "qps"),
-    "recall/buildtime": ("k-nn", "build"),
-    "recall/indexsize": ("k-nn", "indexsize"),
-    "recall/distcomps": ("k-nn", "distcomps"),
-    "rel/time": ("rel", "qps"),
-    "recall/candidates": ("k-nn", "candidates"),
-    "recall/qpssize": ("k-nn", "queriessize"),
-    "eps/time": ("epsilon", "qps"),
-    "largeeps/time": ("largeepsilon", "qps"),
-    "recall/p50": ("k-nn", "p50"),
-    "recall/p95": ("k-nn", "p95"),
-    "recall/p99": ("k-nn", "p99"),
-    "recall/p999": ("k-nn", "p999"),
-}

redisbench_admin/run/ann/pkg/ann_benchmarks/plotting/utils.py

@@ -1,165 +0,0 @@
-from __future__ import absolute_import
-
-import itertools
-import numpy
-from ann_benchmarks.plotting.metrics import all_metrics as metrics
-
-
-def get_or_create_metrics(run):
-    if 'metrics' not in run:
-        run.create_group('metrics')
-    return run['metrics']
-
-
-def create_pointset(data, xn, yn):
-    xm, ym = (metrics[xn], metrics[yn])
-    rev_y = -1 if ym["worst"] < 0 else 1
-    rev_x = -1 if xm["worst"] < 0 else 1
-    data.sort(key=lambda t: (rev_y * t[-1], rev_x * t[-2]))
-
-    axs, ays, als = [], [], []
-    # Generate Pareto frontier
-    xs, ys, ls = [], [], []
-    last_x = xm["worst"]
-    comparator = ((lambda xv, lx: xv > lx)
-                  if last_x < 0 else (lambda xv, lx: xv < lx))
-    for algo, algo_name, xv, yv in data:
-        if not xv or not yv:
-            continue
-        axs.append(xv)
-        ays.append(yv)
-        als.append(algo_name)
-        if comparator(xv, last_x):
-            last_x = xv
-            xs.append(xv)
-            ys.append(yv)
-            ls.append(algo_name)
-    return xs, ys, ls, axs, ays, als
-
-
-def compute_metrics(true_nn_distances, res, metric_1, metric_2,
-                    recompute=False):
-    all_results = {}
-    for i, (properties, run) in enumerate(res):
-        algo = properties['algo']
-        algo_name = properties['name']
-        # cache distances to avoid access to hdf5 file
-        run_distances = numpy.array(run['distances'])
-        # cache times to avoid access to hdf5 file
-        times = numpy.array(run['times'])
-        if recompute and 'metrics' in run:
-            del run['metrics']
-        metrics_cache = get_or_create_metrics(run)
-
-        metric_1_value = metrics[metric_1]['function'](
-            true_nn_distances,
-            run_distances, metrics_cache, times, properties)
-        metric_2_value = metrics[metric_2]['function'](
-            true_nn_distances,
-            run_distances, metrics_cache, times, properties)
-
-        print('%3d: %80s %12.3f %12.3f' %
-              (i, algo_name, metric_1_value, metric_2_value))
-
-        all_results.setdefault(algo, []).append(
-            (algo, algo_name, metric_1_value, metric_2_value))
-
-    return all_results
-
-
-def compute_all_metrics(true_nn_distances, run, properties, recompute=False):
-    algo = properties["algo"]
-    algo_name = properties["name"]
-    print('--')
-    print(algo_name)
-    results = {}
-    # cache distances to avoid access to hdf5 file
-    run_distances = numpy.array(run["distances"])
-    # cache times to avoid access to hdf5 file
-    times = numpy.array(run['times'])
-    if recompute and 'metrics' in run:
-        del run['metrics']
-    metrics_cache = get_or_create_metrics(run)
-
-    for name, metric in metrics.items():
-        v = metric["function"](
-            true_nn_distances, run_distances, metrics_cache, times, properties)
-        results[name] = v
-        if v:
-            print('%s: %g' % (name, v))
-    return (algo, algo_name, results)
-
-def compute_metrics_all_runs(dataset, res, recompute=False):
-    true_nn_distances=list(dataset['distances'])
-    for i, (properties, run) in enumerate(res):
-        algo = properties['algo']
-        algo_name = properties['name']
-        # cache distances to avoid access to hdf5 file
-        # print('Load distances and times')
-        run_distances = numpy.array(run['distances'])
-        times = numpy.array(run['times'])
-        # print('... done')
-        if recompute and 'metrics' in run:
-            print('Recomputing metrics, clearing cache')
-            del run['metrics']
-        metrics_cache = get_or_create_metrics(run)
-        
-        dataset = properties['dataset']
-
-        run_result = {
-            'algorithm': algo,
-            'parameters': algo_name,
-            'count': properties['count']
-        }
-        for name, metric in metrics.items():
-            v = metric["function"](true_nn_distances, run_distances, metrics_cache, times, properties)
-            run_result[name] = v
-        yield run_result
-
-
-def generate_n_colors(n):
-    vs = numpy.linspace(0.3, 0.9, 7)
-    colors = [(.9, .4, .4, 1.)]
-
-    def euclidean(a, b):
-        return sum((x - y)**2 for x, y in zip(a, b))
-    while len(colors) < n:
-        new_color = max(itertools.product(vs, vs, vs),
-                        key=lambda a: min(euclidean(a, b) for b in colors))
-        colors.append(new_color + (1.,))
-    return colors
-
-
-def create_linestyles(unique_algorithms):
-    colors = dict(
-        zip(unique_algorithms, generate_n_colors(len(unique_algorithms))))
-    linestyles = dict((algo, ['--', '-.', '-', ':'][i % 4])
-                      for i, algo in enumerate(unique_algorithms))
-    markerstyles = dict((algo, ['+', '<', 'o', '*', 'x'][i % 5])
-                        for i, algo in enumerate(unique_algorithms))
-    faded = dict((algo, (r, g, b, 0.3))
-                 for algo, (r, g, b, a) in colors.items())
-    return dict((algo, (colors[algo], faded[algo],
-                        linestyles[algo], markerstyles[algo]))
-                for algo in unique_algorithms)
-
-
-def get_up_down(metric):
-    if metric["worst"] == float("inf"):
-        return "down"
-    return "up"
-
-
-def get_left_right(metric):
-    if metric["worst"] == float("inf"):
-        return "left"
-    return "right"
-
-
-def get_plot_label(xm, ym):
-    template = ("%(xlabel)s-%(ylabel)s tradeoff - %(updown)s and"
-                " to the %(leftright)s is better")
-    return template % {"xlabel": xm["description"],
-                       "ylabel": ym["description"],
-                       "updown": get_up_down(ym),
-                       "leftright": get_left_right(xm)}