turfLP 0.2.0__py3-none-any.whl

turflp/__init__.py

@@ -0,0 +1,8 @@
+"""TURF analysis (total unduplicated reach and frequency) with integer linear
+programming. Python port of the turfLP R package; see docs/algorithm.md in
+https://github.com/aigorahub/turfLP for the specification."""
+
+from ._core import Portfolio, TurfWarning, turf, turf_min_cover, turf_sizes
+
+__all__ = ["Portfolio", "TurfWarning", "turf", "turf_min_cover", "turf_sizes"]
+__version__ = "0.2.0"

turflp/_core.py

@@ -0,0 +1,321 @@
+"""The turfLP algorithm. Mirrors R/turf.R; docs/algorithm.md is the spec.
+
+Section numbers in comments refer to docs/algorithm.md.
+"""
+
+import math
+import time
+import warnings
+from dataclasses import dataclass
+
+import numpy as np
+
+from . import _solver
+from ._input import as_reach_matrix, check_limits, check_size, check_tiebreak
+
+EPS = 2.0 ** -52
+MAX_SOLVES = 100
+DEFAULT_TIEBREAK = ("frequency", "penetration")
+
+
+class TurfWarning(UserWarning):
+    """A search stopped before it proved the full optimum (docs/algorithm.md section 10)."""
+
+
+@dataclass(frozen=True)
+class Portfolio:
+    """A selected portfolio. `products` are 0-based column indices, ascending."""
+    products: tuple
+    names: tuple
+    size: int
+    reach: int
+    reach_prop: float
+    frequency: int
+    penetration: float
+    respondents: int
+
+
+# Section 5: the comparison rule.
+def tolerance(value, size):
+    return 16 * size * EPS * max(1.0, abs(value))
+
+
+def signed_value(obj, selected):
+    return (1 if obj["direction"] == "min" else -1) * obj["value"](selected)
+
+
+def worse_on_earlier(objectives, selected, previous, size):
+    for obj in objectives:
+        new = signed_value(obj, selected)
+        old = signed_value(obj, previous)
+        if new > old + tolerance(old, size):
+            return True
+        if new < old - tolerance(old, size):
+            return False
+    return False
+
+
+def best_of(pool, objectives, size):
+    keep = list(range(len(pool)))
+    for obj in objectives:
+        v = [signed_value(obj, pool[i]) for i in keep]
+        lo = min(v)
+        keep = [i for i, x in zip(keep, v) if x <= lo + tolerance(lo, size)]
+    return pool[keep[0]]
+
+
+def _warn(text):
+    warnings.warn(text, TurfWarning, stacklevel=3)
+
+
+def _format_seconds(x):
+    # R formats the budget with %g.
+    return "%g" % x
+
+
+def _portfolio(reach, names, products):
+    products = sorted(int(p) for p in products)
+    r = reach[:, products].sum(axis=0) if products else np.zeros(0)
+    reached = int(np.any(reach[:, products] > 0, axis=1).sum()) if products else 0
+    k = len(products)
+    return Portfolio(
+        products=tuple(products),
+        names=tuple(names[p] for p in products),
+        size=k,
+        reach=reached,
+        reach_prop=reached / reach.shape[0],
+        frequency=int(r.sum()),
+        penetration=k / math.fsum(1.0 / x for x in r),
+        respondents=int(reach.shape[0]),
+    )
+
+
+def turf(reach, size, tiebreak=DEFAULT_TIEBREAK, *, names=None, max_pool=1000,
+         max_pool_seconds=30.0):
+    """Find the portfolio of `size` products with maximum reach.
+
+    Ties on reach are broken by the criteria in `tiebreak`, in order
+    ("frequency", "penetration", or an empty sequence for reach only).
+    Returns a Portfolio. Emits TurfWarning when a search stops early.
+    """
+    reach, names = as_reach_matrix(reach, names)
+    tiebreak = check_tiebreak(tiebreak)
+    check_limits(max_pool, max_pool_seconds)
+    return _turf(reach, names, size, tiebreak, max_pool, max_pool_seconds)
+
+
+def _turf(reach, names, size, tiebreak, max_pool, max_pool_seconds):
+    # Section 2: reduction.
+    prod_reach = reach.sum(axis=0)
+    cand = np.flatnonzero(prod_reach > 0)
+    size = check_size(size, len(cand))
+    a = reach[np.ix_(reach[:, cand].sum(axis=1) > 0, cand)]
+    n, m = a.shape
+    x_vars = np.arange(n, n + m)
+    n_vars = n + m + 1
+    cand_reach = prod_reach[cand]
+    pen_coef = cand_reach.max() / cand_reach
+
+    # Section 3: the model.
+    rows_i, cols_j = np.nonzero(a)
+    counts = np.bincount(rows_i, minlength=n)
+    start = np.zeros(n + 3, dtype=np.int32)
+    start[1:n + 1] = np.cumsum(counts + 1)
+    index = np.empty(int(start[n]), dtype=np.int32)
+    value = np.ones(int(start[n]))
+    # Respondent row i: z_i + sum_j a_ij x_j >= 1 (z_i first, then x_j in column order).
+    pos = start[:n].copy()
+    index[pos] = np.arange(n)
+    pos += 1
+    order = np.lexsort((cols_j, rows_i))
+    fill = np.repeat(pos, counts) + (np.arange(len(order)) - np.repeat(np.cumsum(counts) - counts, counts))
+    index[fill] = n + cols_j[order]
+    index = np.concatenate([index, x_vars, x_vars, [n_vars - 1]]).astype(np.int32)
+    value = np.concatenate([value, np.ones(m), -pen_coef, [1.0]])
+    start[n + 1] = start[n] + m
+    start[n + 2] = start[n + 1] + m + 1
+    lower = np.concatenate([np.ones(n), [size, 0.0]])
+    upper = np.concatenate([np.full(n, np.inf), [size, 0.0]])
+    model = _solver.Model(n_vars, (start, index, value, lower, upper))
+
+    def on_x(coef):
+        return x_vars, np.asarray(coef, dtype=np.float64)
+
+    # Symmetry rows for identical products.
+    keys = [tuple(np.flatnonzero(a[:, j])) for j in range(m)]
+    last_seen = {}
+    for j, key in enumerate(keys):
+        if key in last_seen:
+            model = model.add_row([n + last_seen[key], n + j], [1.0, -1.0], 0.0, math.inf)
+        last_seen[key] = j
+
+    # Section 4: criteria. `sel` is a boolean vector over the candidates.
+    def reach_value(sel):
+        return n - int(np.any(a[:, sel] > 0, axis=1).sum())
+
+    z_coef = np.concatenate([np.ones(n), np.zeros(m + 1)])
+    objectives = {
+        "reach": {"name": "reach", "direction": "min", "coef": z_coef,
+                  "row": (np.arange(n), np.ones(n)), "value": reach_value},
+        "frequency": {"name": "frequency", "direction": "max",
+                      "coef": np.concatenate([np.zeros(n), cand_reach, [0.0]]),
+                      "row": on_x(cand_reach),
+                      "value": lambda sel: int(cand_reach[sel].sum())},
+        "penetration": {"name": "penetration", "direction": "min",
+                        "coef": np.concatenate([np.zeros(n + m), [1.0]]),
+                        "row": (np.array([n_vars - 1]), np.array([1.0])),
+                        "value": lambda sel: math.fsum(pen_coef[sel])},
+    }
+
+    def add_bound(model, obj, rhs):
+        idx, val = obj["row"]
+        if obj["direction"] == "min":
+            return model.add_row(idx, val, -math.inf, rhs)
+        return model.add_row(idx, val, rhs, math.inf)
+
+    def exclude(model, sel):
+        return model.add_row(x_vars[sel], np.ones(int(sel.sum())), -math.inf, size - 1)
+
+    # Section 6: one stage with checks.
+    def next_valid(model, obj, earlier, previous, deadline=math.inf):
+        for _ in range(MAX_SOLVES):
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                return "time", None, model
+            sol = _solver.solve(obj["direction"], obj["coef"], model, x_vars, obj["name"],
+                                soft=previous is not None, time_limit=remaining)
+            if sol is None:
+                return "none", None, model
+            if isinstance(sol, str):
+                if sol == "time":
+                    return "time", None, model
+                if previous is None:
+                    raise RuntimeError("HiGHS returned an invalid solution in the %s stage."
+                                       % obj["name"])
+                return "invalid", None, model
+            x = sol[x_vars]
+            sel = x > 0.5
+            if (np.isnan(x).any() or int(sel.sum()) != size
+                    or np.any(np.abs(x - sel) > 1e-6)):
+                if previous is None:
+                    raise RuntimeError("HiGHS returned an invalid solution in the %s stage."
+                                       % obj["name"])
+                return "invalid", None, model
+            if previous is None or not worse_on_earlier(earlier, sel, previous, size):
+                return "ok", sel, model
+            model = exclude(model, sel)
+        return "limit", None, model
+
+    def reason(status):
+        return {"limit": "%d solves" % MAX_SOLVES,
+                "time": "time limit of %s seconds" % _format_seconds(max_pool_seconds),
+                "invalid": "HiGHS returned an invalid solution",
+                "none": "HiGHS found no valid portfolio",
+                "full": "more than %d portfolios are within the solver tolerance" % max_pool,
+                }[status]
+
+    def unfinished(stage, status, earlier_exact=True):
+        middle = ("the earlier criteria but" if earlier_exact else
+                  "penetration only to within the solver tolerance and")
+        _warn("The %s stage did not finish (%s). The portfolio is optimal on %s may not "
+              "be optimal on %s." % (stage, reason(status), middle, stage))
+
+    # Section 7: the stage loop.
+    stages = ["reach"] + list(tiebreak)
+    previous = None
+    selected = None
+    for s, stage in enumerate(stages):
+        obj = objectives[stage]
+        earlier = [objectives[t] for t in stages[:s]]
+        status, sel, new_model = next_valid(model, obj, earlier, previous)
+        if status != "ok":
+            unfinished(stage, status)
+            break
+        model = new_model
+        selected = sel
+
+        if stage == "penetration":
+            # Section 8: the penetration stage.
+            without_pool = model
+            bound = obj["value"](selected)
+            pool = [selected]
+            last = selected
+            model = add_bound(model, obj, bound)
+            pool_status = "full"
+            deadline = time.monotonic() + max_pool_seconds
+            for _ in range(max_pool):
+                model = exclude(model, last)
+                status, sel, model = next_valid(model, obj, earlier, previous, deadline)
+                if status != "ok":
+                    pool_status = "complete" if status == "none" else status
+                    break
+                last = sel
+                # Skip products that meet the bound only within the solver tolerance.
+                if obj["value"](last) <= bound + tolerance(bound, size):
+                    pool.append(last)
+
+            if pool_status == "complete":
+                selected = best_of(pool, [objectives[t] for t in stages[s:]], size)
+            else:
+                _warn("The search for the penetration optimum stopped (%s). The penetration "
+                      "is optimal only to within the solver tolerance (about 1e-9)."
+                      % reason(pool_status))
+                selected = best_of(pool, [obj], size)
+                if s + 1 < len(stages):
+                    later = objectives[stages[s + 1]]
+                    status, sel, _ = next_valid(
+                        add_bound(without_pool, obj, obj["value"](selected)),
+                        later, [objectives[t] for t in stages[:s + 1]], selected,
+                        time.monotonic() + max_pool_seconds)
+                    if status == "ok":
+                        selected = sel
+                    else:
+                        unfinished(stages[s + 1], status, earlier_exact=False)
+            break
+
+        previous = selected
+        if s + 1 < len(stages):
+            # Fix this criterion at the value the selected products give.
+            model = add_bound(model, obj, obj["value"](selected))
+
+    return _portfolio(reach, names, cand[selected])
+
+
+def turf_min_cover(reach, *, names=None):
+    """Find the smallest portfolio that reaches every reachable respondent."""
+    reach, names = as_reach_matrix(reach, names)
+    return _min_cover(reach, names)
+
+
+def _min_cover(reach, names):
+    cand = np.flatnonzero(reach.sum(axis=0) > 0)
+    if len(cand) == 0:
+        raise ValueError("No product reaches any respondent.")
+    a = reach[np.ix_(reach[:, cand].sum(axis=1) > 0, cand)]
+    n, m = a.shape
+    rows_i, cols_j = np.nonzero(a)
+    order = np.lexsort((cols_j, rows_i))
+    counts = np.bincount(rows_i, minlength=n)
+    start = np.concatenate([[0], np.cumsum(counts)]).astype(np.int32)
+    model = _solver.Model(m, (start, cols_j[order].astype(np.int32), np.ones(len(order)),
+                              np.ones(n), np.full(n, np.inf)))
+    sol = _solver.solve("min", np.ones(m), model, np.arange(m), "set cover")
+    sel = sol > 0.5
+    # Section 11: check the cover.
+    if not np.all(np.any(a[:, sel] > 0, axis=1)) or np.any(np.abs(sol - sel) > 1e-6):
+        raise RuntimeError("HiGHS returned an invalid solution in the set cover stage.")
+    return _portfolio(reach, names, cand[sel])
+
+
+def turf_sizes(reach, sizes=None, tiebreak=DEFAULT_TIEBREAK, *, names=None, max_pool=1000,
+               max_pool_seconds=30.0):
+    """Solve `turf` for each size and return a list of Portfolio values.
+
+    The default sizes are 1 to the size of the minimum cover.
+    """
+    reach, names = as_reach_matrix(reach, names)
+    tiebreak = check_tiebreak(tiebreak)
+    check_limits(max_pool, max_pool_seconds)
+    if sizes is None:
+        sizes = range(1, _min_cover(reach, names).size + 1)
+    return [_turf(reach, names, k, tiebreak, max_pool, max_pool_seconds) for k in sizes]

