epiquire 0.1.0__tar.gz

epiquire-0.1.0/PKG-INFO

@@ -0,0 +1,200 @@
+Metadata-Version: 2.4
+Name: epiquire
+Version: 0.1.0
+Summary: Low-N, acquisition-driven, epistasis-aware protein mutation recommendation engine
+Author: gyuminlee-repo
+Keywords: directed-evolution,protein-engineering,active-learning,bayesian-optimization,epistasis,mutation-recommendation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: pandas
+Provides-Extra: plm
+Requires-Dist: torch; extra == "plm"
+Requires-Dist: esm; extra == "plm"
+Provides-Extra: plm2
+Requires-Dist: fair-esm; extra == "plm2"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# epiquire
+
+Low-N, acquisition-driven protein mutation recommendation. The spine is one measurement campaign:
+
+```text
+R0 seed to measure -> fit surrogate on all measured data -> acquire next plate -> measure -> repeat
+```
+
+`epiquire` is not a magic zero-shot "better protein" predictor. Zero-shot, MSA, inverse-folding,
+structure, and ddG signals are used as priors, constraints, or features. The function-aligned signal
+is still measurement. The tool's job is to spend a small measurement budget better.
+
+## Easiest entry point: `epiquire round`
+
+One command per round. It auto-resolves the active-site design region (the `resolve-site` evidence
+ladder: UniProt -> linked PDB cocrystal -> AlphaFold) and then runs the campaign round, so there is
+no position bookkeeping by hand.
+
+**Run it in your browser, no install:** open [`notebooks/epiquire_round_colab.ipynb`](https://colab.research.google.com/github/gyuminlee-repo/epiquire/blob/master/notebooks/epiquire_round_colab.ipynb)
+in Google Colab -- a form-driven front end over `epiquire round` (paste the WT sequence + an accession,
+optionally upload measured results, get the plate CSV). The core loop is numpy/scikit-learn (seconds);
+only the optional PLM path is heavy, and Colab's free GPU covers that.
+
+```bash
+# R0: no --measured -> the funclib seed plate to MEASURE (needs a signal: --msa / --ddg / --if-logprobs)
+epiquire round WT.fasta --uniprot Q50L36 --msa alignment.a3m --plate 95 --outdir outputs/round
+
+# Rk: add each round's measured results -> the next AL plate over the full saturation universe
+epiquire round WT.fasta --uniprot Q50L36 --measured round0_measured.csv --plate 95 --outdir outputs/round
+```
+
+Define the design region any one way: `--uniprot`/`--query`/`--pdb` (auto ladder), a local `--holo`
+structure, or explicit `--positions`. If the ladder cannot map evidence onto your WT it abstains
+(supply `--positions` or `--holo`) rather than guessing. `round` is a thin wrapper: `resolve-site`
+and `campaign` below remain the explicit, fully-configurable commands it calls.
+
+## The campaign engine (what `round` calls)
+
+Use `campaign` when starting an active-site campaign. It combines the two validated pieces:
+
+1. **R0 cold-start seed**: FuncLib-style active-site library construction. This proposes variants to
+   measure; it does not predict winners.
+2. **R1+ active learning**: after measurements arrive, the AL loop searches the full saturation space
+   of the design positions, not just the R0 seed.
+
+### R0: generate the seed plate
+
+```bash
+epiquire campaign WT.fasta \
+  --holo holo_structure.pdb --ligand-resnames LIG \
+  --msa alignment.a3m \
+  --plate 95 \
+  --outdir outputs/campaign
+```
+
+This writes `outputs/campaign/round0_plate.csv` with `variant,mutations,n_mut,seed_score`. Measure
+those variants and save a `variant,fitness` CSV.
+
+You can use explicit design positions instead of a holo structure:
+
+```bash
+epiquire campaign WT.fasta \
+  --positions 183,184,227,228 \
+  --msa alignment.a3m \
+  --plate 95 \
+  --outdir outputs/campaign
+```
+
+### R1+: propose the next plate from measured data
+
+```bash
+epiquire campaign WT.fasta \
+  --positions 183,184,227,228 \
+  --measured round0_measured.csv \
+  --plate 95 \
+  --outdir outputs/campaign
+```
+
+With multiple rounds, pass all accumulated CSVs:
+
+```bash
+epiquire campaign WT.fasta \
+  --positions 183,184,227,228 \
+  --measured round0_measured.csv round1_measured.csv \
+  --plate 95 \
+  --outdir outputs/campaign
+```
+
+### Simulate against a complete landscape
+
+For validation or retrospective benchmarks:
+
+```bash
+epiquire campaign WT.fasta \
+  --simulate data/trpb.csv \
+  --positions 183,184,227,228 \
+  --msa isps_run/msa_trpb.a3m \
+  --strategies funclib singles random \
+  --plate 95 --rounds 3 --seeds 20 --jobs 4 \
+  --model-class ridge \
+  --outdir artifacts/campaign_trpb
+```
+
+`--jobs` parallelizes independent seeds with spawn processes; serial output and parallel output are
+byte-identical by test.
+
+## Other commands
+
+- `epiquire recommend measured.csv`: rank next candidates from accumulated measurements. This is the
+  AL round engine exposed directly. If you pass `--if-logprobs`, epiquire CV-gates that signal by
+  default and uses it only if it improves held-out performance on this protein. Use
+  `--no-auto-signals` only as an expert override. `--recombine` also adds recombinations of your
+  MEASURED beneficials (variants beating WT) to the candidate pool -- the strategy the real-data
+  evidence supports (measure broadly, then recombine confirmed wins).
+- `epiquire resolve-site WT.fasta --uniprot ACC` (or `--query`): resolve active-site/binding positions
+  from UniProt experimental curation, sequence-aligned onto YOUR WT numbering (handles transit-peptide
+  / species offsets), with provenance + confidence per position. If UniProt features do not map it
+  falls back to a UniProt-linked PDB cocrystal (active-site shells); `--pdb ID` forces the structure
+  path. If neither maps, it fetches the AlphaFold model (predicted, apo). Optional `--apo-pocket`
+  (fpocket) guesses pocket positions but is LOW-confidence -- it missed the catalytic site on ispS,
+  so it is warned, not default. Abstains on positions rather than guessing -- then provide
+  `--holo`/`--positions`. Feed resolved positions to `campaign`.
+- `epiquire funclib WT.fasta ...`: build only the active-site R0 measurement library. Useful when you
+  want the seed plate without the campaign wrapper.
+- `epiquire advise measured.csv`: readiness check on measured data.
+- `epiquire bench`: synthetic alpha-spectrum benchmark.
+- `epiquire report`: summarize a JSON report.
+
+## What the opt-ins mean
+
+Most optional flags are not feature clutter. They are either:
+
+- **resources you must provide**: MSA, PDB, inverse-folding table, ddG table, PLM cache; or
+- **expert overrides** for known regimes.
+
+The default stays conservative because low-N model selection overfits. When epiquire can decide from
+this protein's measured data, it should decide itself: optional IF signals are now CV-gated by default;
+pairwise epistasis has its own data gate (`--auto-gate-pairwise`). See `docs/OPTIN_AUDIT.md`.
+
+## Honest scope
+
+Evidence so far supports these claims:
+
+- active-site FuncLib-style seeds enrich measurable libraries and improve low-budget discovery;
+- the global activity winner can be outside the seed, so AL must search beyond the seed;
+- stability/ddG signals are best used as constraints, while activity improvement is measurement-bound;
+- high-order activity epistasis makes zero-shot winner prediction unreliable.
+
+Evidence does **not** support: "epiquire predicts the best protein from sequence/structure alone." It
+increases the probability and efficiency of finding a better variant per measured plate, conditional on
+the design space and assay.
+
+## When NOT to use epiquire
+
+The focused active-site campaign helps only when the wins plausibly live in a region you can name
+and measure combinatorially. Do NOT reach for it when:
+
+- you do not know where beneficial mutations are (no mechanistic/structural prior on the target site);
+- the wins are likely distal/distributed across the protein (use a broad whole-protein single-mutant
+  scan instead -- that is a different tool class; epiquire's additive default cannot rank
+  whole-protein singles because one-hot has no cross-position transfer);
+- you cannot measure a focused combinatorial library (no assay throughput at the chosen site).
+
+Real-data caution (PtIspS, `artifacts/ispS_wetlab_validation.md`): a campaign run as a broad
+single-mutant scan with the active site barely sampled and the global winner distal is exactly the
+regime epiquire is NOT for. Pick broad-vs-focused from your biology; epiquire does not decide it.
+
+More detail: `ARCHITECTURE.md`, `artifacts/DECISION_EVIDENCE.md`, and the Obsidian decision log named
+there.

epiquire-0.1.0/README.md

@@ -0,0 +1,169 @@
+# epiquire
+
+Low-N, acquisition-driven protein mutation recommendation. The spine is one measurement campaign:
+
+```text
+R0 seed to measure -> fit surrogate on all measured data -> acquire next plate -> measure -> repeat
+```
+
+`epiquire` is not a magic zero-shot "better protein" predictor. Zero-shot, MSA, inverse-folding,
+structure, and ddG signals are used as priors, constraints, or features. The function-aligned signal
+is still measurement. The tool's job is to spend a small measurement budget better.
+
+## Easiest entry point: `epiquire round`
+
+One command per round. It auto-resolves the active-site design region (the `resolve-site` evidence
+ladder: UniProt -> linked PDB cocrystal -> AlphaFold) and then runs the campaign round, so there is
+no position bookkeeping by hand.
+
+**Run it in your browser, no install:** open [`notebooks/epiquire_round_colab.ipynb`](https://colab.research.google.com/github/gyuminlee-repo/epiquire/blob/master/notebooks/epiquire_round_colab.ipynb)
+in Google Colab -- a form-driven front end over `epiquire round` (paste the WT sequence + an accession,
+optionally upload measured results, get the plate CSV). The core loop is numpy/scikit-learn (seconds);
+only the optional PLM path is heavy, and Colab's free GPU covers that.
+
+```bash
+# R0: no --measured -> the funclib seed plate to MEASURE (needs a signal: --msa / --ddg / --if-logprobs)
+epiquire round WT.fasta --uniprot Q50L36 --msa alignment.a3m --plate 95 --outdir outputs/round
+
+# Rk: add each round's measured results -> the next AL plate over the full saturation universe
+epiquire round WT.fasta --uniprot Q50L36 --measured round0_measured.csv --plate 95 --outdir outputs/round
+```
+
+Define the design region any one way: `--uniprot`/`--query`/`--pdb` (auto ladder), a local `--holo`
+structure, or explicit `--positions`. If the ladder cannot map evidence onto your WT it abstains
+(supply `--positions` or `--holo`) rather than guessing. `round` is a thin wrapper: `resolve-site`
+and `campaign` below remain the explicit, fully-configurable commands it calls.
+
+## The campaign engine (what `round` calls)
+
+Use `campaign` when starting an active-site campaign. It combines the two validated pieces:
+
+1. **R0 cold-start seed**: FuncLib-style active-site library construction. This proposes variants to
+   measure; it does not predict winners.
+2. **R1+ active learning**: after measurements arrive, the AL loop searches the full saturation space
+   of the design positions, not just the R0 seed.
+
+### R0: generate the seed plate
+
+```bash
+epiquire campaign WT.fasta \
+  --holo holo_structure.pdb --ligand-resnames LIG \
+  --msa alignment.a3m \
+  --plate 95 \
+  --outdir outputs/campaign
+```
+
+This writes `outputs/campaign/round0_plate.csv` with `variant,mutations,n_mut,seed_score`. Measure
+those variants and save a `variant,fitness` CSV.
+
+You can use explicit design positions instead of a holo structure:
+
+```bash
+epiquire campaign WT.fasta \
+  --positions 183,184,227,228 \
+  --msa alignment.a3m \
+  --plate 95 \
+  --outdir outputs/campaign
+```
+
+### R1+: propose the next plate from measured data
+
+```bash
+epiquire campaign WT.fasta \
+  --positions 183,184,227,228 \
+  --measured round0_measured.csv \
+  --plate 95 \
+  --outdir outputs/campaign
+```
+
+With multiple rounds, pass all accumulated CSVs:
+
+```bash
+epiquire campaign WT.fasta \
+  --positions 183,184,227,228 \
+  --measured round0_measured.csv round1_measured.csv \
+  --plate 95 \
+  --outdir outputs/campaign
+```
+
+### Simulate against a complete landscape
+
+For validation or retrospective benchmarks:
+
+```bash
+epiquire campaign WT.fasta \
+  --simulate data/trpb.csv \
+  --positions 183,184,227,228 \
+  --msa isps_run/msa_trpb.a3m \
+  --strategies funclib singles random \
+  --plate 95 --rounds 3 --seeds 20 --jobs 4 \
+  --model-class ridge \
+  --outdir artifacts/campaign_trpb
+```
+
+`--jobs` parallelizes independent seeds with spawn processes; serial output and parallel output are
+byte-identical by test.
+
+## Other commands
+
+- `epiquire recommend measured.csv`: rank next candidates from accumulated measurements. This is the
+  AL round engine exposed directly. If you pass `--if-logprobs`, epiquire CV-gates that signal by
+  default and uses it only if it improves held-out performance on this protein. Use
+  `--no-auto-signals` only as an expert override. `--recombine` also adds recombinations of your
+  MEASURED beneficials (variants beating WT) to the candidate pool -- the strategy the real-data
+  evidence supports (measure broadly, then recombine confirmed wins).
+- `epiquire resolve-site WT.fasta --uniprot ACC` (or `--query`): resolve active-site/binding positions
+  from UniProt experimental curation, sequence-aligned onto YOUR WT numbering (handles transit-peptide
+  / species offsets), with provenance + confidence per position. If UniProt features do not map it
+  falls back to a UniProt-linked PDB cocrystal (active-site shells); `--pdb ID` forces the structure
+  path. If neither maps, it fetches the AlphaFold model (predicted, apo). Optional `--apo-pocket`
+  (fpocket) guesses pocket positions but is LOW-confidence -- it missed the catalytic site on ispS,
+  so it is warned, not default. Abstains on positions rather than guessing -- then provide
+  `--holo`/`--positions`. Feed resolved positions to `campaign`.
+- `epiquire funclib WT.fasta ...`: build only the active-site R0 measurement library. Useful when you
+  want the seed plate without the campaign wrapper.
+- `epiquire advise measured.csv`: readiness check on measured data.
+- `epiquire bench`: synthetic alpha-spectrum benchmark.
+- `epiquire report`: summarize a JSON report.
+
+## What the opt-ins mean
+
+Most optional flags are not feature clutter. They are either:
+
+- **resources you must provide**: MSA, PDB, inverse-folding table, ddG table, PLM cache; or
+- **expert overrides** for known regimes.
+
+The default stays conservative because low-N model selection overfits. When epiquire can decide from
+this protein's measured data, it should decide itself: optional IF signals are now CV-gated by default;
+pairwise epistasis has its own data gate (`--auto-gate-pairwise`). See `docs/OPTIN_AUDIT.md`.
+
+## Honest scope
+
+Evidence so far supports these claims:
+
+- active-site FuncLib-style seeds enrich measurable libraries and improve low-budget discovery;
+- the global activity winner can be outside the seed, so AL must search beyond the seed;
+- stability/ddG signals are best used as constraints, while activity improvement is measurement-bound;
+- high-order activity epistasis makes zero-shot winner prediction unreliable.
+
+Evidence does **not** support: "epiquire predicts the best protein from sequence/structure alone." It
+increases the probability and efficiency of finding a better variant per measured plate, conditional on
+the design space and assay.
+
+## When NOT to use epiquire
+
+The focused active-site campaign helps only when the wins plausibly live in a region you can name
+and measure combinatorially. Do NOT reach for it when:
+
+- you do not know where beneficial mutations are (no mechanistic/structural prior on the target site);
+- the wins are likely distal/distributed across the protein (use a broad whole-protein single-mutant
+  scan instead -- that is a different tool class; epiquire's additive default cannot rank
+  whole-protein singles because one-hot has no cross-position transfer);
+- you cannot measure a focused combinatorial library (no assay throughput at the chosen site).
+
+Real-data caution (PtIspS, `artifacts/ispS_wetlab_validation.md`): a campaign run as a broad
+single-mutant scan with the active site barely sampled and the global winner distal is exactly the
+regime epiquire is NOT for. Pick broad-vs-focused from your biology; epiquire does not decide it.
+
+More detail: `ARCHITECTURE.md`, `artifacts/DECISION_EVIDENCE.md`, and the Obsidian decision log named
+there.

epiquire-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "epiquire"
+version = "0.1.0"
+description = "Low-N, acquisition-driven, epistasis-aware protein mutation recommendation engine"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "gyuminlee-repo" }]
+keywords = [
+    "directed-evolution",
+    "protein-engineering",
+    "active-learning",
+    "bayesian-optimization",
+    "epistasis",
+    "mutation-recommendation",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "numpy",
+    "scipy",
+    "scikit-learn",
+    "pandas",
+]
+
+[project.optional-dependencies]
+plm = ["torch", "esm"]          # ESM-C (EvolutionaryScale) + on-demand embeddings
+plm2 = ["fair-esm"]             # ESM-2 (Meta) alternative provider
+dev = ["pytest", "pyright", "build", "twine"]
+
+[project.scripts]
+epiquire = "epiquire.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

