Communitygithub.com

ComeOnOliver/skillshub

Transcrivez de l'audio avec Whisper d'OpenAI — le modèle de reconnaissance vocale de pointe. Ce skill couvre Whisper local (Python), faster-whisper (CTranslate2, 4x plus rapide), whisper.cpp (C++ optimisé CPU) et l'API OpenAI Whisper. Inclut la génération de sous-titres (SRT/VTT/JSON), la transcription multilingue, la traduction vers l'anglais, la diarisation des locuteurs, les horodatages au niveau du mot et des modèles de pipeline de production pour podcasts, réunions et sous-titres vidéo.

Qu'est-ce que skillshub ?

Ce skill permet de transcrire des fichiers audio en utilisant Whisper d'OpenAI, le modèle de reconnaissance vocale le plus avancé. Il supporte plusieurs runtimes : Whisper original (Python), faster-whisper (recommandé pour le local, 4x plus rapide grâce à CTranslate2), whisper.cpp (optimisé pour le CPU avec des dépendances minimales) et l'API OpenAI Whisper (nécessite une clé API). Les fonctionnalités incluent la transcription avec détection automatique de la langue (99 langues), la traduction en anglais, la génération de sous-titres aux formats SRT et VTT avec horodatages au niveau du mot, ainsi que la diarisation des locuteurs en combinant Whisper avec pyannote-audio pour identifier qui parle et quand. Le skill fournit des exemples concrets pour traiter des podcasts, des réunions ou des vidéos, avec un guide de sélection de modèle en fonction du matériel (CPU vs GPU) et des recommandations pour optimiser la précision et la vitesse. Les développeurs peuvent ainsi construire des pipelines de production automatisés pour la transcription et le sous-titrage.

Compatible avec~Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/TerminalSkills/skills/whisper

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Whisper

Présentation

Transcrivez de l'audio avec Whisper d'OpenAI — le modèle de reconnaissance vocale de pointe. Ce skill couvre Whisper local (Python), faster-whisper (CTranslate2, 4x plus rapide), whisper.cpp (C++ optimisé CPU) et l'API OpenAI Whisper. Inclut la génération de sous-titres (SRT/VTT/JSON), la transcription multilingue, la traduction vers l'anglais, la diarisation des locuteurs, les horodatages au niveau du mot et des modèles de pipeline de production pour podcasts, réunions et sous-titres vidéo.

Instructions

Étape 1 : Choisissez votre environnement d'exécution

Option A — OpenAI Whisper (Python original) :

pip install openai-whisper
# Modèles : tiny (39M), base (74M), small (244M), medium (769M), large-v3 (1,5G)

Option B — faster-whisper (recommandé pour le local, 4x plus rapide) :

pip install faster-whisper
# Utilise CTranslate2 — quantification INT8, fonctionne bien sur CPU

Option C — whisper.cpp (meilleur pour CPU, dépendances minimales) :

git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp && make
# Télécharger le modèle
bash models/download-ggml-model.sh base.en

Option D — API OpenAI (aucun GPU local nécessaire) :

pip install openai
export OPENAI_API_KEY="sk-..."

Étape 2 : Transcription de base

faster-whisper (recommandé) :

from faster_whisper import WhisperModel

model = WhisperModel("base", device="cpu", compute_type="int8")
# GPU : model = WhisperModel("large-v3", device="cuda", compute_type="float16")

segments, info = model.transcribe("episode.mp3", beam_size=5)
print(f"Langue : {info.language} (probabilité : {info.language_probability:.2f})")

for segment in segments:
    print(f"[{segment.start:.2f}s → {segment.end:.2f}s] {segment.text}")

OpenAI Whisper (original) :

import whisper

model = whisper.load_model("base")  # tiny, base, small, medium, large-v3
result = model.transcribe("episode.mp3")

print(result["text"])
for segment in result["segments"]:
    print(f"[{segment['start']:.1f}s - {segment['end']:.1f}s] {segment['text']}")

whisper.cpp (CLI) :

./main -m models/ggml-base.en.bin -f episode.wav -otxt -osrt -ovtt
# Produit : episode.txt, episode.srt, episode.vtt

API OpenAI :

from openai import OpenAI
client = OpenAI()

with open("episode.mp3", "rb") as f:
    transcript = client.audio.transcriptions.create(
        model="whisper-1",
        file=f,
        response_format="verbose_json",
        timestamp_granularities=["segment", "word"],
    )

