semvec/pypi-packages huggingface dataset:
livekit-plugins-tenvad 1.0.8
Agent Framework Plugin for TEN VAD
Requires Python: >=3.10
Keywords: audio, livekit, realtime, video, webrtc

# LiveKit Plugins – TEN VAD  

**`livekit-plugins-tenvad`** provides seamless integration of the [TEN-framework/ten-vad](https://github.com/TEN-framework/ten-vad) voice activity detection (VAD) plugin into the [LiveKit](https://github.com/livekit) ecosystem.  

This plugin enables **real-time speech activity detection** with low-latency inference, optimized for streaming, conversational AI, and **[livekit-agents](https://github.com/livekit/agents)** integration.  

## ✨ Features  
- 🔌 **LiveKit plugin integration** — plug-and-play support for LiveKit workflows  
- 🤖 **Compatible with livekit-agents** — extend agents with real-time VAD capabilities  
- 🎤 **Accurate voice activity detection** powered by [TEN VAD](https://github.com/TEN-framework/ten-vad)  
- ⚡ **Low-latency inference** (~0.17ms avg per frame) suitable for real-time use  
- 📊 **Benchmark validated** against Silero VAD (faster and more continuous speech detection)  
- 🛠️ **Configurable & extensible** within the LiveKit plugin system  


## 🔧 Installation  
```bash
# from PyPI
uv pip install livekit-plugins-tenvad

# from source
uv pip install git+https://github.com/dangvansam/livekit-plugins-tenvad.git
```
## 🔌 Usage
```python
from livekit.plugins import tenvad

vad = tenvad.VAD.load(
    activation_threshold=0.5,
    min_speech_duration=0.1,
    min_silence_duration=0.3,
    max_buffered_speech=60,
    prefix_padding_duration=0.3
)
```

## 📊 Run Benchmark  
```bash
git clone https://github.com/dangvansam/livekit-plugins-tenvad.git

cd livekit-plugins-tenvad

# install dependencies for testing
uv pip install .[test]

python test/benchmark.py -i test/sample.wav
```


### Benchmark Results  

| Metric                  | Silero VAD                | TEN VAD                  |
|--------------------------|---------------------------|--------------------------|
| Speech segments          | 95                        | 41                       |
| Total speech             | 19.01s (13.0%)            | 114.98s (78.8%)          |
| Avg inference time       | 0.22ms                    | 0.17ms                   |
| Min inference time       | 0.18ms                    | 0.14ms                   |
| Max inference time       | 9.76ms                    | 0.78ms                   |

**Highlights:**  
- TEN VAD is **~1.27× faster per frame**  
- Detects **longer continuous speech** compared to Silero  
- Provides **lower latency** with fewer false segment splits  

## Visualizations
### Long audio
![TEN VAD Benchmark](test/vad_comparison_long_audio.png)

### Short audio
![TEN VAD Benchmark](test/vad_comparison_short_audio.png)

## Citations
```
@misc{TEN VAD,
  author       = {TEN Team},
  title        = {TEN VAD: A Low-Latency, Lightweight and High-Performance Streaming Voice Activity Detector (VAD)},
  year         = {2025},
  publisher    = {GitHub},
  journal      = {GitHub repository},
  howpublished = {\url{https://github.com/TEN-framework/ten-vad.git}},
  email        = {developer@ten.ai}
}
```
openinference-instrumentation-portkey 0.1.7
OpenInference Portkey AI Instrumentation
Requires Python: <3.15,>=3.9

# OpenInference Portkey AI Instrumentation

This package provides instrumentation for the [Portkey AI](https://portkey.ai) library using OpenInference.

## Installation

```bash
pip install openinference-instrumentation-portkey
```

## Usage

```python
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import ConsoleSpanExporter
from opentelemetry.sdk.trace.export import SimpleSpanProcessor

from openinference.instrumentation.portkey import PortkeyInstrumentor

# Set up the tracer provider
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
    SimpleSpanProcessor(ConsoleSpanExporter())
)

# Instrument Portkey AI
PortkeyInstrumentor().instrument()

# Use Portkey AI as usual
# ...

# Uninstrument when done
PortkeyInstrumentor().uninstrument()
```

## Features

- Automatic instrumentation of Portkey AI API calls
- Capture of input messages, output messages, and model information
- Integration with OpenTelemetry for distributed tracing

## Requirements

- Python 3.9+
- Portkey AI 0.1.0+

## License

Apache License 2.0
gradlens 0.2.0
An enterprise-grade PyTorch monitoring and analytics toolkit.
Requires Python: >=3.8

# 🔥 GradLens

[![CI](https://github.com/gradlens/gradlens/actions/workflows/ci.yml/badge.svg)](https://github.com/gradlens/gradlens/actions/workflows/ci.yml)
[![PyPI version](https://badge.fury.io/py/gradlens.svg)](https://badge.fury.io/py/gradlens)


An enterprise-grade **PyTorch monitoring and analytics toolkit.**

---

## 🚀 Quick Start (v0.1)

`gradlens` provides a lightweight, zero-overhead monitoring engine for your PyTorch training loops.

---

### Installation

```bash
pip install gradlens
```

---

### Usage

Use the `gl.watch()` context manager to automatically attach hooks to your model. The `monitor.log()` method captures statistics with near-zero performance impact.

```python
import torch
import torch.nn as nn
import gradlens as gl  # Import the library

# 1. Define your model and data (example)
model = nn.Sequential(nn.Linear(10, 20), nn.ReLU(), nn.Linear(20, 1))
data = torch.randn(16, 10)
target = torch.randn(16, 1)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
criterion = nn.MSELoss()

# 2. Wrap your training loop with gl.watch()
try:
    with gl.watch(model) as monitor:
        for _ in range(10):  # Example training loop

            # --- Training Step ---
            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()  # Hooks capture data here
            optimizer.step()

            # 3. Log the loss
            monitor.log(loss=loss.item())

except Exception as e:
    print(f"Training failed: {e}")

finally:
    # 4. Get the results
    history = monitor.get_history()

    print("\n--- Training History ---")
    print(f"Total steps: {len(history['loss'])}")
    print(f"Final loss: {history['loss'][-1]}")

    # Show stats for the last step
    last_stats = monitor.get_stats()
    print("\n--- Last Step Stats ---")
    print(f"Gradient Norms: {last_stats['grad_norm']}")
    print(f"Dead Neuron %: {last_stats['dead_neuron_pct']}")
```