<SYSTEM>This is the abridged developer documentation for PhenoMe</SYSTEM>

# Getting started

> Install PhenoMe and run a first analysis in four steps.

This page walks you from an empty environment to a first PCA plot of your own images.

## 1. Requirements

[Section titled “1. Requirements”](#1-requirements)

* **Python** 3.12 or newer.
* **Hardware**: any CPU works; an NVIDIA GPU is strongly recommended for speed. See [Best practices - performance](/PhenoMe/guides/best-practices/performance/) for sizing.
* **OS**: Linux, macOS, Windows.

## 2. Installation

[Section titled “2. Installation”](#2-installation)

Install the published package with pip.

```bash
pip install phenome
```

PyTorch and the Jupyter packages used by the notebooks are included. Pass `device` to speed up the computation using the GPU.

`phenome[full]` adds TorchDR and PyKeOps for large GPU analyses. Turn GPU dimensionality reduction on with `PhenoMe(..., use_gpu_for_dr=True)`. It does not move embeddings onto the GPU by itself:

```bash
pip install "phenome[full]"
```

Verify:

```bash
python3 -c '
import torch, phenome
print(f"PhenoMe {phenome.__version__} is ready!")
print("GPU:", torch.cuda.is_available(),
      f"({torch.cuda.get_device_name(0)})" if torch.cuda.is_available() else "(CPU-only mode)")
'
```

Regenerating the figures in the paper uses a separate environment. See [Paper reproducibility](/PhenoMe/paper-reproducibility/).

## 3. Run your first analysis

[Section titled “3. Run your first analysis”](#3-run-your-first-analysis)

The snippet below runs the full pipeline on a folder of images. You can run this in a **Python script** or a **Jupyter Notebook** cell.

1. **Set up and start**

   Load an AI vision model (DINOv2 by default) and create the pipeline.

   ```python
   import torch
   from phenome import PhenoMe, load_dinov2_model


   device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
   wrapper = load_dinov2_model(model_name="dinov2_vitb14_reg", device=device)
   pheno = PhenoMe(device=device)
   ```

2. **Find your images**

   A simple folder is fine. For grouped experiments (conditions, drugs, time points) add labels via [folder patterns or spreadsheets](/PhenoMe/guides/experiment-details/).

   ```python
   pheno.find_files("path/to/your/images")
   ```

3. **Extract embeddings (AI descriptions) and properties**

   ```python
   pheno.process_images(wrapper)
   pheno.compute_properties(property_preset="intensity")
   ```

4. **Visualize your results**

   ```python
   pheno.plot_pca()
   ```

   To color points, pass a key from `pheno.get_available_metadata_keys()`. For example, after a folder pattern or spreadsheet created `condition`, call `pheno.plot_pca(color_by="condition")`. Add `seed=42` to `PhenoMe` only when you want a reproducible run.

## What’s next?

[Section titled “What’s next?”](#whats-next)

Pick the card that matches your next goal. Each links to the most relevant guide, reference, or notebook - no duplicates of the quickstart above.

[Pick a learning path](/PhenoMe/user-paths/)Curated routes by audience: first day, own dataset, reporting, developer, interpretability.

[Preparing your data](/PhenoMe/guides/data-setup/)Organize folders, add labels via folder patterns or spreadsheets, and find masks.

[Common workflows](/PhenoMe/workflows/)Recipes for typical study designs: conditions, doses, time courses, plates.

[Understanding properties](/PhenoMe/concepts/property-interpretation/)Learn about the physical traits like size and shape that PhenoMe measures.

[Reproducibility & performance](/PhenoMe/guides/best-practices/)Seeds, device selection, batching, and best practices for reliable runs.

# Common workflows

> Simple overview of what you can do with PhenoMe, with links to the best tutorial for each task.

Full code for each workflow lives in the Jupyter notebooks under [`Notebooks/tutorials/`](https://github.com/PhenoMe-Ecosystem/PhenoMe/tree/main/Notebooks/tutorials). This page keeps only a short summary and pointers.

## 1. Basic analysis

[Section titled “1. Basic analysis”](#1-basic-analysis)

The standard end-to-end workflow - from loading images and extracting visual fingerprints (AI descriptions) to comparing images and generating reports - is covered in the core tutorial.

* **Tutorial:** [03 - Core phenotyping workflow](https://github.com/PhenoMe-Ecosystem/PhenoMe/blob/main/Notebooks/tutorials/03_core_phenotyping_workflow.ipynb)

## 2. Drug screening and time-course

[Section titled “2. Drug screening and time-course”](#2-drug-screening-and-time-course)

Analyzing the effects of different drug treatments or mapping changes over time requires using experimental info (metadata). Whether your data is organized hierarchically (`.../(drug)/(concentration)/(filename).*`) or encoded in filenames (`Treated_24h`), you can handle it through the metadata pipeline.

* **Guide:** [Adding experiment info (metadata)](/PhenoMe/guides/experiment-details/)

## 3. Property-based analysis and explaining results

[Section titled “3. Property-based analysis and explaining results”](#3-property-based-analysis-and-explaining-results)

To connect abstract AI patterns to real biology, compute classical physical properties (like area, brightness, and texture) and link them to your visual fingerprints.

* **Tutorial:** [04 - Exploratory analysis and explainability](https://github.com/PhenoMe-Ecosystem/PhenoMe/blob/main/Notebooks/tutorials/04_exploratory_analysis_and_explainability.ipynb)
* **Guide:** [Understanding properties](/PhenoMe/concepts/property-interpretation/), [Explaining AI results](/PhenoMe/concepts/embeddings-interpretability/)

## 4. Finding groups and outliers

[Section titled “4. Finding groups and outliers”](#4-finding-groups-and-outliers)

Discover hidden groups of images (clusters) within a single condition or find unusual cells (outliers) using clustering and similarity checks.

* **Tutorial:** [04 - Exploratory analysis and explainability](https://github.com/PhenoMe-Ecosystem/PhenoMe/blob/main/Notebooks/tutorials/04_exploratory_analysis_and_explainability.ipynb)

## 5. Temporal images (testing new data quickly)

[Section titled “5. Temporal images (testing new data quickly)”](#5-temporal-images-testing-new-data-quickly)

To see how **new** images fit into your existing pattern visualizations (PCA/t-SNE) without starting over, use temporal processing.

```python
pheno.process_temporal_images(
    wrapper,
    files=["new_data/test1.tif", "new_data/test2.tif"],
)


pheno.plot_pca(color_by="condition", hover_features=["source"])


pheno.clear_temporal_data()
```

## 6. Batch processing large datasets

[Section titled “6. Batch processing large datasets”](#6-batch-processing-large-datasets)

For very large datasets, discover files first, then checkpoint during extraction so results are saved as they are calculated.

```python
pheno.find_files("path/to/your/images")
pheno.process_images(
    wrapper,
    checkpoint_path="results/my_large_dataset.h5",
    batch_size=128,
)
```

## 7. Plate / Batch correction

[Section titled “7. Plate / Batch correction”](#7-plate--batch-correction)

If your data comes from multiple plates or batches, you can correct for technical variation (plate effects) using control wells.

```python
# Correct embeddings using 'Control' wells in each 'Plate'
pheno.correct_batches(
    batch_metadata_key="Plate",
    control_filters={"condition": "Control"},
    method="sphering",  # or "zscore"
    source="embeddings", # or "properties"
)
```

See [Best practices - performance](/PhenoMe/guides/best-practices/performance/) for memory sizing.

## See also

[Section titled “See also”](#see-also)

| Topic                                           | Where                                                                                                                           |
| ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| Installation and quick start                    | [Getting started](/PhenoMe/getting-started/)                                                                                    |
| Figures in the paper                            | [Paper reproducibility](/PhenoMe/paper-reproducibility/)                                                                        |
| Folder structure and metadata                   | [Preparing your data](/PhenoMe/guides/data-setup/), [Adding experiment info](/PhenoMe/guides/experiment-details/)               |
| Visual fingerprints, channel modes, and results | [Core concepts](/PhenoMe/concepts/)                                                                                             |
| Full API reference                              | [API & data formats](/PhenoMe/advanced/), [Pipeline API](/PhenoMe/advanced/api/pipeline/)                                       |
| Property sets and custom functions              | [Select properties](/PhenoMe/guides/select-properties/), [Understanding properties](/PhenoMe/concepts/property-interpretation/) |
| Reproducibility and optimization                | [Best practices](/PhenoMe/guides/best-practices/)                                                                               |

# FAQ

> Grouped answers to the most common PhenoMe questions - install, data, compute, results, and extension.

Common questions grouped by topic.

***

## Installation and setup

[Section titled “Installation and setup”](#installation-and-setup)

### Do I need to train a model?

[Section titled “Do I need to train a model?”](#do-i-need-to-train-a-model)

No. PhenoMe is **zero-shot**: it uses pre-trained AI models like DINOv2 out-of-the-box. You point the pipeline at your images and run. No training, fine-tuning, or manual annotation is required.

### Do I need a GPU?

[Section titled “Do I need a GPU?”](#do-i-need-a-gpu)

A GPU is **strongly recommended** for reasonable speed. The pipeline works on CPU, but processing thousands of images will be slow. For small datasets (hundreds of images), CPU is feasible. See [Best practices - performance](/PhenoMe/guides/best-practices/performance/).

### `pip` failed or PyTorch is wrong - what should I try?

[Section titled “pip failed or PyTorch is wrong - what should I try?”](#pip-failed-or-pytorch-is-wrong---what-should-i-try)

1. Install with pip, as in [Getting started - installation](/PhenoMe/getting-started/#2-installation): `pip install phenome`.
2. For GPU, ensure your driver matches the CUDA wheel you install; see [PyTorch get started](https://pytorch.org/get-started/locally/).
3. If `pykeops` fails on your OS, omit it and use the default backends (see [Best practices - performance](/PhenoMe/guides/best-practices/performance/)).
4. To regenerate the figures in the paper, use the locked environment instead of this install. See [Paper reproducibility](/PhenoMe/paper-reproducibility/).

### I get a `[KeOps] Warning : CUDA libraries not found or could not be loaded; Switching to CPU only` error, what should I do?

[Section titled “I get a \[KeOps\] Warning : CUDA libraries not found or could not be loaded; Switching to CPU only error, what should I do?”](#i-get-a-keops-warning--cuda-libraries-not-found-or-could-not-be-loaded-switching-to-cpu-only-error-what-should-i-do)

This happens if `pykeops` is installed but cannot find your system’s CUDA toolkit or compiler. In most cases, you can ignore this: PhenoMe will automatically fall back to standard PyTorch or Scikit-Learn backends for visualizing patterns (using PCA, t-SNE, or UMAP), which is fast enough for most datasets.

If you are working with very large datasets (e.g., >100,000 images) and need the memory efficiency of KeOps, ensure you have a functional C++ compiler and that your `CUDA_HOME` environment variable is set. For standard usage, you can safely ignore the warning or simply uninstall `pykeops`.

If you have a working CUDA setup but still see the error, try clearing the cache:

```python
import pykeops
pykeops.clean_pykeops()
```

### How do I verify the install?

[Section titled “How do I verify the install?”](#how-do-i-verify-the-install)

See the verification steps in [Getting started — Installation](/PhenoMe/getting-started/#2-installation).

### Do I need masks?

[Section titled “Do I need masks?”](#do-i-need-masks)

* **For embeddings**: No. These are extracted directly from images.
* **For classical properties**: Depends on the preset. The `intensity` preset works on images only (no masks). Presets like `basic`, `shape`, `standard`, and `complete` require masks for shape-based features (see [Select properties — Presets](/PhenoMe/guides/select-properties/presets/)). See [Understanding properties](/PhenoMe/concepts/property-interpretation/).

### How long does processing take?

[Section titled “How long does processing take?”](#how-long-does-processing-take)

Rough order of magnitude (GPU, ViT-B/14, batch\_size=32):

* \~1–5 seconds per 100 images (embedding extraction)
* PCA/t-SNE/UMAP: seconds to minutes depending on sample count
* For tens of thousands of images, expect minutes to hours; use checkpointing to resume if interrupted.

***

## Data and metadata

[Section titled “Data and metadata”](#data-and-metadata)

### What folder structure should I use?

[Section titled “What folder structure should I use?”](#what-folder-structure-should-i-use)

The pipeline is flexible:

* **Flat**: All images in one folder. Use `pheno.find_files("path/to/images")`.
* **By condition**: `data/Control/img1.tif`, `data/Drug1/img1.tif`. Use a **path template** (`get_metadata_from_path`) or custom `metadata_fn`.

See [Preparing your data](/PhenoMe/guides/data-setup/) and [Adding experiment info](/PhenoMe/guides/experiment-details/).

### I use a CSV for metadata—why don’t my CSV row count and `file_df` row count match?

[Section titled “I use a CSV for metadata—why don’t my CSV row count and file\_df row count match?”](#i-use-a-csv-for-metadatawhy-dont-my-csv-row-count-and-file_df-row-count-match)

`find_files` first scans your images folder, then matches those images to your CSV. **Only the overlap is used:** image files must exist in **both** the folder and the CSV to be processed. Extra rows in your CSV are ignored, and images without a CSV row are skipped by default. See [Adding experiment info — Using a spreadsheet](/PhenoMe/guides/experiment-details/csv-lookup/).

### My filter returns no images. Why?

[Section titled “My filter returns no images. Why?”](#my-filter-returns-no-images-why)

Check that:

1. The metadata keys exist (`pheno.get_available_metadata_keys()`).
2. The filter values match your data exactly (case-sensitive).
3. The column values are as expected (`df['condition'].unique()`).

See [Best practices - data organization](/PhenoMe/guides/best-practices/data-organization/).

***

## Analysis and compute

[Section titled “Analysis and compute”](#analysis-and-compute)

### I get “CUDA out of memory.” What do I do?

[Section titled “I get “CUDA out of memory.” What do I do?”](#i-get-cuda-out-of-memory-what-do-i-do)

1. Reduce `batch_size` (e.g., from 32 to 16 or 8).
2. Use a smaller model (e.g., ViT-S instead of ViT-g).
3. Clear GPU memory between runs: `gc.collect(); torch.cuda.empty_cache()`.

See [Best practices - performance](/PhenoMe/guides/best-practices/performance/#gpu-out-of-memory).

### Processing is very slow. How can I speed it up?

[Section titled “Processing is very slow. How can I speed it up?”](#processing-is-very-slow-how-can-i-speed-it-up)

1. Ensure you are using a GPU (`wrapper.device` should show `cuda:X`).
2. Increase `batch_size` if GPU memory allows.
3. Increase `num_workers` for data loading.
4. Use the `intensity` preset instead of `complete` if you do not need all properties.

### Results differ between runs. Why?

[Section titled “Results differ between runs. Why?”](#results-differ-between-runs-why)

t-SNE and UMAP have random elements (they are stochastic). For reproducibility, set `seed=42` when creating the pipeline: `PhenoMe(seed=42)`. Also use `use_gpu_for_dr=False` if you need exact match with CPU sklearn/umap-learn. For large datasets on GPU, install `pykeops` to avoid OOM. See [Best practices - reproducibility](/PhenoMe/guides/best-practices/reproducibility/) and [Best practices - performance](/PhenoMe/guides/best-practices/performance/).

***

## Results and interpretation

[Section titled “Results and interpretation”](#results-and-interpretation)

### What is the “correlation engine” (linking AI to biology) and how do I use it?

[Section titled “What is the “correlation engine” (linking AI to biology) and how do I use it?”](#what-is-the-correlation-engine-linking-ai-to-biology-and-how-do-i-use-it)

The correlation engine links the abstract AI descriptions to classical physical properties (like size or shape). It answers: “What physical trait does this AI pattern represent?” For example, a certain axis might represent how elongated a cell is. See [Explaining AI results](/PhenoMe/concepts/embeddings-interpretability/).

### How do I choose channel mode (split vs combined)?

[Section titled “How do I choose channel mode (split vs combined)?”](#how-do-i-choose-channel-mode-split-vs-combined)

* **Split**: Fluorescence images with distinct channels (DAPI, GFP, etc.). Each channel is processed separately.
* **Combined**: Brightfield, phase contrast, or RGB images. Channels are treated as a single color image.

See [Core concepts — channel modes](/PhenoMe/concepts/channel-modes/).

### Which property preset should I use?

[Section titled “Which property preset should I use?”](#which-property-preset-should-i-use)

| You have…                                         | Use preset  |
| ------------------------------------------------- | ----------- |
| No masks                                          | `intensity` |
| Masks, lightweight stats                          | `basic`     |
| Masks, shape only                                 | `shape`     |
| Masks, rings + axis lengths (recommended default) | `standard`  |
| Masks, texture + QC + extended shape              | `complete`  |

See [Select properties — Presets](/PhenoMe/guides/select-properties/presets/) and [Understanding properties — choosing properties](/PhenoMe/concepts/property-interpretation/#choosing-properties).

***

## Extending PhenoMe

[Section titled “Extending PhenoMe”](#extending-phenome)

### What is the relationship between PhenoMe and the `phenome` package?

[Section titled “What is the relationship between PhenoMe and the phenome package?”](#what-is-the-relationship-between-phenome-and-the-phenome-package)

**PhenoMe** is the project name. The installable Python package is **`phenome`** (`pip install phenome`; `import phenome`).

### Where do I add custom models, properties, or plugins?

[Section titled “Where do I add custom models, properties, or plugins?”](#where-do-i-add-custom-models-properties-or-plugins)

See [Extending PhenoMe](/PhenoMe/guides/extending/), [Select properties](/PhenoMe/guides/select-properties/), [Plugins](/PhenoMe/guides/plugins/), and notebook [05 - Extending](https://github.com/PhenoMe-Ecosystem/PhenoMe/blob/main/Notebooks/tutorials/05_extending_phenome_plugins.ipynb).

# Using PhenoMe with LLMs

> Short constraints for a PhenoMe notebook or script. The user guides are the source for the workflow.

This page is for scientists using PhenoMe. Most are not programmers, so a notebook or a script should stay easy to read and follow. The workflow is in [Getting started](/PhenoMe/getting-started/) and [Common workflows](/PhenoMe/workflows/). People who change PhenoMe itself follow the repository `AGENTS.md`.

A developer assistant builds that scientist’s analysis tool with `from phenome import PhenoMe, load_dinov2_model`. An analysis assistant runs the dataset and either saves the run or summarizes it.

Generated from the same docs build:

* [llms-small.txt](https://phenome-ecosystem.github.io/PhenoMe/llms-small.txt) — getting started, workflows, folder patterns, FAQ, this page, and MCP
* [llms-full.txt](https://phenome-ecosystem.github.io/PhenoMe/llms-full.txt) — the whole site, including the API reference
* [phenome-api.json](https://phenome-ecosystem.github.io/PhenoMe/phenome-api.json) — public methods and signatures

Look up a name in `phenome-api.json` or the [function location guide](/PhenoMe/function-location-guide/). Do not invent a method, preset, metadata key, or parameter.

## Constraints

[Section titled “Constraints”](#constraints)

* Import `from phenome import PhenoMe, load_dinov2_model`. Pass `device` into both. Add also a `seed` to keep it reproducible by default.
* Order: `find_files`, with metadata from `get_metadata_from_path` (a path template) or `make_dataframe_metadata_fn` (a table) → read the file table, `plot_image_by_index`, and `inspect_data` → `process_images`, or load an existing run → `compute_properties` when classical measurements are needed → `plot_pca`, `plot_tsne`, or `plot_umap`. Those plots compute the projection themselves. `correct_batches` only when plate or batch labels and controls are present. Multi-channel images set `channel_mode` to `split` or `combined`.
* One checkpoint file uses `load_results`. Separate embedding and property files use `load_embeddings`, then `load_properties`. New images on an existing projection use `process_temporal_images`. Those rows stay in memory; plot or export them, then call `clear_temporal_data`.
* Do not change logging, plot format, or report sections unless asked. `save_results` writes HDF5 only.
* For a handoff, call `save_results`. Add `export_experiment_config`, `export_methods_markdown`, or `generate_report(..., include_run_settings=True)` only for the files the user should receive.
* For a summary, keep tables and `return_fig=True` figures in variables and read `get_run_settings()` or `print_processing_pipeline()`.
* After each step, read the printed text and any variable you kept. Before `process_images`, the file count, metadata keys, and the sample image have to match the dataset. Read height and width from `inspect_data`. If the default 224-pixel square would compress the content too far or stretch a non-square image, set `resize_size` and `pad_size`. An int is a square side. A pair `(height, width)` keeps a rectangular frame.
* Call `get_available_metadata_keys()` before `color_by`, filters, or `batch_metadata_key`, and `get_available_property_keys()` before naming a property.
* Folder patterns use `(name)` groups, as in [Using folder names](/PhenoMe/guides/experiment-details/path-templates/). Brace placeholders do not match.
* Preset names are `none`, `intensity`, `shape`, `basic`, `standard`, and `complete`. `intensity` does not need masks. See [Presets](/PhenoMe/guides/select-properties/presets/).
* The usual analysis is a notebook, so the user can see the plot and open `create_interactive_explorer` (`create_colab_interactive_explorer` in Colab). A `.py` script is fine when the user asked for one, or when a notebook is not available.
* Run only the comparison the question asks for. A treatment against a reference uses `compute_reference_distances`, `property_stats_by_group`, and `top_properties_different_from_reference`. Counts per group use `plot_counts`. Groups and unusual images use `compute_clustering`, `analyze_group_enrichment`, `find_prototypes`, and `detect_outliers`. A time course of group centers uses `plot_centroids`.
* Linking embeddings to measurements uses `compute_component_correlation` for one projection, `compute_embedding_property_correlations` and `summarize_embedding_property_correlations` for embedding dimensions, and `compute_multivariate_interpretability` for a joint fit.
* A custom property uses `register_property` from `phenome.plugins`. A model other than DINOv2 subclasses `ModelWrapper` from `phenome.utils` and implements `_get_embeddings`. Changes to images before that model are `preprocessing_fn` and `custom_transformations` on `process_images`.

For Cursor or Claude Desktop, see [MCP for PhenoMe](/PhenoMe/guides/mcp/).

# MCP for PhenoMe

> Optional Model Context Protocol server so assistants can search docs, fetch recipes, inspect a folder, and format exported run settings.

The MCP server is **optional**. It helps a scientist use PhenoMe: build an analysis tool on the public API, or run an analysis and either save it or summarize it. It does not modify PhenoMe, does not change defaults, and does not run embedding extraction.

The server is a helper layer, not a second API. For a symbol, use [`phenome-api.json`](https://phenome-ecosystem.github.io/PhenoMe/phenome-api.json), the [function location guide](/PhenoMe/function-location-guide/), or [`llms-full.txt`](https://phenome-ecosystem.github.io/PhenoMe/llms-full.txt). [`llms-small.txt`](https://phenome-ecosystem.github.io/PhenoMe/llms-small.txt) is the short usage guide. Do not invent methods from a partial search hit.

## Install

[Section titled “Install”](#install)

```bash
pip install "phenome[mcp]"
```

From a clone (editable):

```bash
pip install -e ".[mcp]"
```

Then run:

```bash
phenome-mcp
```

## Cursor example

[Section titled “Cursor example”](#cursor-example)

In MCP settings, point stdio at the `phenome-mcp` executable from the same environment where PhenoMe is installed:

```json
{
  "mcpServers": {
    "phenome": {
      "command": "phenome-mcp"
    }
  }
}
```

## Tools

[Section titled “Tools”](#tools)

* **search\_docs** — keyword search. A checkout is searched first, then bundled recipes, then the published [llms-small.txt](https://phenome-ecosystem.github.io/PhenoMe/llms-small.txt). Each hit names its source.
* **get\_recipe** — one snippet: `first-analysis`, `export-settings`, `summarize`, `path-metadata`, `property-presets`, `batch-correction`, or `checkpoint`. `get_recipe("list")` lists them. An unknown name is an error. `export-settings` saves the HDF5 file and only the extra files the user asked to keep. `summarize` keeps the plot and the run text in memory.
* **list\_public\_api** — top-level imports and `PhenoMe` methods.
* **inspect\_dataset** — `find_files` and `inspect_data` on a folder. No model and no embeddings.
* **format\_run\_settings** — pretty-print a top-level JSON object, usually the file from `export_experiment_config`. A missing file, unreadable file, or non-object JSON is an error.
* **get\_api\_symbol** — one exact name. A `PhenoMe` method returns its purpose, signature, and a documentation link. Another public import returns its name, import path, and a link to the API overview.
* **troubleshoot** — match an error or question against a small set of known causes (masks, metadata keys, processing order, checkpoint order).
* **validate\_analysis\_code** — static check only. It flags call names that start with `find_`, `process_`, `compute_`, `plot_`, `save_`, or `load_` when they are not public `PhenoMe` methods or top-level imports. It flags `process_images` or `load_results` before `find_files`. A `{name}` path template is a warning. It does not check keyword arguments or presets.
* **get\_version\_info** — package version, the `llms-small.txt` / `llms-full.txt` URLs, and the two assistant roles: build the analysis tool, or run the analysis and save or summarize it.

The same method list is published at [`phenome-api.json`](https://phenome-ecosystem.github.io/PhenoMe/phenome-api.json).

Pass a `seed` into `PhenoMe` so the run is reproducible. Pass other extra parameters (`include_run_settings`, log level, plot kwargs) only when the user asked. See [Using with LLMs](/PhenoMe/guides/using-with-llms/).

# Paper reproducibility

> Conda environments for regenerating the analyses in the paper. Separate from the pip install.

The everyday install is [`pip install phenome`](/PhenoMe/getting-started/#2-installation). The analyses in the paper were run with Python 3.12 and PyTorch 2.12, and with `PhenoMe(seed=42)`. Those versions are pinned in the conda environments below, not by the pip install.

GPU, which is the setup used for those analyses:

```bash
git clone https://github.com/PhenoMe-Ecosystem/PhenoMe.git
cd PhenoMe
conda env create -f envs/environment-gpu.yml
conda activate phenome-gpu
```

The same PyTorch pin on CPU:

```bash
conda env create -f envs/environment-cpu.yml
conda activate phenome-cpu
```

The notebooks that regenerate the main analyses are in `Notebooks/examples/`: BBBC021, BBBC014, the Human Protein Atlas, the *E. coli* antibiotic time course, CellCognition, and STED-FM on synaptic proteins. Each one calls `PhenoMe(device=device, seed=42)`. The STED-FM notebook also needs the [STED-FM](https://github.com/FLClab/STED-FM) package, which is not part of the PhenoMe install. The install commands and the dataset scripts are in that notebook and in `Notebooks/examples/sted_fm_utils/`.