semvec/pypi-packages huggingface dataset:
mase-triton 0.0.6.post4
Triton kernels for MASE
Requires Python: >=3.11
Keywords: deep-learning, mase, triton

# MASE-Triton

Software-emulation & acceleration triton kernels for [MASE](https://github.com/DeepWok/mase).

## Install

Please ensure you are using Python 3.11 or later, and run MASE-Triton on **CUDA-enabled GPU**.

### PyPI

```bash
pip install mase-triton
```

### Build from Source

1. Install [uv](https://docs.astral.sh/uv/)
2. Build the package

    ```bash
    uv build
    ```

    The wheel file can be found in `dist/` folder.
    You can install it by `pip install path/to/wheel/file.whl`


## Functionality
- Random Bitflip
    - [`functional APIs`](/src/mase_triton/random_bitflip/functional.py): random bitflip function with backward support.
    - [`layers.py`](/src/mase_triton/random_bitflip/layers.py): subclasses of `torch.nn.Module` that can be used in neural networks.
        - `RandomBitflipDropout`
        - `RandomBitflipLinear`
- [Optical Transformer](https://arxiv.org/abs/2302.10360)
    - [`functional APIs`](/src/mase_triton/optical_compute/functional.py): optical transformer function with backward support.
        - `ot_quantize`
        - `ot_linear`
        - `ot_matmul`
    - [`layers.py`](/src/mase_triton/optical_compute/layers.py): subclasses of `torch.nn.Module` that can be used in neural networks.
        - `OpticalTransformerLinear`
- [MXFP](https://arxiv.org/abs/2310.10537): Simulate MXFP formats on CPU & GPU using PyTorch & Triton.
    - [`functional`](/src/mase_triton/mxfp/functional/__init__.py)
        - `extract_mxfp_tensor`: Cast a tensor to MXFP format (extracting the shared exponent and Minifloat elements).
        - `compose_mxfp_tensor`: Cast an MXFP tensor to FP format (composing MXFP components).
        - `mxfp_linear`: functional linear operation with MXFP support.
        - `mxfp_matmul`: functional matrix multiplication with MXFP support.
    - [`layers`](/src/mase_triton/mxfp/layers.py)
        - `MXFPLinearPTQ`: Linear layer with MXFP support for post-training quantization (no back propagation support).
- Minifloat: Simulate minifloat formats on CPU & GPU using PyTorch & Triton.
    - [`functional`](/src/mase_triton/minifloat/functional/__init__.py)
        - `extract_minifloat_component`: Extract minifloat components from a tensor.
        - `compose_minifloat_component`: Compose minifloat components back to a tensor.
        - `quantize_dequantize`: Quantize and dequantize tensors using minifloat format.
        - `minifloat_linear`: functional linear operation with minifloat support.
        - `minifloat_matmul`: functional matrix multiplication with minifloat support.
    - [`layers`](/src/mase_triton/minifloat/layers.py)
        - `MinifloatLinearPTQ`: Linear layer with minifloat support for post-training quantization (no back propagation support).


## Dev

1. Install [uv](https://docs.astral.sh/uv/)
2. Install dependencies for development

    ```bash
    uv sync
    ```
y2hscore 0.1.0
Y2HScore runs with python -m y2hscore
Requires Python: >=3.10

# Y2HScore

A Python tool that runs with:

```bash
python -m y2hscore
```

It uses:

* **OpenCV** (>= 4.10, < 5.0)
* **NumPy** (>= 2.2)
* **Tkinter** (for GUI support)

---

## Installation

1. Make sure you have Python **3.10+** installed.
2. Clone or download this repository.
3. Install the package:

```bash
pip install -e .
```

This will also install **OpenCV** and **NumPy** automatically.

---

## Usage

After installation, run:

```bash
python -m y2hscore
```
torch-linear-assignment 0.0.5
Batched linear assignment with PyTorch and CUDA.

# Batch linear assignment for PyTorch
[![PyPI version](https://badge.fury.io/py/torch-linear-assignment.svg)](https://badge.fury.io/py/torch-linear-assignment)
[![Build Status](https://github.com/ivan-chai/torch-linear-assignment/actions/workflows/ci-tests.yml/badge.svg)](https://github.com/ivan-chai/torch-linear-assignment/actions)
[![Downloads](https://static.pepy.tech/badge/torch-linear-assignment)](https://pepy.tech/project/torch-linear-assignment)
[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
<h4 align="left">
    <p>
        <a href="#Install">Installation</a> |
        <a href="#Example">Usage</a> |
        <a href="#Citation">Citation</a>
    <p>
</h4>
Batch computation of the linear assignment problem on GPU.

## Install
Build and install via PyPI (source distribution):
```bash
pip install torch-linear-assignment
```

Build and install from Git repository:
```bash
pip install .
```

Building in an isolated environment may use a different PyTorch version. To match the current environment and reduce the disk usage, apply the following flag:
```bash
pip install --no-build-isolation torch-linear-assignment
```

When building with CUDA, make sure NVCC has the same CUDA version as PyTorch.
You can choose CUDA version by
```bash
export PATH=/usr/local/cuda-<version>/bin:"$PATH"
```

If you need custom C++ compiler, use the following command:
```bash
CXX=<c++-compiler> CC=<gcc-compiler> pip install .
```

If you get a torch-not-found error, try the following command:
```bash
pip install --upgrade pip wheel setuptools
python -m pip install .
```

## Example
```python
import torch
from torch_linear_assignment import batch_linear_assignment

cost = torch.tensor([
    8, 4, 7,
    5, 2, 3,
    9, 6, 7,
    9, 4, 8
]).reshape(1, 4, 3).cuda()

assignment = batch_linear_assignment(cost)
print(assignment)
```

The output is:
```py
tensor([[ 0,  2, -1,  1]], device='cuda:0')
```

To get indices in the SciPy's format:
```py
from torch_linear_assignment import assignment_to_indices

row_ind, col_ind = assignment_to_indices(assignment)
print(row_ind)
print(col_ind)
```

The output is:
```py
tensor([[0, 1, 3]], device='cuda:0')
tensor([[0, 2, 1]], device='cuda:0')
```

# Citation
The code was originally developed for the [HoTPP Benchmark](https://github.com/ivan-chai/hotpp-benchmark). If you use this code in your research project, please cite one of the following papers:
```
@article{karpukhin2024hotppbenchmark,
  title={HoTPP Benchmark: Are We Good at the Long Horizon Events Forecasting?},
  author={Karpukhin, Ivan and Shipilov, Foma and Savchenko, Andrey},
  journal={arXiv preprint arXiv:2406.14341},
  year={2024},
  url ={https://arxiv.org/abs/2406.14341}
}

@article{karpukhin2024detpp,
  title={DeTPP: Leveraging Object Detection for Robust Long-Horizon Event Prediction},
  author={Karpukhin, Ivan and Savchenko, Andrey},
  journal={arXiv preprint arXiv:2408.13131},
  year={2024},
  url ={https://arxiv.org/abs/2408.13131}
}
```
stockpulse 0.1.0
A robust Python package for fetching and managing stock market data with yfinance to avoid frequent rate-limiting.
Requires Python: >=3.8

# StockPulse
A robust Python package for fetching and managing stock market data with rate-limiting.

## Installation
```bash
pip install stockpulse
```

## Usage
```
from stockpulse import fetch_stock_data, intra_day_data, get_real_time_prices

# Fetch historical data
data = fetch_stock_data(tickers=["AAPL", "TSLA"], save_to_csv=True)

# Fetch intraday data
intraday = intra_day_data(tickers=["AAPL"], period="1d")

# Get real-time prices
prices = get_real_time_prices(tickers=["AAPL", "GOOGL"])
print(prices)

```

## Features

- Fetch historical and intraday stock data using yfinance.
- Rate-limiting to avoid API restrictions.
- Save data to CSV with organized file structure.
- Continuous data fetching for real-time applications.