semvec/pypi-packages huggingface dataset:
wellmap 3.5.2
File format for 96-well plate layouts.
Requires Python: ~=3.7

***************************************************
``wellmap`` — File format for 96-well plate layouts
***************************************************

.. image:: https://img.shields.io/pypi/v/wellmap.svg
   :target: https://pypi.python.org/pypi/wellmap

.. image:: https://img.shields.io/pypi/pyversions/wellmap.svg
   :target: https://pypi.python.org/pypi/wellmap

.. image:: https://img.shields.io/badge/R-3.0,4.0-blue.svg
   :target: http://wellmap.readthedocs.io/en/latest/basic_usage_with_r.html

.. image:: https://readthedocs.org/projects/wellmap/badge/?version=latest
   :target: http://wellmap.readthedocs.io/en/latest/

.. image:: https://img.shields.io/github/actions/workflow/status/kalekundert/wellmap/test.yml?branch=master
   :target: https://github.com/kalekundert/wellmap/actions

.. image:: https://img.shields.io/coveralls/kalekundert/wellmap.svg
   :target: https://coveralls.io/github/kalekundert/wellmap?branch=master

Many medium-throughput experiments produce data in 24-, 96-, or 384-well plate 
format.  However, it can be a challenge to keep track of which wells (e.g. A1, 
B2, etc.) correspond to which experimental conditions (e.g. genotype, drug 
concentration, replicate number, etc.) for large numbers of experiments.  It 
can also be a challenge to write analysis scripts flexible enough to handle the 
different plate layouts that will inevitably come up as more and more 
experiments are run.

The *wellmap* package solves these challenges by introducing a `TOML-based file 
format`__ that succinctly describes the organization of wells on plates.  The 
file format is designed to be human-readable and -writable, so it can serve as 
a standalone digital record.  The file format can also be easily parsed in 
python and R to help write analysis scripts that will work regardless of how 
you (or your collaborators) organize wells on your plates.

__ https://wellmap.readthedocs.io/en/latest/file_format.html

Citation
========
Kundert, K. Wellmap: a file format for microplate layouts. *BMC Res Notes* 
**14**, 164 (2021). https://doi.org/10.1186/s13104-021-05573-0

Documentation
=============
See the complete documentation `here <http://wellmap.readthedocs.io/>`_.

.. image:: docs/manuscript/figures/well_groups.svg
long-range-models 0.0.1
Simple Flax implementations of long-range sequence models
Keywords: artificial intelligence,state space models,long range models

# Long Range Models

[![PyPI version](https://badge.fury.io/py/long_range_models.svg)](https://badge.fury.io/py/long_range_models)
[![Static Badge](https://img.shields.io/badge/powered%20by-Flax-blue)](https://github.com/google/flax)
[![Static Badge](https://img.shields.io/badge/license-MIT-yellow)](/LICENSE)


A collection of simple implementations of long-range sequence models, including [LRU](/long_range_models/lru.py), [S5](/long_range_models/s5.py), and [S4](/long_range_models/s4.py).
More implementations to come.

## Install

```bash
$ pip install long_range_models
```

## Usage

This library offers detailed documentation for every module and layer implemented.
Models are created by composing different pieces together.
Check out the examples below.

### Discrete sequence data

Consider a language model built with an LRU sequence layer and the architecture proposed in the S4 paper:

```py
from functools import partial
import jax.random as jrandom
from long_range_models import SequenceModel, S4Module, LRULayer

rng = jrandom.PRNGKey(0)

model = SequenceModel(
  num_tokens=1000,
  module=S4Module(
    sequence_layer=partial(LRULayer, state_dim=256),
    dim=128,
    depth=6,
  ),
)

x = jrandom.randint(rng, (1, 1024), 0, 1000)

variables = model.init(rng, x)
model.apply(variables, x)  # (1, 1024, 1000)

```

### Continuous sequence data

For sequences with continuous values, the setup looks as follows:

```py
from functools import partial
import jax.random as jrandom
from long_range_models import ContinuousSequenceModel, S4Module, LRULayer

rng = jrandom.PRNGKey(0)

model = ContinuousSequenceModel(
  out_dim=10,
  module=S4Module(
    sequence_layer=partial(LRULayer, state_dim=256),
    dim=128,
    depth=6,
  ),
)

x = jrandom.normal(rng, (1, 1024, 32))

variables = model.init(rng, x)
model.apply(variables, x)  # (1, 1024, 10)

```

**Note:** both model types offer several customization options. Make sure to check out [their documentation](/long_range_models/sequence_models.py).

## Upcoming features

- **More implementations:** Extend the library with models like S4D, S4Liquid, BiGS, Hyena, RetNet, SGConv, H3, and others.
- **Customization:** Allow users to better customize currently implemented layers and architectures (e.g., activation functions, initialization, etc.).
- **Sequential API:** Allow recurrent models to run sequentially, allowing for efficient inference.