semvec/pypi-packages huggingface dataset:
egnn-jax 0.3
E(3) GNN in jax
Requires Python: >=3.8

# E(n) Equivariant GNN in jax
Reimplementation of [EGNN](https://arxiv.org/abs/2102.09844) in jax. Original work by Victor Garcia Satorras, Emiel Hogeboom and Max Welling.

## Installation
```
python -m pip install egnn-jax
```

Or clone this repository and build locally
```
git clone https://github.com/gerkone/egnn-jax
cd painn-jax
python -m pip install -e .
```
### GPU support
Upgrade `jax` to the gpu version
```
pip install --upgrade "jax[cuda]==0.4.10" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
```

## Validation
N-body (charged) is included for validation from the original paper. Times are  __model only__ on batches of 100 graphs, in (global) single precision.
|                  |  MSE  | Inference [ms]* |
|------------------|-------|-----------------|
| torch (original) | .0071 |      8.27       |
| jax (ours)       | .0093 |      0.94       |

\* remeasured (Quadro RTX 4000)

### Validation install

The N-Body experiments are only included in the github repo, so it needs to be cloned first.
```
git clone https://github.com/gerkone/egnn-jax
```

They are adapted from the original implementation, so additionally `torch` and `torch_geometric` are needed (cpu versions are enough).
```
python -m pip install -r nbody/requirements.txt
```

### Valdation usage
The charged N-body dataset has to be locally generated in the directory [/nbody/data](/nbody/data).
```
python -u generate_dataset.py --num-train 3000 --seed 43 --sufix small
```
Then, the model can be trained and evaluated with
```
python validate.py --epochs=1000 --batch-size=100 --lr=1e-4 --weight-decay=1e-12
```

## Acknowledgements
This implementation heavily borrows from the [original pytorch code](https://github.com/vgsatorras/egnn).
python-llm 0.2.0
An LLM wrapper for Humans
Requires Python: >=3.6

# python-llm: A LLM API for Humans

![Tests](https://github.com/danielgross/python-llm/actions/workflows/tests.yml/badge.svg)

The simplicity and elegance of python-requests, but for LLMs. This library supports models from OpenAI and Anthropic. I will try to add more when I have the time, and am warmly accepting pull requests if that's of interest.

## Usage

```python
import llm
llm.set_api_key(openai="sk-...", anthropic="sk-...")

# Chat
llm.chat("what is 2+2") # 4. Uses GPT-3 by default if key is provided.
llm.chat("what is 2+2", engine="anthropic:claude-instant-v1") # 4.

# Completion
llm.complete("hello, I am") # A GPT model.
llm.complete("hello, I am", engine="openai:gpt-4") # A big GPT model.
llm.complete("hello, I am ", engine="anthropic:claude-instant-v1") # Claude.

# Back-and-forth chat [human, assistant, human]
llm.chat(["hi", "hi there, how are you?", "good, tell me a joke"]) # Why did chicken cross road?

# Streaming chat
llm.stream_chat(["what is 2+2"]) # 4. 
llm.multi_stream_chat(["what is 2+2"], 
                      engines=
                      ["anthropic:claude-instant-v1", 
                      "openai:gpt-3.5-turbo"]) 
# Results will stream back to you from both models at the same time like this:
# ["anthropic:claude-instant-v1", "hi"], ["openai:gpt-3.5-turbo", "howdy"], 
# ["anthropic:claude-instant-v1", " there"] ["openai:gpt-3.5-turbo", " my friend"]

# Engines are in the provider:model format, as in openai:gpt-4, or anthropic:claude-instant-v1.
```

## Multi Stream Chat In Action
Given this feature is very lively, I've included a video of it in action.

https://github.com/danielgross/python-llm/assets/279531/d68eb843-7a32-4ffe-8ac2-b06b81e764b0

## Installation

To install `python-llm`, use pip: ```pip install python-llm```.

## Configuration
You can set API keys in a few ways:
1. Through environment variables (you can also set a `.env` file).
```bash
export OPENAI_API_KEY=sk_...
export ANTHROPIC_API_KEY=sk_...
```
2. By calling the method manually:
```python
import llm
llm.set_api_key(openai="sk-...", anthropic="sk-...")
```
3. By passing a JSON file like this:
```python
llm.set_api_key("path/to/api_keys.json")
```
The JSON should look like:
```json
{
  "openai": "sk-...",
  "anthropic": "sk-..."
}
```

## TODO 
- [ ] Caching! 
- [ ] More LLM vendors!
- [ ] More tests!
aish 0.1.8
A command-line application that interacts with the OpenAI ChatGPT API.

# Aish - ChatGPT CLI

This command-line interface (CLI) application is used to interact with the OpenAI through the OpenAI API. The chatbot takes an input prompt and returns a response from the selected model.

## Installation

Ensure you have Python 3.7+ installed. To install the required libraries, use:

```bash
    pip install aish
```

## Usage

To use the application, you need to set the environment variable `OPENAI_API_KEY` with your OpenAI API key. Then, you can run the script from the terminal using the command:

```bash
    aish How can i list all files older than 30 days?
```

```bash
    aish -s How can i list all files older than 30 days?
```

```bash
    aish -c code Write a hello world app in python
```

Optional parameters will take default values if not provided:

- `ModelVersion`: The model version that you want to use. Default is "gpt-3.5-turbo".
- `TemperatureValue`: The randomness of the AI’s responses. A lower value makes the output more focused and deterministic, while higher values produce more diverse and random outputs. Default is 0.5.
- `TopPValue`: A parameter for controlling randomness. A higher value generates more random responses, and a lower value generates more deterministic responses. Default is 0.5.
- `TimeoutValue`: The maximum time in seconds that the request will wait for a response from the API. Default is 60.

## Help

You can display the help message which provides details about the command usage and the different parameters by running:

```bash
    aish --help
```