semvec/pypi-packages huggingface dataset:
pasero 0.0.1
pasero for detecting pathogen-serotype outbreaks
Requires Python: >=3.8

# pasero

pasero is a PyPI tool to visualize "Number of isolates" or "% Change" against the baseline of "Past two years average". pasero can be used for detecting outbreaks of pathogens and serotypes.
Execute the pip command provided below in your system terminal to install Pasero. 
Note that the symbol ‘$’ signifies the system prompt. Pasero is an interactive system to show either 'Number of isolates' or 'Past two years average' as baseline and '% Change'.

$ pip install pasero

The subsequent illustration showcases a scenario where ‘Salmonella’ is the chosen pathogen and ‘Sundsvall’ is the selected serotype. The ‘Past two years average and % Change’ option was picked, resulting in a graph with two distinct lines.

<pre>
$ pasero
Pathogens:
1. Campylobacter
2. STEC
3. Salmonella
4. Shigella
5. Vibrio
Select a pathogen by number: 3

Serotypes:
1. Africana
2. Agbeni
3. Agona
  ...
32. Stanley
33. Sundsvall
34. Thompson
35. Typhi
36. Typhimurium
37. Uganda
Select up to 4 serotypes by number (separated by space): 33

1. Number of isolates
2. Past two years average and % Change
Select one by number: 2
</pre>
<img src='https://github.com/y-takefuji/pasero/raw/main/Salmonella_Sundsvall.png' width=640 hight=480>
tinymodel_feature_circuits 0.1.1.post8
A small TinyStories LM with SAEs and transcoders
Requires Python: <4.0,>=3.11

