Whisper Tiny

🚀 Whisper

Whisperは、自動音声認識（ASR）と音声翻訳のための事前学習済みモデルです。68万時間のラベル付きデータで学習されたWhisperモデルは、微調整を必要とせずに、多くのデータセットやドメインに対して強力な汎化能力を示します。

Whisperは、OpenAIのAlec Radfordらによる論文 Robust Speech Recognition via Large-Scale Weak Supervision で提案されました。元のコードリポジトリは こちら で確認できます。

免責事項：このモデルカードの内容は、一部がHugging Faceチームによって作成され、一部は元のモデルカードからコピー＆ペーストされています。

🚀 クイックスタート

このセクションでは、Whisperモデルの概要や基本的な使い方を紹介します。

✨ 主な機能

• 多言語対応：英語のみならず、多くの言語に対応した音声認識と音声翻訳が可能です。
• 強力な汎化能力：68万時間のラベル付きデータで学習され、微調整なしで多くのデータセットやドメインに適用できます。
• 柔軟な出力制御：コンテキストトークンを使用して、出力言語やタスクを制御できます。

📦 インストール

このREADMEには具体的なインストール手順が記載されていないため、このセクションは省略します。

💻 使用例

基本的な使用法

音声サンプルを文字起こしするには、モデルを WhisperProcessor と一緒に使用する必要があります。

# load model and processor
from transformers import WhisperProcessor, WhisperForConditionalGeneration
from datasets import load_dataset

processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")
model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny")
model.config.forced_decoder_ids = None

# load dummy dataset and read audio files
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
sample = ds[0]["audio"]
input_features = processor(sample["array"], sampling_rate=sample["sampling_rate"], return_tensors="pt").input_features 

# generate token ids
predicted_ids = model.generate(input_features)
# decode token ids to text
transcription = processor.batch_decode(predicted_ids, skip_special_tokens=False)
print(transcription)
transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
print(transcription)

高度な使用法

英語から英語の文字起こし

from transformers import WhisperProcessor, WhisperForConditionalGeneration
from datasets import load_dataset

# load model and processor
processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")
model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny")
model.config.forced_decoder_ids = None

# load dummy dataset and read audio files
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
sample = ds[0]["audio"]
input_features = processor(sample["array"], sampling_rate=sample["sampling_rate"], return_tensors="pt").input_features 

# generate token ids
predicted_ids = model.generate(input_features)
# decode token ids to text
transcription = processor.batch_decode(predicted_ids, skip_special_tokens=False)
print(transcription)
transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
print(transcription)

フランス語からフランス語の文字起こし

from transformers import WhisperProcessor, WhisperForConditionalGeneration
from datasets import Audio, load_dataset

# load model and processor
processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")
model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny")
forced_decoder_ids = processor.get_decoder_prompt_ids(language="french", task="transcribe")

# load streaming dataset and read first audio sample
ds = load_dataset("common_voice", "fr", split="test", streaming=True)
ds = ds.cast_column("audio", Audio(sampling_rate=16_000))
input_speech = next(iter(ds))["audio"]
input_features = processor(input_speech["array"], sampling_rate=input_speech["sampling_rate"], return_tensors="pt").input_features

# generate token ids
predicted_ids = model.generate(input_features, forced_decoder_ids=forced_decoder_ids)
# decode token ids to text
transcription = processor.batch_decode(predicted_ids)
print(transcription)
transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
print(transcription)

フランス語から英語の翻訳

from transformers import WhisperProcessor, WhisperForConditionalGeneration
from datasets import Audio, load_dataset

# load model and processor
processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")
model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny")
forced_decoder_ids = processor.get_decoder_prompt_ids(language="french", task="translate")

# load streaming dataset and read first audio sample
ds = load_dataset("common_voice", "fr", split="test", streaming=True)
ds = ds.cast_column("audio", Audio(sampling_rate=16_000))
input_speech = next(iter(ds))["audio"]
input_features = processor(input_speech["array"], sampling_rate=input_speech["sampling_rate"], return_tensors="pt").input_features

# generate token ids
predicted_ids = model.generate(input_features, forced_decoder_ids=forced_decoder_ids)
# decode token ids to text
transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
print(transcription)

評価

from datasets import load_dataset
from transformers import WhisperForConditionalGeneration, WhisperProcessor
import torch
from evaluate import load

librispeech_test_clean = load_dataset("librispeech_asr", "clean", split="test")

processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")
model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny").to("cuda")