turflp/_input.py

@@ -0,0 +1,109 @@
+"""Input checks. Mirrors as_reach_matrix(), check_size(), and check_tiebreak()
+in R/turf.R; the error texts are those of docs/algorithm.md section 1."""
+
+import math
+import numbers
+
+import numpy as np
+
+CRITERIA = ("frequency", "penetration")
+
+
+def as_reach_matrix(reach, names=None):
+    """Return (float 0/1 matrix, list of product names)."""
+    columns = None
+    if hasattr(reach, "to_numpy") and hasattr(reach, "columns"):
+        columns = [str(c) for c in reach.columns]
+        reach = reach.to_numpy()
+    if isinstance(reach, np.ndarray):
+        arr = reach
+    elif isinstance(reach, (list, tuple)):
+        if not all(isinstance(row, (list, tuple, np.ndarray)) for row in reach):
+            raise TypeError("`reach` must be a numeric or logical matrix or data frame.")
+        widths = {len(row) for row in reach}
+        if len(widths) > 1:
+            raise ValueError("`reach` must be a numeric or logical matrix or data frame.")
+        arr = np.empty((len(reach), widths.pop() if widths else 0), dtype=object)
+        for i, row in enumerate(reach):
+            arr[i, :] = list(row)
+    else:
+        raise TypeError("`reach` must be a numeric or logical matrix or data frame.")
+
+    if arr.ndim != 2:
+        raise TypeError("`reach` must be a numeric or logical matrix or data frame.")
+    if arr.dtype.kind in "biuf":
+        pass
+    elif arr.dtype.kind == "O":
+        for v in arr.flat:
+            if v is None:
+                continue
+            if isinstance(v, (bool, np.bool_)) or (
+                    isinstance(v, numbers.Real) and not isinstance(v, str)):
+                continue
+            raise TypeError("`reach` must be a numeric or logical matrix or data frame.")
+    else:
+        raise TypeError("`reach` must be a numeric or logical matrix or data frame.")
+    if arr.shape[0] == 0 or arr.shape[1] == 0:
+        raise ValueError("`reach` must have at least one row and one column.")
+    if arr.dtype.kind == "O":
+        if any(v is None or (isinstance(v, float) and math.isnan(v)) for v in arr.flat):
+            raise ValueError("`reach` must not contain missing values.")
+        arr = arr.astype(np.float64)
+    elif arr.dtype.kind == "f" and np.isnan(arr).any():
+        raise ValueError("`reach` must not contain missing values.")
+    arr = arr.astype(np.float64)
+    if not np.all((arr == 0) | (arr == 1)):
+        raise ValueError("`reach` must contain only 0 and 1, or FALSE and TRUE.")
+
+    if names is not None:
+        names = [str(n) for n in names]
+        if len(names) != arr.shape[1]:
+            raise ValueError("`names` must have one name per column of `reach`.")
+    elif columns is not None:
+        names = columns
+    else:
+        names = ["P%d" % (j + 1) for j in range(arr.shape[1])]
+    return arr, names
+
+
+def check_size(size, max_size):
+    ok = (isinstance(size, numbers.Real) and not isinstance(size, (bool, np.bool_))
+          and math.isfinite(size) and size >= 1 and size == int(size))
+    if not ok:
+        raise ValueError("`size` must be a single whole number of 1 or more.")
+    size = int(size)
+    if size > max_size:
+        raise ValueError("`size` is %d, but only %d products reach at least one respondent."
+                         % (size, max_size))
+    return size
+
+
+def check_tiebreak(tiebreak):
+    if tiebreak is None:
+        return []
+    if isinstance(tiebreak, str):
+        tiebreak = [tiebreak]
+    try:
+        tiebreak = list(tiebreak)
+    except TypeError:
+        raise TypeError('`tiebreak` must contain only "frequency" and "penetration".') from None
+    out = []
+    for t in tiebreak:
+        if t not in CRITERIA:
+            raise ValueError('`tiebreak` must contain only "frequency" and "penetration".')
+        if t not in out:
+            out.append(t)
+    return out
+
+
+def check_limits(max_pool, max_pool_seconds):
+    """Check the limits of docs/algorithm.md section 14 before any solve."""
+    if (not isinstance(max_pool, numbers.Integral) or isinstance(max_pool, (bool, np.bool_))):
+        raise TypeError("`max_pool` must be a whole number of 0 or more.")
+    if max_pool < 0:
+        raise ValueError("`max_pool` must be a whole number of 0 or more.")
+    if (not isinstance(max_pool_seconds, numbers.Real)
+            or isinstance(max_pool_seconds, (bool, np.bool_))):
+        raise TypeError("`max_pool_seconds` must be a number of 0 or more (math.inf for no limit).")
+    if math.isnan(max_pool_seconds) or max_pool_seconds < 0:
+        raise ValueError("`max_pool_seconds` must be a number of 0 or more (math.inf for no limit).")