# [TinyModel](https://github.com/noanabeshima/tiny_model)
TinyModel is a 4 layer, 44M parameter model trained on [TinyStories V2](https://arxiv.org/abs/2305.07759) for mechanistic interpretability. It uses ReLU activations and no layernorms. It comes with trained SAEs and transcoders.

It can be installed with `pip install tinymodel`


```
from tiny_model import TinyModel, tokenizer

lm = TinyModel()

# for inference
tok_ids, attn_mask = tokenizer(['Once upon a time', 'In the forest'])
logprobs = lm(tok_ids)

# Get SAE/transcoder acts
# See 'SAEs/Transcoders' section for more information.
feature_acts = lm['M1N123'](tok_ids)
all_feat_acts = lm['M2'](tok_ids)

# Generation
lm.generate('Once upon a time, Ada was happily walking through a magical forest with')

# To decode tok_ids you can use
tokenizer.decode(tok_ids)
```

It was trained for 3 epochs on a [preprocessed version of TinyStoriesV2](https://huggingface.co/datasets/noanabeshima/TinyStoriesV2). Pre-tokenized dataset [here](https://huggingface.co/datasets/noanabeshima/TinyModelTokIds). I recommend using this dataset for getting SAE/transcoder activations.



# SAEs/transcoders
Some sparse SAEs/transcoders are provided along with the model.

For example, `acts = lm['M2N100'](tok_ids)`

To get sparse acts, choose which part of the transformer block you want to look at (currently [sparse MLP](https://www.lesswrong.com/posts/MXabwqMwo3rkGqEW8/sparse-mlp-distillation)/[transcoder](https://www.alignmentforum.org/posts/YmkjnWtZGLbHRbzrP/transcoders-enable-fine-grained-interpretable-circuit) and SAEs on attention out are available, under the tags `'M'` and `'A'` respectively). Residual stream and MLP out SAEs exist, they just haven't been added yet, bug me on e.g. Twitter if you want this to happen fast.

Then, add the layer. A sparse MLP at layer 2 would be `'M2'`.
Finally, optionally add a particular neuron. For example `'M0N10000'`.

# Tokenization
Tokenization is done as follows:
- the top-10K most frequent tokens using the GPT-NeoX tokenizer are selected and sorted by frequency.
- To tokenize a document, first tokenize with the GPT-NeoX tokenizer. Then replace tokens not in the top 10K tokens with a special \[UNK\] token id. All token ids are then mapped to be between 1 and 10K, roughly sorted from most frequent to least.
- Finally, prepend the document with a [BEGIN] token id.
raydium-sdk 2.1.3
SDK for trading tokens on Solana's Raydium DEX
Requires Python: <4.0,>=3.10

# raydium_sdk

SDK for trading tokens on Solana's Raydium DEX.

## Features
- **Buy tokens**
- **Sell tokens** 
- **Get token symbol**
- **Get token balance** 
- **Download and cache raydium liquidity pools** 
- **Customizable compute limits and prices (gas fees)**
- **Use custom RPC**

## Installation 

```bash
pip install raydium-sdk
``` 

## Quick Start 

```python
from raydium_sdk import buy_token, sell_token
from solana.rpc.api import Client, Keypair
from solana.rpc.async_api import AsyncClient

RPC = "https://api.mainnet-beta.solana.com" # Use an RPC provider like Helius, the official RPC has strict ratelimits

async_solana_client = AsyncClient(RPC)
solana_client = Client(RPC)

keypair = Keypair.from_base58_string("your-private-key")

buy_tx = buy_token(
    solana_client, 
    async_solana_client, 
    "EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzLHYxdM65zcjm", # Token address
    keypair,  
    0.01, # SOL amount to buy
    debug=True # Shows debug information
) # Returns TXID if successful

print("Buy TXID:", buy_tx)

sell_tx = sell_token(
    solana_client, 
    async_solana_client, 
    "EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzLHYxdM65zcjm", # Token address
    keypair
    None, # Amount of token to sell, sells all if not specified/None
    debug=True, # Shows debug information
) # Returns TXID if successful

print("Sell TXID:", sell_tx)
```
bambulab-cloud 0.0.1
Unofficial Python client for Bambulab's Cloud API
Requires Python: >=3.8.1

# bambulab-cloud-py

> Python implementation of [bambulab-rs](https://github.com/m1guelpf/bambulab-rs)

An unofficial Python client for Bambulab's Cloud API.

# 🛠️ Usage
```python
from bambulab_cloud import BambuClient

client = await BambuClient.login(email, password)
profile = await client.get_profile()
print(profile)
devices = await client.get_devices()
print(devices)
tasks = await client.get_tasks()
print(tasks)
```
Supported calls so far are just `GET` requests for data.

## License
[MIT](https://github.com/zhaobenny/bambulab-cloud-py/blob/main/LICENSE)
vpredicto 0.2.1
A library for video frame prediction using SimVP, PredRNN++, MIM, PredNet, Novel GAN and Causal LSTM.
Requires Python: >=3.6

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>
<body>
    <h1>Predicto</h1>
    <p><strong>Predicto</strong> is a Python library for video frame prediction, featuring three state-of-the-art models: PredRNN++, MIM, and Causal LSTM. This library is designed to cater to both expert and non-expert users, providing an API for developers and a simple interface for non-experts.</p>

    <h2>Features</h2>
    <ul>
        <li>Three video frame prediction models: PredRNN++, MIM, and Causal LSTM.</li>
        <li>Easy-to-use interface for training and testing models.</li>
        <li>Supports custom dataloaders or default to MovingMNIST dataset.</li>
        <li>Pre and post-processing for input and output in each model.</li>
    </ul>

    <h2>Installation</h2>
    <pre><code>pip install predicto</code></pre>

    <h2>Usage</h2>
    <h3>Quick Start</h3>
    <pre><code>from predicto import PredRNN, MIM, ConvLSTM, SimVP,PredNet, Novel GAN and Predicto

# Create a model object
model_object = MIM()

# Initialize Predicto with the model object
model = Predicto(model_object)

# Train the model
model.train(train_loader)

# Test the model
model.test(test_loader)</code></pre>

    <h3>Custom Dataloader</h3>
    <pre><code>from predicto import PredRNN, MIM, CausalLSTM, Predicto

# Define your custom dataloader
class CustomDataLoader:
    def __init__(self, ...):
        ...

    def __iter__(self):
        ...

# Create a model object
model_object = CausalLSTM()

# Initialize Predicto with the model object and custom dataloader
model = Predicto(model_object, dataloader=CustomDataLoader())

# Train the model
model.train(train_loader)

# Test the model
model.test(test_loader)</code></pre>

    <h2>Models</h2>
    <ul>
        <li><strong>PredRNN++</strong>: A recurrent neural network model for video frame prediction.</li>
        <li><strong>MIM</strong>: Memory In Memory network for spatiotemporal predictive learning.</li>
        <li><strong>Causal LSTM</strong>: A causal LSTM model for video frame prediction.</li>
    </ul>

</body>
</html>