epiquire-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

epiquire-0.1.0/src/epiquire/__init__.py

@@ -0,0 +1,18 @@
+"""epiquire: low-N, acquisition-driven, epistasis-aware mutation recommendation."""
+from __future__ import annotations
+
+__version__ = "0.0.1"
+
+from epiquire.funclib import (
+    FuncLibLibrary,
+    combine_tolerances,
+    design_library,
+    tolerance_from_logprob_table,
+)
+
+__all__ = [
+    "FuncLibLibrary",
+    "combine_tolerances",
+    "design_library",
+    "tolerance_from_logprob_table",
+]

epiquire-0.1.0/src/epiquire/acquisition.py

@@ -0,0 +1,135 @@
+"""Acquisition layer: the experimental-design lever (the tool's organizing axis).
+
+Score-based acquisitions (Greedy / UCB / MaxVariance) rank candidates by a scalar;
+``select`` returns the top-k. DiverseBatch wraps a score acquisition and applies
+KURO greedy-maximin so a batch is both high-value and spread out (no near-duplicate
+wells). All satisfy ``protocols.Acquisition`` and compose freely:
+
+    DiverseBatch(UCB(beta=1.0))          # diverse, uncertainty-aware exploitation
+    DiverseBatch(MaxVariance())          # diverse pure exploration (resolve uncertainty)
+    Greedy()                             # pure exploitation (the additive-greedy baseline)
+
+UCB / MaxVariance are only meaningful because the surrogate std is CALIBRATED (P1).
+"""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+
+import numpy as np
+
+from epiquire.design_space import DesignSpace, to_assignment
+from epiquire.types import Prediction
+
+
+class _ScoreAcquisition(ABC):
+    """Acquisitions that rank candidates by a per-candidate scalar score."""
+
+    @abstractmethod
+    def score(self, pred: Prediction) -> np.ndarray:
+        """Per-candidate acquisition value (higher = more desirable)."""
+
+    def select(
+        self,
+        pred: Prediction,
+        k: int,
+        *,
+        candidates: Sequence[str] | None = None,
+        space: DesignSpace | None = None,
+    ) -> list[int]:
+        s = self.score(pred)
+        if k <= 0 or s.size == 0:
+            return []
+        k = min(k, s.size)
+        return np.argsort(s)[::-1][:k].astype(int).tolist()
+
+
+class Greedy(_ScoreAcquisition):
+    """Pure exploitation: score = predicted mean (the additive-greedy lever)."""
+
+    def score(self, pred: Prediction) -> np.ndarray:
+        return np.asarray(pred.mean, dtype=float)
+
+
+class UCB(_ScoreAcquisition):
+    """Upper-confidence bound: score = mean + beta * calibrated std."""
+
+    def __init__(self, beta: float = 1.0) -> None:
+        self.beta = beta
+
+    def score(self, pred: Prediction) -> np.ndarray:
+        return np.asarray(pred.mean, dtype=float) + self.beta * np.asarray(pred.std, dtype=float)
+
+
+class MaxVariance(_ScoreAcquisition):
+    """Information-targeted (BALD-style) pure exploration: score = calibrated std.
+
+    Acquires where the model is most uncertain, i.e. where a measurement most reduces
+    predictive uncertainty. With calibrated std this is a principled exploration lever
+    (and the seed of resolving epistasis once interaction uncertainty is exposed).
+    """
+
+    def score(self, pred: Prediction) -> np.ndarray:
+        return np.asarray(pred.std, dtype=float)
+
+
+def _combo_vectors(candidates: Sequence[str], space: DesignSpace) -> list[tuple[str, ...]]:
+    """Per-position residue tuples for fast Hamming distance over the design space."""
+    out: list[tuple[str, ...]] = []
+    for v in candidates:
+        a = to_assignment(v, space)
+        out.append(tuple(a[p] for p in space.positions))
+    return out
+
+
+def _hamming(a: tuple[str, ...], b: tuple[str, ...]) -> int:
+    return sum(1 for x, y in zip(a, b, strict=True) if x != y)
+
+
+class DiverseBatch:
+    """KURO greedy-maximin diversity over a top-scored pool of a base acquisition.
+
+    Ranks all candidates by the base acquisition, keeps the top ``pool_factor * k``,
+    then greedily builds a batch that maximizes the minimum design-space (Hamming)
+    distance to the already-chosen set, seeded by the single best-scoring candidate.
+    The result is a high-value batch with no near-duplicate wells.
+    """
+
+    def __init__(self, base: _ScoreAcquisition, pool_factor: float = 4.0) -> None:
+        self.base = base
+        self.pool_factor = pool_factor
+
+    def select(
+        self,
+        pred: Prediction,
+        k: int,
+        *,
+        candidates: Sequence[str],
+        space: DesignSpace,
+    ) -> list[int]:
+        n = len(candidates)
+        if n == 0 or k <= 0:
+            return []
+        k = min(k, n)
+        scores = self.base.score(pred)
+        order = np.argsort(scores)[::-1]
+        pool_size = min(n, max(k, int(self.pool_factor * k)))
+        pool: list[int] = [int(j) for j in order[:pool_size]]
+        vecs = _combo_vectors([candidates[i] for i in pool], space)
+
+        chosen = [0]  # local index into pool; pool[0] is the highest base score
+        mind = [_hamming(vecs[j], vecs[0]) for j in range(len(pool))]
+        mind[0] = -1
+        while len(chosen) < k:
+            j = int(np.argmax(mind))  # max-min distance; ties -> lowest index = higher base score
+            if mind[j] < 0:  # pool exhausted of distinct points
+                break
+            chosen.append(j)
+            mind[j] = -1
+            vj = vecs[j]
+            for t in range(len(pool)):
+                if mind[t] >= 0:
+                    d = _hamming(vecs[t], vj)
+                    if d < mind[t]:
+                        mind[t] = d
+        return [pool[j] for j in chosen]