semvec/pypi-packages huggingface dataset:
edgerun-request-generator 1.0.1.dev2
Edge Run Request Generator

# Edge Run Request Generator

This project provides ready-to-use request generators that the Galileo project uses to generate workload
(specifically, [faas-sim](https://github.com/edgerun/faas-sim) and [galileo-experiments](https://github.com/edgerun/galileo-experiments))

The project is structured simply and offers multiple generators that produce inter-arrival times.
Currently supported RPS profiles:

* Constant - does what you'd expect
* Sine - replicates a sine wave with a given peak (max rps) and period (simulation time in seconds between peaks)
* Randomwalk - creates a random walk pattern

RPS profiles yield a target average request per second pattern at a given time.


RPS profiles can be decorated using arrival profiles to get a more realistic request pattern.
Following arrival profiles are supported:

* Static
* Expovariate

You can save profiles using the helper function `save_requests` and `pre_recorded_profile` to read a saved profile
(only necessary if you like to plot it afterwards again).

# Install

To install dependencies and develop, run:

    make venv

This creates a virtual environment, activates it and installs all dependencies (`requirements.txt` and `requirements-dev.txt`).

If you like to run the notebooks (i.e., to generate request patterns and plot them comfortably):

    pip install -e .
    jupyter notebook

Note: you might have to restart the terminal session if `jupyter notebook` fails.
pixian-ai 1.0.0
Python SDK for pixian.ai
Requires Python: >3.6
Keywords: pixian.ai remove background

# pixian-ai

Python SDK for [pixian.ai](https://pixian.ai/).

## What is it?

Remove image backgrounds.

## Install

```bash
$ pip install pixian-ai
```

## Usage

### Basic

```python
from pixian_ai import PixianAI

client = PixianAI(
    api_id="PIXIAN-AI-API-ID",
    api_secret="PIXIAN-AI-API-SECRET",
)
img = client.remove_background("/path/to/input.jpeg")

img.save("/path/to/output.jpeg")
```

You can also use:

```python
client.remove_background(image_base64="base64encodedimage==")

# or

client.remove_background(image_url="https://imageurl.com/test.jpeg")
```

### Advanced

```python
client.remove_background(
    image_path="/path/to/image.jpeg",
    max_pixels=100,
    background_color="#0055FF"
    ...
)
```

Reference: [https://pixian.ai/api](https://pixian.ai/api#:~:text=uploading%20binary%20files.-,Parameters,-The%20input%20image)

All parameters described in the API spec above replace period (`.`) with underscore (`_`). For example, if the parameter is `background.color`, the SDK will use `background_color`.

## Contributing

Feel free to open a PR for any changes!

## Testing

```bash
$ python -m unittest discover -s tests -p 'test_*.py'
```

Made with ❤️ by [@mitchbregs](https://twitter.com/mitchbregs)
minisom-gpu 0.2.0
Minimalistic implementation of the Self Organizing Maps (SOM) employing GPU.
Requires Python: >=3.7

<h1>MiniSom<img src='https://3.bp.blogspot.com/-_6UDGEHzIrs/WSfiyjmoeRI/AAAAAAAABHw/3UQylcCBEhUfHNhf56WSHBBmQ6g_lXQhwCLcB/s320/minisom_logo.png' align='right'></h1>

Self Organizing Maps
--------------------

MiniSom GPU is a minimalistic and PyTorch based implementation of the Self Organizing Maps (SOM). SOM is a type of Artificial Neural Network able to convert complex, nonlinear statistical relationships between high-dimensional data items into simple geometric relationships on a low-dimensional display. Minisom is designed to allow researchers to easily build on top of it and to give students the ability to quickly grasp its details.

This repository is a fork of the original [MiniSom package](https://github.com/JustGlowing/minisom).

Installation
---------------------

Just use pip:

    pip install minisom_gpu


How to use it
---------------------

In order to use MiniSom you need your data organized as a PyTorch tensor where each row corresponds to an observation like the following:

```python
import torch

data = torch.tensor([[ 0.80,  0.55,  0.22,  0.03],
        [ 0.82,  0.50,  0.23,  0.03],
        [ 0.80,  0.54,  0.22,  0.03],
        [ 0.80,  0.53,  0.26,  0.03],
        [ 0.79,  0.56,  0.22,  0.03],
        [ 0.75,  0.60,  0.25,  0.03],
        [ 0.77,  0.59,  0.22,  0.03]])
```

 Then you can train MiniSom just as follows:

```python
from minisom_gpu.som import MiniSom    
som = MiniSom(6, 6, 4, sigma=0.3, learning_rate=0.5) # initialization of 6x6 SOM
som.train(data, 100) # trains the SOM with 100 iterations
```

You can obtain the position of the winning neuron on the map for a given sample as follows:

```
som.winner(data[0])
```

For an overview of all the features implemented in minisom you can browse the following examples: https://github.com/rctorres/minisom/tree/master/examples