def map_to_pred(batch):
    audio = batch["audio"]
    input_features = processor(audio["array"], sampling_rate=audio["sampling_rate"], return_tensors="pt").input_features
    batch["reference"] = processor.tokenizer._normalize(batch['text'])
    
    with torch.no_grad():
        predicted_ids = model.generate(input_features.to("cuda"))[0]
    transcription = processor.decode(predicted_ids)
    batch["prediction"] = processor.tokenizer._normalize(transcription)
    return batch

result = librispeech_test_clean.map(map_to_pred)

wer = load("wer")
print(100 * wer.compute(references=result["reference"], predictions=result["prediction"]))

長時間音声の文字起こし

import torch
from transformers import pipeline
from datasets import load_dataset

device = "cuda:0" if torch.cuda.is_available() else "cpu"

pipe = pipeline(
  "automatic-speech-recognition",
  model="openai/whisper-tiny",
  chunk_length_s=30,
  device=device,
)

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
sample = ds[0]["audio"]

prediction = pipe(sample.copy(), batch_size=8)["text"]
print(prediction)

# we can also return timestamps for the predictions
prediction = pipe(sample.copy(), batch_size=8, return_timestamps=True)["chunks"]
print(prediction)

📚 ドキュメント

モデルの詳細

Whisperは、Transformerベースのエンコーダ・デコーダモデルで、シーケンス-to-シーケンス モデルとも呼ばれます。大規模な弱教師付き学習を用いて注釈付けされた68万時間のラベル付き音声データで学習されました。

モデルは、英語のみのデータまたは多言語データで学習されています。英語のみのモデルは音声認識タスクで学習され、多言語モデルは音声認識と音声翻訳の両方で学習されています。音声認識の場合、モデルは音声と同じ言語の文字起こしを予測します。音声翻訳の場合、モデルは音声と異なる言語の文字起こしを予測します。

Whisperのチェックポイントは、モデルサイズが異なる5つの設定で提供されています。最小の4つは、英語のみまたは多言語データで学習されています。最大のチェックポイントは多言語のみです。10個の事前学習済みチェックポイントはすべて、Hugging Face Hub で利用可能です。チェックポイントは以下の表にまとめられており、Hub上のモデルへのリンクも含まれています。

コンテキストトークン

コンテキストトークンは、モデルに実行するタスク（文字起こしまたは翻訳）を通知するために使用されます。これらのコンテキストトークンは、デコードプロセスの開始時にデコーダに与えられるトークンのシーケンスで、以下の順序を持ちます。

1. 文字起こしは常に <|startoftranscript|> トークンから始まります。
2. 2番目のトークンは言語トークンです（例：英語の場合は <|en|>）。
3. 3番目のトークンは「タスクトークン」です。<|transcribe|>（音声認識）または <|translate|>（音声翻訳）の2つの値のいずれかを取ります。
4. さらに、モデルがタイムスタンプ予測を含めない場合には、<|notimestamps|> トークンが追加されます。

したがって、典型的なコンテキストトークンのシーケンスは以下のようになります。

<|startoftranscript|> <|en|> <|transcribe|> <|notimestamps|>

これは、モデルに英語で音声認識タスクを実行し、タイムスタンプを予測しないように指示します。

これらのトークンは、強制または非強制のいずれかに設定できます。強制された場合、モデルは各位置で各トークンを予測するようにされます。これにより、Whisperモデルの出力言語とタスクを制御することができます。非強制の場合、Whisperモデルは自動的に出力言語とタスクを予測します。

コンテキストトークンは以下のように設定できます。

model.config.forced_decoder_ids = WhisperProcessor.get_decoder_prompt_ids(language="english", task="transcribe")

これにより、モデルは音声認識タスクで英語を予測するように強制されます。

🔧 技術詳細

このセクションでは、Whisperモデルの技術的な詳細について説明します。

モデルアーキテクチャ

Whisperは、Transformerベースのエンコーダ・デコーダモデルです。エンコーダは入力音声を特徴ベクトルに変換し、デコーダはこの特徴ベクトルを使用して文字起こしまたは翻訳を生成します。

学習データ

モデルは、68万時間のラベル付き音声データで学習されました。これらのデータは、大規模な弱教師付き学習を用いて注釈付けされています。

評価指標

モデルの評価には、単語誤り率（WER）が使用されます。WERは、予測された文字起こしと正解の文字起こしとの間の誤り率を測定します。

📄 ライセンス

このモデルは、Apache 2.0ライセンスの下で提供されています。