print(transcript.text)
for segment in transcript.segments:
    print(f"[{segment.start:.1f}s] {segment.text}")

Étape 3 : Génération de sous-titres (SRT/VTT)

Générer un SRT avec faster-whisper :

from faster_whisper import WhisperModel

model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe("episode.mp3", beam_size=5)

def format_timestamp(seconds):
    h = int(seconds // 3600)
    m = int((seconds % 3600) // 60)
    s = int(seconds % 60)
    ms = int((seconds % 1) * 1000)
    return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"

with open("episode.srt", "w") as f:
    for i, seg in enumerate(segments, 1):
        f.write(f"{i}\n")
        f.write(f"{format_timestamp(seg.start)} --> {format_timestamp(seg.end)}\n")
        f.write(f"{seg.text.strip()}\n\n")

print("Fichier episode.srt généré")

Générer un VTT (pour vidéo HTML5) :

with open("episode.vtt", "w") as f:
    f.write("WEBVTT\n\n")
    for i, seg in enumerate(segments, 1):
        start = format_timestamp(seg.start).replace(",", ".")
        end = format_timestamp(seg.end).replace(",", ".")
        f.write(f"{start} --> {end}\n")
        f.write(f"{seg.text.strip()}\n\n")

Horodatages au niveau du mot (pour sous-titres style karaoké) :

segments, info = model.transcribe("episode.mp3", word_timestamps=True)
for segment in segments:
    for word in segment.words:
        print(f"  [{word.start:.2f}s → {word.end:.2f}s] {word.word}")

Étape 4 : Détection de langue et traduction

# Détection automatique de la langue
segments, info = model.transcribe("foreign_audio.mp3")
print(f"Langue détectée : {info.language} ({info.language_probability:.0%})")

# Forcer une langue spécifique
segments, info = model.transcribe("german.mp3", language="de")

# Traduire en anglais (toute langue → anglais)
segments, info = model.transcribe("german.mp3", task="translate")
for seg in segments:
    print(seg.text)  # Traduction en anglais

Langues supportées : 99 langues dont en, zh, de, es, ru, ko, fr, ja, pt, tr, pl, nl, ar, sv, it, hi, et bien d'autres.

Étape 5 : Diarisation des locuteurs

Combinez Whisper avec pyannote-audio pour identifier « qui a dit quoi » :

from faster_whisper import WhisperModel
from pyannote.audio import Pipeline
import torch

# Transcrire
model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe("meeting.wav", beam_size=5)
whisper_segments = list(segments)

# Diariser (nécessite un token HuggingFace avec accès à pyannote)
diarization = Pipeline.from_pretrained(
    "pyannote/speaker-diarization-3.1",
    use_auth_token="hf_VOTRE_TOKEN"
)
diarization_result = diarization("meeting.wav")

# Fusionner : assigner un locuteur à chaque segment Whisper
def get_speaker(start, end, diarization_result):
    """Trouve le locuteur dominant pendant une plage temporelle."""
    speakers = {}
    for turn, _, speaker in diarization_result.itertracks(yield_label=True):
        overlap_start = max(start, turn.start)
        overlap_end = min(end, turn.end)
        if overlap_start < overlap_end:
            duration = overlap_end - overlap_start
            speakers[speaker] = speakers.get(speaker, 0) + duration
    return max(speakers, key=speakers.get) if speakers else "Inconnu"

for seg in whisper_segments:
    speaker = get_speaker(seg.start, seg.end, diarization_result)
    print(f"[{speaker}] [{seg.start:.1f}s → {seg.end:.1f}s] {seg.text}")

Étape 6 : Traitement par lots et pipelines

Transcrire tous les épisodes d'un répertoire :

import os
from pathlib import Path
from faster_whisper import WhisperModel

model = WhisperModel("small", device="cpu", compute_type="int8")
episodes_dir = Path("episodes")
output_dir = Path("transcriptions")
output_dir.mkdir(exist_ok=True)

for audio_file in sorted(episodes_dir.glob("*.mp3")):
    print(f"Transcription en cours : {audio_file.name}")
    segments, info = model.transcribe(str(audio_file), beam_size=5)
    
    # Texte brut
    txt_path = output_dir / f"{audio_file.stem}.txt"
    with open(txt_path, "w") as f:
        for seg in segments:
            f.write(seg.text.strip() + "\n")
    
    # SRT
    srt_path = output_dir / f"{audio_file.stem}.srt"
    segments2, _ = model.transcribe(str(audio_file), beam_size=5)  # Ré-itérer
    with open(srt_path, "w") as f:
        for i, seg in enumerate(segments2, 1):
            h, m = divmod(int(seg.start), 3600)
            m, s = divmod(m, 60)
            ms = int((seg.start % 1) * 1000)
            start_ts = f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
            h2, m2 = divmod(int(seg.end), 3600)
            m2, s2 = divmod(m2, 60)
            ms2 = int((seg.end % 1) * 1000)
            end_ts = f"{h2:02d}:{m2:02d}:{s2:02d},{ms2:03d}"
            f.write(f"{i}\n{start_ts} --> {end_ts}\n{seg.text.strip()}\n\n")
    
    print(f"  → {txt_path}, {srt_path}")

Étape 7 : Guide de sélection du modèle

ModèleTailleVRAMVitesse (CPU)PrécisionIdéal pour
tiny39M~1 GoTrès rapideFaibleBrouillons rapides, temps réel
base74M~1 GoRapideMoyenneBon équilibre pour CPU
small244M~2 GoModéréeBonnePodcasts, audio clair
medium769M~5 GoLenteTrès bonneAudio bruité, accents
large-v31,5 Go~10 GoTrès lenteExcellenteQualité production

Recommandations :

  • CPU uniquement, la vitesse compte : tiny ou base avec faster-whisper
  • CPU uniquement, la précision compte : small avec faster-whisper
  • GPU disponible : large-v3 avec faster-whisper (float16)
  • Aucun calcul local : API OpenAI (whisper-1)

Exemples

Exemple 1 : Transcrire une saison de podcast et générer des sous-titres SRT

Invite utilisateur : « Transcrivez les 20 épisodes MP3 dans ./episodes/ et générez à la fois des transcriptions en texte brut et des fichiers de sous-titres SRT. J'ai un GPU avec 10 Go de VRAM. »

L'agent va :

  1. Installer faster-whisper via pip install faster-whisper.
  2. Charger le modèle large-v3 avec device="cuda" et compute_type="float16" pour exploiter le GPU.
  3. Créer un répertoire de sortie ./transcriptions/.
  4. Parcourir tous les fichiers .mp3 dans ./episodes/, en transcrivant chacun avec beam_size=5.
  5. Écrire à la fois un fichier .txt (texte brut) et un fichier .srt (avec horodatages correctement formatés) pour chaque épisode.
  6. Signaler la langue détectée et le temps de traitement total par épisode.

Exemple 2 : Traduire un entretien allemand en anglais avec étiquettes de locuteurs

Invite utilisateur : « J'ai un enregistrement d'entretien en allemand de 45 minutes dans meeting.wav avec deux locuteurs. Transcrivez-le en anglais et étiquetez qui a dit quoi. »

L'agent va :

  1. Installer faster-whisper et pyannote-audio (pip install faster-whisper pyannote.audio).
  2. Transcrire meeting.wav avec task="translate" pour obtenir le texte anglais à partir de l'audio allemand.
  3. Exécuter la diarisation des locuteurs pyannote pour identifier les segments de locuteurs (nécessite un token HuggingFace avec accès au modèle pyannote).
  4. Fusionner les segments Whisper avec les résultats de diarisation en faisant correspondre les plages temporelles pour attribuer des étiquettes de locuteurs.
  5. Produire une transcription formatée avec les étiquettes [Locuteur 1] et [Locuteur 2] avant chaque segment.

Directives

  • Utilisez faster-whisper plutôt que l'original OpenAI Whisper pour la transcription locale ; il est 4x plus rapide et utilise moins de mémoire grâce à la quantification INT8 via CTranslate2.
  • Choisissez la taille du modèle en fonction de votre matériel : tiny/base pour la vitesse sur CPU, small pour la précision sur CPU, large-v3 pour la qualité production sur GPU.
  • Convertissez toujours l'audio en WAV ou assurez-vous que ffmpeg est installé lorsque vous travaillez avec des entrées MP3/M4A ; Whisper dépend de ffmpeg pour le décodage des formats autres que WAV.
  • Pour la diarisation des locuteurs, le pipeline pyannote nécessite un jeton d'accès HuggingFace avec les conditions d'utilisation du modèle acceptées ; configurez-le avant de tenter une transcription multi-locuteurs.
  • Lors de la génération de fichiers SRT, utilisez beam_size=5 pour des limites de segments plus précises ; le décodage glouton par défaut peut produire des coupures de sous-titres mal synchronisées.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Skills associés