turflp/_solver.py

@@ -0,0 +1,126 @@
+"""HiGHS through highspy. Mirrors solve_lp() in R/turf.R with the settings of
+docs/algorithm.md section 13."""
+
+import math
+from dataclasses import dataclass
+
+import highspy
+import numpy as np
+
+
+@dataclass
+class Settings:
+    # Presolve is the one named difference from R (docs/algorithm.md section 13).
+    # Tests switch it off to run the conformance suite a second time.
+    presolve: str = "on"
+
+
+settings = Settings()
+# The options of the most recent solve, read back from HiGHS. Tests check them.
+last_options = {}
+
+OPTION_NAMES = ("presolve", "mip_rel_gap", "mip_abs_gap", "primal_feasibility_tolerance",
+                "mip_feasibility_tolerance", "threads", "time_limit")
+
+
+class Model:
+    """Rows of a linear model, stored so that adding a row copies nothing large.
+
+    `base` holds the rows built once per call (CSR arrays); `extra` holds the
+    rows added later (bounds and no-good cuts), as in the R model list.
+    """
+
+    def __init__(self, n_vars, base, extra=()):
+        self.n_vars = n_vars
+        self.base = base            # (start, index, value, lower, upper)
+        self.extra = tuple(extra)   # ((index, value, lower, upper), ...)
+
+    def add_row(self, index, value, lower, upper):
+        row = (np.asarray(index, dtype=np.int32), np.asarray(value, dtype=np.float64),
+               float(lower), float(upper))
+        return Model(self.n_vars, self.base, self.extra + (row,))
+
+    def csr(self):
+        start, index, value, lower, upper = self.base
+        if not self.extra:
+            return start, index, value, lower, upper
+        starts = [start[:-1]]
+        idx = [index]
+        val = [value]
+        pos = int(start[-1])
+        extra_starts = []
+        for i, v, _, _ in self.extra:
+            extra_starts.append(pos)
+            idx.append(i)
+            val.append(v)
+            pos += len(i)
+        starts.append(np.asarray(extra_starts + [pos], dtype=np.int32))
+        return (np.concatenate(starts), np.concatenate(idx), np.concatenate(val),
+                np.concatenate([lower, [r[2] for r in self.extra]]),
+                np.concatenate([upper, [r[3] for r in self.extra]]))
+
+
+def solve(direction, objective, model, binary, stage, soft=False, time_limit=math.inf):
+    """Solve one stage.
+
+    Returns the column values. With `soft`, an infeasible model gives None,
+    the time limit gives "time", and any other failure gives "invalid";
+    without `soft`, all of these raise RuntimeError.
+    """
+    n = model.n_vars
+    start, index, value, lower, upper = model.csr()
+    lp = highspy.HighsLp()
+    lp.num_col_ = n
+    lp.num_row_ = len(lower)
+    lp.col_cost_ = np.asarray(objective, dtype=np.float64)
+    col_lower = np.zeros(n)
+    col_upper = np.full(n, highspy.kHighsInf)
+    col_upper[binary] = 1.0
+    lp.col_lower_ = col_lower
+    lp.col_upper_ = col_upper
+    integrality = [highspy.HighsVarType.kContinuous] * n
+    for j in binary:
+        integrality[j] = highspy.HighsVarType.kInteger
+    lp.integrality_ = integrality
+    lp.row_lower_ = np.where(np.isinf(lower), -highspy.kHighsInf, lower)
+    lp.row_upper_ = np.where(np.isinf(upper), highspy.kHighsInf, upper)
+    lp.a_matrix_.format_ = highspy.MatrixFormat.kRowwise
+    lp.a_matrix_.num_col_ = n
+    lp.a_matrix_.num_row_ = len(lower)
+    lp.a_matrix_.start_ = start
+    lp.a_matrix_.index_ = index
+    lp.a_matrix_.value_ = value
+    lp.sense_ = highspy.ObjSense.kMaximize if direction == "max" else highspy.ObjSense.kMinimize
+
+    h = highspy.Highs()
+    h.setOptionValue("output_flag", False)
+    h.setOptionValue("presolve", settings.presolve)
+    h.setOptionValue("mip_rel_gap", 0.0)
+    h.setOptionValue("mip_abs_gap", 0.0)
+    h.setOptionValue("primal_feasibility_tolerance", 1e-9)
+    h.setOptionValue("mip_feasibility_tolerance", 1e-9)
+    h.setOptionValue("threads", 1)
+    if math.isfinite(time_limit):
+        h.setOptionValue("time_limit", float(time_limit))
+    h.passModel(lp)
+    h.run()
+    last_options.clear()
+    for name in OPTION_NAMES:
+        value = h.getOptionValue(name)
+        # highspy 1.15 returns (status, value).
+        last_options[name] = value[1] if isinstance(value, tuple) else value
+
+    status = h.getModelStatus()
+    if status == highspy.HighsModelStatus.kOptimal:
+        return np.asarray(h.getSolution().col_value, dtype=np.float64)
+    # No model here is unbounded, so HiGHS's "unbounded or infeasible" means infeasible.
+    infeasible = status in (highspy.HighsModelStatus.kInfeasible,
+                            highspy.HighsModelStatus.kUnboundedOrInfeasible)
+    if soft:
+        if infeasible:
+            return None
+        if status == highspy.HighsModelStatus.kTimeLimit:
+            return "time"
+        return "invalid"
+    raise RuntimeError("HiGHS did not find a solution in the %s stage (%s)."
+                       % (stage, h.modelStatusToString(status)))

turflp/datasets/__init__.py

@@ -0,0 +1,33 @@
+"""Example data sets, copied from the turfLP R package.
+
+The values are the raw responses. The R help pages suggest these reach
+thresholds: icecream >= 8, chips >= 4, ham >= 7, coffee >= 8; cafe, pies,
+and lunchbags are already 0/1. See COPYRIGHTS for sources and licenses.
+"""
+
+import csv
+from importlib import resources
+from typing import NamedTuple
+
+import numpy as np
+
+_NAMES = ("cafe", "chips", "coffee", "ham", "icecream", "lunchbags", "pies")
+
+
+class Dataset(NamedTuple):
+    columns: tuple
+    values: np.ndarray
+
+
+def names():
+    """The names of the seven data sets."""
+    return _NAMES
+
+
+def load(name):
+    """Load a data set as Dataset(columns, values)."""
+    if name not in _NAMES:
+        raise ValueError("Unknown data set %r. Use one of: %s." % (name, ", ".join(_NAMES)))
+    text = resources.files(__name__).joinpath(name + ".csv").read_text(encoding="utf-8")
+    rows = list(csv.reader(text.splitlines()))
+    return Dataset(tuple(rows[0]), np.array(rows[1:], dtype=np.int64))