semvec/pypi-packages huggingface dataset:
torchdtw 0.1.1
PyTorch DTW C++ extension
Requires Python: >=3.12
Keywords: machine learning

# PyTorch DTW C++ extension

Dynamic time warping in native PyTorch, with CPU and CUDA backends.

```bash
pip install torchdtw
```

This package requires PyTorch 2.10 or later. It is developed using the PyTorch
2.10 Stable ABI, and compiled with instructions for CUDA cards from Volta to Blackwell.
This was originally made for [fastabx](https://github.com/bootphon/fastabx), but
it can be used in other projects. Only the exact DTW is implemented, there is
no plan to add variants.

## Usage
 
This package provides three functions:

### DTW

```python
def dtw(distances: torch.Tensor) -> torch.Tensor
```

Compute the DTW cost of the given ``distances`` 2D tensor.

**Arguments**:

- `distances`: A 2D tensor of shape (n, m) representing the pairwise distances between two sequences.

**Returns**:

A scalar tensor with the cost.

### DTW path

```python
def dtw_path(distances: torch.Tensor) -> torch.Tensor
```

Compute the DTW path of the given ``distances`` 2D tensor.

No CUDA variant or batched implementation are provided for now.

**Arguments**:

- `distances`: A 2D tensor of shape (n, m) representing the pairwise distances between two sequences.

**Returns**:

A 2D tensor of shape (*, 2) with the path indices.

### Batched DTW

```python
def dtw_batch(distances: torch.Tensor, sx: torch.Tensor, sy: torch.Tensor, *,
              symmetric: bool) -> torch.Tensor
```

Compute the batched DTW cost on the ``distances`` 4D tensor.

**Arguments**:

- `distances`: A 4D tensor of shape (n1, n2, s1, s2) representing the pairwise distances between two
batches of sequences.
- `sx`: A 1D tensor of shape (n1,) representing the lengths of the sequences in the first batch.
- `sy`: A 1D tensor of shape (n2,) representing the lengths of the sequences in the second batch.
- `symmetric`: Whether or not the DTW is symmetric (i.e., the two batches are the same).

**Returns**:

A 2D tensor of shape (n1, n2) with the costs.

## Benchmark

Check [this folder](https://github.com/mxmpl/torchdtw/tree/main/benchmark) for comparisons
against reference implementations.

## Citation

Please cite the fastabx paper if you use this package in your work:

```bib
@misc{fastabx,
  title={fastabx: A library for efficient computation of ABX discriminability},
  author={Maxime Poli and Emmanuel Chemla and Emmanuel Dupoux},
  year={2025},
  eprint={2505.02692},
  archivePrefix={arXiv},
  primaryClass={cs.CL},
  url={https://arxiv.org/abs/2505.02692},
}
```
pennylane-quantuminspire 0.13.0
The PennyLane-QuantumInspire plugin integrates the Quantum Inspire quantum computing backends with PennyLane's quantum machine learning capabilities.
Requires Python: <3.14,>=3.11

# PennyLane-QuantumInspire Plugin

[![License](https://img.shields.io/github/license/qutech-delft/qiskit-quantuminspire.svg?style=popout-square)](https://opensource.org/licenses/Apache-2.0)

**[PennyLane]** is an open-source SDK for quantum programming.
This project contains a provider that allows access to **[Quantum Inspire]** quantum systems.

## Getting started

All information needed to get started using this plugin can be found in our [documentation](https://qutech-delft.github.io/pennylane-quantuminspire/). Some particularly useful links:

1. [Installation and login](https://qutech-delft.github.io/pennylane-quantuminspire/getting_started/installation.html)
2. [Submitting your first circuit](https://qutech-delft.github.io/pennylane-quantuminspire/getting_started/submitting.html)
3. [Example notebooks](https://qutech-delft.github.io/pennylane-quantuminspire/notebooks/index.html)

[quantum inspire]: https://www.quantum-inspire.com/
[pennylane]: https://pennylane.ai/
phonexia-enhanced-speech-to-text-built-on-whisper-client 2.1.1
Audio Quality Estimation Client
Requires Python: >=3.9
Keywords: grpc, transcription, STT, ASR, speech to text, speech, language, microservice


![](https://www.phonexia.com/wp-content/uploads/PHX_logotype_basic_2016_positive_transparent_RGB.png)

# Phonexia enhanced speech to text built on whisper client

This module contains client for communication with [enhanced speech to text built on whisper](https://hub.docker.com/r/phonexia/enhanced-speech-to-text-built-on-whisper/) developed by [Phonexia](https://phonexia.com).

To use this client you will first need a running instance of any *Phonexia enhanced speech to text built on whisper microservice*. If you don't yet have any running instance, don't hesitate to [contact our sales department](mailto:info@phonexia.com).

You can learn more about the enhanced speech to text built on whisper technology [here](https://docs.phonexia.com/products/speech-platform-4/technologies/speech-to-text/enhanced-speech-to-text-built-on-whisper).

On [this page](https://docs.phonexia.com/products/speech-platform-4/grpc/api/phonexia/grpc/technologies/enhanced_speech_to_text_built_on_whisper/v1/enhanced_speech_to_text_built_on_whisper.proto), you will find a *gRPC API* reference for *enhanced speech to text built on whisper microservice*.
khmerns 0.0.4
Khmer Neural Segmenter
Requires Python: >=3.9
Keywords: khmer, nlp, segmentation, tokenization, neural-network

# Khmer Neural Segmenter

A fast Khmer word segmentation library.

<img src="img/graph.png" alt="" width=500>

## Installation

```
pip install khmerns
```

## Usage

```python
from khmerns import tokenize, normalize

# Returns a list of words
words = tokenize("សួស្តីបងប្អូន")
# => ['សួស្តី', 'បង', 'ប្អូន']

# normalize and reorder Khmer characters
words = tokenize(normalize("សួស្តីបងប្អូន"))
# => ['សួស្តី', 'បង', 'ប្អូន']
```

You can also use the class-based API if you prefer:

```python
from khmerns import KhmerSegmenter

segmenter = KhmerSegmenter()

words = segmenter.tokenize("សួស្តីបងប្អូន")
# or

words = segmenter("សួស្តីបងប្អូន")
```

## Training

The training pipeline lives in the `training/` directory. It trains a BiGRU + CRF model on character-level BIO tags, then converts the result to GGUF for the C++ inference backend.

### Data format

Training data is a plain text file at `training/data/train.txt`. One word per line. Words that appear on consecutive lines are treated as part of the same sentence. The model learns word boundaries from this.

Example `training/data/train.txt`:

```
សួស្តី
បង
ប្អូន
ខ្ញុំ
ទៅ
ផ្សារ
```

Non-Khmer tokens (spaces, punctuation, numbers, Latin text) are tagged as `NON-KHMER`. Khmer tokens get `B-WORD` on the first character and `I-WORD` on the rest.

### Steps

```bash
cd training
pip install -r requirements.txt
```

**1. Prepare training data**

Place your segmented text in `data/train.txt` (one word per line). If you have raw unsegmented Khmer text, you can use the generation script to pre-segment it:

```bash
python generate.py
```

This requires `khmersegment` and a source text file. Edit the path in `generate.py` to point to your raw text.

**2. Train**

```bash
python train.py
```

Trains for 20 epochs with AdamW (lr=1e-5) and ReduceLROnPlateau. Saves `best_model.pt` (best eval loss) and `model.pt` (final). Uses CUDA if available.

**3. Convert to GGUF**

```bash
python convert_to_gguf.py best_model.pt model.gguf
```

This produces a GGUF file (~3.3MB) containing all model weights.

**4. Embed in the C++ binary**

To use the new model in the library, convert the GGUF file to a C header and replace `src/model_data.h`, then rebuild:

```bash
xxd -i model.gguf > ../src/model_data.h
pip install -e ..
```

## License

MIT
cliboa 3.0.0a0
application framework for ETL(ELT) processing
Requires Python: <4.0,>=3.10
Keywords: etl, elt, data pipeline, workflow, automation, framework

[![PyPI](https://img.shields.io/pypi/v/cliboa?style=flat-square)](https://pypi.org/project/cliboa)
[![PyPI - Implementation](https://img.shields.io/pypi/implementation/cliboa?style=flat-square)](https://pypi.org/project/cliboa)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cliboa?style=flat-square)](https://pypi.org/project/cliboa)
[![GitHub Actions](https://github.com/BrainPad/cliboa/actions/workflows/test.yaml/badge.svg)](https://github.com/BrainPad/cliboa/actions/workflows/test.yaml)
[![Code Style:
black](https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square)](https://github.com/psf/black)
[![Contributions Welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/BrainPad/cliboa/blob/master/CONTRIBUTING.md)
[![Repo Size](https://img.shields.io/github/repo-size/BrainPad/cliboa)](https://github.com/BrainPad/cliboa)

# Table of Contents
* [Introduction](#introduction)
  * [What is cliboa](#what-is-cliboa)
  * [Features](#features)
* [Documentation](#documentation)

# Introduction

## What is cliboa

**cliboa** is an application framework designed for building ETL/ELT pipelines.
It streamlines the entire process of fetching, transforming, and transferring data between various databases, cloud storage, and other services.
![](/img/cliboa_brief.png)

## Features
- **Python based framework**: Leverage the power and flexibility of Python.
- **YAML-based configuration**: Define and execute complex ETL/ELT workflows with simple, human-readable YAML files.
- **Highly extensible**: Easily implement custom modules in just a few steps if the built-in modules don't meet your specific needs.

# Documentation

> [!NOTE]
> **cliboa v3 has been released!**
> With the release of v3, official support for v2 has ended. We recommend all users to migrate to v3.

* [QuickStart](/docs/quick_start.md)
* [MANUAL](/docs/manual.md)
  * [Scenario Configuration](/docs/scenario_configuration.md)
  * [Default ETL Modules](/docs/default_etl_modules.md)
  * [Migration Guide from v2 to v3](/docs/migration_v2_to_v3.md)
* [How to Contribute](/CONTRIBUTING.md)
* [Developer Documents](/docs/developers/)