SSD Nodes Learn Hosting plans →
מדריכים Matt Connorמאת Matt Connor

אירוח עצמי של Whisper ו-Piper על שרת VPS

למדו כיצד להריץ תמלול Whisper וסינתזת קול בעזרת Piper על שרת VPS ללא GPU. המדריך מפרט צריכת משאבים, נפח אחסון נדרש והקמת שרת תואם OpenAI API לשימוש ביישומי צד שלישי.

אירוח עצמי של המרת דיבור לטקסט וטקסט לדיבור, בקצרה

אירוח עצמי של המרת דיבור לטקסט (STT) וטקסט לדיבור (TTS) מתבצע על שרת שבבעלותך. תמלול מתבצע באמצעות Whisper על גבי סביבת הריצה faster-whisper. סינתזה מתבצעת באמצעות Piper. שניהם עובדים על שרת VPS מבוסס CPU רגיל, ללא צורך ב־GPU כלל. המודל הקטן של Whisper דורש כ-484 MB שטח דיסק, וקול של Piper מורכב משני קבצים: מודל ONNX וקובץ תצורה קטן בפורמט JSON, שמשקלם הכולל נמוך מ-150 MB.

זו הסיבה לכך שתחום האודיו הוא נקודת התחלה טובה. מחולל תמונות באירוח עצמי ויצירת וידאו באירוח עצמי דורשים שניהם GPU כדי להיות שמישים בכלל. אודיו אינו דורש זאת.

מדריך זה מכסה את שני הכיוונים ואת השכבה המקשרת ביניהם. Whisper הופך אודיו לטקסט. Piper הופך טקסט לאודיו. שרת HTTP התואם ל-OpenAI שיוצב לפני שניהם יאפשר ללקוח קיים להפנות בקשות לשרת שלך ללא כל שינוי, מלבד כתובת ה-base URL.

כל גרסה שצוינה בפקודות כאן נבדקה מול דף ה-releases של הפרויקט הרלוונטי ב-11 באוקטובר 2026. גרסאות CTranslate2 המוזכרות תחת מצבי כשל הן סמני תאימות, ולא גרסאות עדכניות.

מדוע להשתמש ב-faster-whisper ולא בחבילת ה-Whisper הרשמית

החבילה whisper של OpenAI מריצה את המודל ב-PyTorch. לעומתה, faster-whisper מריצה את אותם משקלי מודל על גבי CTranslate2, מנוע הסקה (inference) שנכתב במיוחד עבור מודלי transformer. המודל זהה, אך הגדרות הקוונטיזציה (quantization) והפענוח משפיעות על התמלול. סביבת הריצה היא הגורם להבדלי המהירות המפורטים להלן.

CTranslate2 מבצע קוונטיזציה למשקלים בזמן הטעינה, וזו הסיבה ש-compute_type="int8" הוא ארגומנט יחיד ולא שלב המרה נפרד. כמו כן, אין לו תלות ב-PyTorch. החבילה pip install faster-whisper מושכת את CTranslate2, טוקנייזר (tokenizer) ו-PyAV לפענוח אודיו, כך שהסביבה הווירטואלית תופסת מאות מגה-בייטים במקום מספר גיגה-בייטים. בשרת VPS עם דיסק של 40 GB, פער זה הוא ההבדל בין עבודה נוחה לבין מחסור במקום.

להלן הנתונים הרשמיים של הפרויקט עבור המודל small על גבי CPU. המבחן מתמלל 13 דקות של אודיו תוך שימוש ב-8 תהליכונים (threads) על מעבד Intel Core i7-12700K. העמודה x_realtime מייצגת את אותן 13 דקות חלקי הזמן שנמדד: 7.6 משמעו הקלטה של 13 דקות שהסתיימה תוך קצת יותר מדקה ו-40 שניות.

תרשיםWhisper small on CPU, 13 minutes of audio (published project figures)
הנתונים שמאחורי התרשים
[
  {
    "label": "openai/whisper, fp32",
    "x_realtime": 1.9,
    "seconds": 418,
    "memory_mb": "2,335"
  },
  {
    "label": "whisper.cpp, fp32",
    "x_realtime": 6.2,
    "seconds": 125,
    "memory_mb": "1,049"
  },
  {
    "label": "faster-whisper, fp32",
    "x_realtime": 5.0,
    "seconds": 157,
    "memory_mb": "2,257"
  },
  {
    "label": "faster-whisper, int8",
    "x_realtime": 7.6,
    "seconds": 102,
    "memory_mb": "1,477"
  },
  {
    "label": "faster-whisper, int8, batch 8",
    "x_realtime": 15.3,
    "seconds": 51,
    "memory_mb": "3,608"
  }
]

קראו את השורה השנייה בעיון. ב-fp32, הביצועים של whisper.cpp מהירים יותר מאשר faster-whisper על מעבד זה, 6.2x לעומת 5.0x, והוא עושה זאת בפחות מחצי מכמות הזיכרון. זוהי אותה משפחת ggml שנמצאת מאחורי צד ה-llama.cpp של מחסנית ה-LLM המקומית. faster-whisper עוקף אותו ברגע ש-int8 ועיבוד באצ'ים (batching) מופעלים, ומגיע ל-15.3x, תוך צריכת 3,608 MB של RAM. לסיכום: בחרו ב-faster-whisper עבור ה-API של Python והיכולת לעבד באצ'ים, ובחרו ב-whisper.cpp כאשר ה-RAM הוא המגבלה שאינכם יכולים לעקוף.

השורה הראשונה היא הנקודה המרכזית בסעיף זה. החבילה הרשמית מגיעה ל-1.9x מהזמן האמיתי על אותה מכונה, מה שאומר ששעת אודיו דורשת חצי שעה של זמן מעבד.

כמה שטח דיסק דורשים משקלי המודל Whisper?

תרשיםfaster-whisper model weights on disk (Systran CTranslate2 conversions, float16)
הנתונים שמאחורי התרשים
[
  {
    "label": "tiny",
    "weights_mb": 75.5
  },
  {
    "label": "base",
    "weights_mb": 145
  },
  {
    "label": "small",
    "weights_mb": 484
  },
  {
    "label": "medium",
    "weights_mb": "1,530"
  },
  {
    "label": "large-v3",
    "weights_mb": "3,090"
  }
]

אלו הם המודלים שעברו המרה ל-CTranslate2, בפורמט float16. שימו לב למה ש-compute_type="int8" אינו עושה: הוא אינו מקטין את נפח ההורדה. המשקלים מגיעים בפורמט float16, ו-CTranslate2 מבצע להם קוונטיזציה בזיכרון בזמן הטעינה. לכן, large-v3 תופס 3,090 MB על הדיסק, ללא קשר לשאלה אם אתם מריצים אותו ב-float16 או ב-int8. שימוש ב-int8 חוסך RAM ומשפר מהירות, אך לא חוסך מקום בדיסק.

המודלים יורדים בשימוש הראשון לתוך ~/.cache/huggingface/hub. בשרת VPS עם מחיצת root קטנה, הפנו את הנתיב למקום עם מספיק שטח פנוי באמצעות הארגומנט download_root או משתנה הסביבה HF_HOME. אחרת, ההרצה הראשונה תמלא את הדיסק והתהליך יקרוס במהלך ההורדה.

התקנת faster-whisper מבלי לפגוע ב־Python של המערכת

הפצות Ubuntu 24.04 ו־Debian 13 מגדירות את ה־Python של המערכת כ"מנוהל חיצונית" (externally managed). הרצה של pip install faster-whisper מחוץ לסביבה וירטואלית תיעצר מיד עם השגיאה הבאה:

error: externally-managed-environment

מערכת ניהול החבילות עושה זאת כדי להגן על קבצים שנמצאים בבעלות apt. השתמשו בסביבה וירטואלית.

sudo apt update
sudo apt install -y python3-venv ffmpeg
python3 -m venv ~/stt
~/stt/bin/pip install --upgrade pip
~/stt/bin/pip install faster-whisper==1.2.1

גרסה 1.2.1 היא המהדורה הנוכחית, שפורסמה באוקטובר 2025. הספרייה faster-whisper מפענחת אודיו באמצעות PyAV, אשר כוללת בתוכה ספריות ffmpeg משלה, ולכן היא קוראת קובצי mp3 או m4a ללא צורך בבינארי ffmpeg נפרד. חבילת ה-ffmpeg לעיל מיועדת לעבודה עם וידאו בהמשך מדריך זה.

בדקו את ההתקנה לפני הורדת שלושה גיגה-בייט של משקולות (weights):

~/stt/bin/python -c "from faster_whisper import WhisperModel; print('ok')"

שורה המציגה ok מעידה על כך שהחבילות הותקנו בהצלחה. שגיאת ImportError המציינת את ctranslate2 משמעותה שסביבת הריצה חסרה או שהספרייה המקומית שלה לא נטענה; שאר ההודעה תפרט את הסיבה. בתמונות מערכת (images) של 32-bit ARM לא קיימת חבילת CTranslate2 כלל, ולכן pip ייכשל כבר בזמן ההתקנה.

תמלול הקלטת פגישה או הערה קולית

שמרו זאת כ-transcribe.py:

from faster_whisper import WhisperModel

model = WhisperModel("small", device="cpu", compute_type="int8", cpu_threads=4)
segments, info = model.transcribe("meeting.m4a", beam_size=5, vad_filter=True)

print("language: %s (%.2f)" % (info.language, info.language_probability))
for segment in segments:
    print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))

הריצו זאת עם ~/stt/bin/python transcribe.py. ההרצה הראשונה מורידה את המשקולות (weights), לכן לא יודפס דבר במשך זמן מה. לאחר מכן, המודל ייטען מה-cache תוך שניות ספורות.

segments הוא מחולל (generator), לכן התמלול לא יתחיל עד שתבצעו איטרציה עליו. אנשים מודדים את זמן הקריאה ל-transcribe(), רואים שהיא חוזרת באופן מיידי, וחושבים שמשהו תקול. שום דבר אינו תקול. העבודה מתבצעת בתוך הלולאה.

vad_filter=True מריץ תחילה את Silero VAD (זיהוי פעילות קולית) ומסיר קטעים שקטים לפני ש-Whisper רואה אותם. בהקלטת פגישה עם הפסקות ארוכות, זהו השיפור המשמעותי ביותר במהירות שניתן להשיג, כיוון ש-Whisper לא מבזבז זמן כלל על אודיו שאינו מכיל דיבור. זה גם מונע לולאות של משפטים חוזרים ש-Whisper מייצר כאשר מוזנת אליו דממה והוא מנסה למצוא בה מילים.

הגדירו את cpu_threads למספר הליבות שיש לכם בפועל. הגדרה גבוהה ממספר ה-vCPU שלכם תאט את התמלול, כיוון שהת'רדים הנוספים יתחרו על אותה ליבה וה-scheduler ישלם מחיר על כל החלפת הקשר (context switch).

כתוביות עבור ספריית Jellyfin

Jellyfin קורא קובצי כתוביות חיצוניים הנמצאים לצד קובץ הווידאו ונושאים את אותו השם, כך ש-Movie (2019).en.srt לצד Movie (2019).mkv יופיע כרצועה באנגלית ללא צורך בבנייה מחדש של הספרייה. השאלה אם לקוח מסוים ינגן את הקובץ ישירות, או שהשרת יבצע remux או יטמיע (burn-in) את הכתוביות לתוך הווידאו, תלויה ביכולות התמיכה של אותו לקוח.

תחילה יש לחלץ את האודיו. Whisper מבצע דגימה מחדש (resample) פנימית לכל קובץ ל-16 kHz במונו, לכן הזנת קובץ בפורמט 16 kHz מונו חוסכת עבודה משני הצדדים:

ffmpeg -i "Movie (2019).mkv" -vn -ac 1 -ar 16000 -c:a pcm_s16le "Movie (2019).wav"

ל-faster-whisper אין כותב SRT מובנה, לכן יש לעצב את המקטעים באופן ידני. שמרו זאת כ-srt.py:

import sys
from faster_whisper import WhisperModel

def ts(seconds):
    ms = int(round(seconds * 1000))
    hours, ms = divmod(ms, 3600000)
    minutes, ms = divmod(ms, 60000)
    secs, ms = divmod(ms, 1000)
    return "%02d:%02d:%02d,%03d" % (hours, minutes, secs, ms)

model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe(sys.argv[1], vad_filter=True)

with open(sys.argv[2], "w", encoding="utf-8") as out:
    for index, segment in enumerate(segments, start=1):
        out.write("%d\n" % index)
        out.write("%s --> %s\n" % (ts(segment.start), ts(segment.end)))
        out.write("%s\n\n" % segment.text.strip())

לאחר מכן בצעו סריקה של הספרייה:

for f in /srv/media/films/*.mkv; do
  ffmpeg -nostdin -y -i "$f" -vn -ac 1 -ar 16000 -c:a pcm_s16le "${f%.mkv}.wav"
  nice -n 15 ~/stt/bin/python srt.py "${f%.mkv}.wav" "${f%.mkv}.en.srt"
  rm -f "${f%.mkv}.wav"
done

הדגל -nostdin משבית את האינטראקציה עם המקלדת ב-ffmpeg. הוא גם מונע מ-ffmpeg לצרוך שמות קבצים כאשר הוא רץ בתוך לולאה הקוראת אותם מהקלט הסטנדרטי (standard input). הלולאה מבוססת ה-glob לעיל אינה קוראת את רשימת הקבצים שלה מהקלט הסטנדרטי.

העריכו את הזמן הנדרש לפני תחילת התהליך. לפי נתון ה-7.6x לעיל, סרט באורך 100 דקות דורש בערך 13 דקות של זמן מעבד, כך שספרייה של חמישים סרטים היא משימה שתימשך לילה שלם. בתוכנית vCPU משותפת התהליך איטי יותר, וזהו בדיוק השימוש ב-nice: הרצת הכתוביות תפנה משאבים לכל פעולה אחרת שהשרת מבצע באותו זמן.

טקסט לדיבור באמצעות Piper

Piper הוא מנוע עצבי להמרת טקסט לדיבור המריץ מודל קול בפורמט ONNX על גבי ה-CPU. הוא כולל בתוכו את espeak-ng לצורך המרת טקסט לפונמות, כך שאין צורך בהתקנה של רכיב phonemizer נפרד. הגרסה הנוכחית היא 1.8.0, שפורסמה בספטמבר 2026.

python3 -m venv ~/tts
~/tts/bin/pip install piper-tts==1.8.0
~/tts/bin/python -m piper.download_voices en_US-lessac-medium
~/tts/bin/python -m piper -m en_US-lessac-medium -f test.wav -- 'This is a test.'

download_voices כותב שני קבצים לתיקיית העבודה: משקולות ה-.onnx וקובץ .onnx.json המכיל את קצב הדגימה ואת רשימת הדוברים. עליהם להישאר יחד. אם אתם שומרים קולות במיקום קבוע, העבירו את --data-dir לשתי הפקודות, שכן אחרת הנגן יחפש בתיקיית העבודה ולא ימצא את הקול אם הוא אינו שם.

גם ה--- לפני הטקסט חשוב. הוא מפריד בין הטקסט לבין אפשרויות שורת הפקודה, כולל אפשרויות שמשפט המתחיל במקף עלול להפעיל בטעות.

הקולות מופצים בכמה רמות איכות. קול אנגלי ברמה בינונית שוקל כ-60 MB, וקול ברמה גבוהה שוקל בערך כפול מכך. איכות גבוהה יותר משמעותה מודל גדול יותר וצריכת CPU גבוהה יותר לכל שניית דיבור, ולא דובר שונה.

אל תקראו ל-CLI בתוך לולאה. הוא טוען את המודל בכל הרצה, וטעינת המודל היא הפעולה היקרה ביותר עבור משפט קצר. במקום זאת, הריצו את שרת ה-HTTP:

~/tts/bin/pip install 'piper-tts[http]==1.8.0'
~/tts/bin/python -m piper.http_server -m en_US-lessac-medium --host 127.0.0.1 --port 5000
curl -X POST -H 'Content-Type: application/json' \
  -d '{ "text": "This is a test." }' \
  -o test.wav localhost:5000/synthesize

אם ה-test.wav שאתם מנגנים עובד, סימן שהמערכת תקינה. נקודת הקצה הזו היא במבנה הייחודי של Piper ולא של OpenAI, לכן לקוח שמצפה ל-/v1/audio/speech לא יתקשר איתה. הסעיף הבא פותר זאת.

השאירו את השירות רץ באמצעות קובץ unit במקום בטרמינל שייסגר. ה-unit מריץ את Piper כמשתמש piper ללא אפשרות התחברות, מתיקיית הבית של אותו משתמש, כך שהשירות אינו תלוי בחשבון שלכם. צרו את המשתמש והתקינו שם את Piper ואת הקול:

sudo useradd --system --create-home --home-dir /home/piper --shell /usr/sbin/nologin piper
sudo -u piper python3 -m venv /home/piper/tts
sudo -u piper /home/piper/tts/bin/pip install 'piper-tts[http]==1.8.0'
sudo -u piper /home/piper/tts/bin/python -m piper.download_voices --data-dir /home/piper/voices en_US-lessac-medium

עצרו את השרת שהפעלתם בטרמינל, ולאחר מכן כתבו את ה-unit:

[Unit]
Description=Piper text to speech HTTP server
After=network-online.target

[Service]
User=piper
ExecStart=/home/piper/tts/bin/python -m piper.http_server -m en_US-lessac-medium --data-dir /home/piper/voices --host 127.0.0.1 --port 5000
Restart=on-failure

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now piper מפעיל אותו ומחזיר אותו לפעולה לאחר אתחול. אם פקודת ה-curl לעיל לא מחזירה דבר, journalctl -u piper -n 50 יכיל את הסיבה, כאשר קובץ קול חסר הוא הסיבה הנפוצה ביותר.

מבנה השרת התואם ל-OpenAI

רוב התוכנות המטפלות באודיו כבר תומכות ב-API האודיו של OpenAI: בקשת multipart POST אל /v1/audio/transcriptions עבור קובץ, ובקשת JSON POST אל /v1/audio/speech עבור משפט. אם תגישו את שני הנתיבים הללו בעצמכם, הלקוח יזדקק לשינוי אחד בלבד: כתובת ה-base URL שלו.

Speaches הוא שרת אחד המבצע את שני הכיוונים. הוא מריץ את faster-whisper עבור תמלול ואת Piper או Kokoro עבור דיבור, מאחורי נתיבי ה-OpenAI. הגרסה הנוכחית היא v0.9.0-rc.3 מדצמבר 2025, שטרם הגיעה ל-1.0, לכן קבעו (pin) את תגית ה-image שלכם וקראו את הערות השחרור לפני שדרוג.

curl --silent --remote-name https://raw.githubusercontent.com/speaches-ai/speaches/master/compose.yaml
curl --silent --remote-name https://raw.githubusercontent.com/speaches-ai/speaches/master/compose.cpu.yaml
export COMPOSE_FILE=compose.cpu.yaml
docker compose up --detach

הצורה של מכולה בודדת, אם אינכם מעוניינים לשמור קובצי compose:

docker run --rm --detach --publish 8000:8000 --name speaches \
  --volume hf-hub-cache:/home/ubuntu/.cache/huggingface/hub \
  ghcr.io/speaches-ai/speaches:latest-cpu

ה-named volume הוא החלק שאנשים נוטים לשכוח. בלעדיו, מטמון המודלים נמצא בתוך המכולה, כך שהסרה ויצירה מחדש של המכולה יגרמו לאובדן המשקולות שהורדו. הפעלה מחדש של אותה מכולה שומרת עליהם.

Speech זקוק לקול שהורד לפני ש-/v1/audio/speech ישיב:

uvx speaches-cli model download speaches-ai/Kokoro-82M-v1.0-ONNX

לאחר מכן, כל לקוח OpenAI יעבוד עם שינוי ה-base URL:

from pathlib import Path
from openai import OpenAI

openai = OpenAI(base_url="http://localhost:8000/v1", api_key="cant-be-empty")
res = openai.audio.speech.create(
    model="speaches-ai/Kokoro-82M-v1.0-ONNX",
    voice="af_heart",
    input="Hello, world!",
    response_format="mp3",
    speed=1,
)
with Path("output.mp3").open("wb") as f:
    f.write(res.response.read())

ממלא המקום api_key נדרש מכיוון שספריית הלקוח של OpenAI מסרבת לשלוח בקשה בלעדיו. השרת מתעלם מהערך שלו עד שתגדירו מפתח אמיתי.

vox-box הוא הפרויקט הנוסף שכדאי לציין כאן. זוהי חבילת Python ולא מכולה, והיא מגישה את אותם נתיבים מאחורי Whisper, FunASR, Bark, Dia או CosyVoice. גרסה 0.0.21 היא הנוכחית, מדצמבר 2025, והיא דורשת Python 3.10 ומעלה.

python3 -m venv ~/voice
~/voice/bin/pip install vox-box==0.0.21
~/voice/bin/vox-box start --huggingface-repo-id Systran/faster-whisper-small \
  --data-dir ~/voice/data --host 127.0.0.1 --port 8010

הדוגמה של הפרויקט עצמו מאזינה לפורט 80, מה שדורש הרשאות root או את ה-capability‏ CAP_NET_BIND_SERVICE. פורט גבוה מאחורי reverse proxy הוא המבנה העדיף בשרת שמבצע פעולות נוספות. vox-box start מקבל מודל אחד, לכן כיסוי של שני הכיוונים דורש מופע שני בפורט שני עם מזהה (id) של מאגר דיבור.

שאלו את השרת מה הוא טען, ולאחר מכן השתמשו במזהה זה בשדה model:

curl http://127.0.0.1:8010/v1/models
curl http://127.0.0.1:8010/v1/audio/transcriptions \
  -H "Content-Type: multipart/form-data" \
  -F file="@voice-note.m4a" \
  -F model="faster-whisper-small"

גוף JSON במבנה {"text": "..."} מעיד על כך שהנתיב כולו עובד. עבור שגיאת 404, קראו את גוף התגובה ובדקו את מזהה המודל מול /v1/models. Speaches מחזיר 404 גם עבור מודל תקין שאינו מותקן מקומית. אם השגיאה מציינת זאת, הורידו את המודל המבוקש באמצעות uvx speaches-cli model download MODEL_ID, ולאחר מכן נסו שוב. נתיב ההורדה שלו הוא POST /v1/models/{model_id}.

אף אחד מהשרתים הללו אינו מפעיל אימות כברירת מחדל. קשרו אותם ל-127.0.0.1 וגשו אליהם דרך VPN או reverse proxy הדורש אישורי גישה. /v1/audio/transcriptions פתוח בכתובת IP ציבורית הוא משאבי CPU בחינם לכל מי שימצא אותו, והם ימצאו אותו.

ממשק קולי עבור עוזר אישי באירוח עצמי

ברגע ששני הכיוונים מגיבים לנתיבי OpenAI, ניתן להפעיל אותם באמצעות ממשק צ'אט. Open WebUI וחלופותיה מקבלים בהגדרות שלהם כתובת בסיס (base URL) תואמת OpenAI עבור אודיו, כך ששרת אחד יכול להריץ LLM מקומי עם Ollama ולסגור את המעגל הקולי בשני הקצוות.

יש לתכנן את השיהוי (latency) בכנות, כיוון ששלושת השלבים הללו רצים בזה אחר זה על אותם ליבות מעבד. שאלה באורך 10 שניות דורשת כ-1.3 שניות לתמלול לפי נתון ה-7.6x לעיל, וזה עוד לפני שהמודל קרא טוקן אחד. הוסיפו לכך יצירת טוקנים ב-CPU, וזמן הלוך-חזור הופך לאיטי מספיק כדי שבודקים יניחו שהמערכת קרסה. תמלול באצווה (batch) עובד היטב על CPU. שיחה אינה עובדת היטב בתצורה זו, וזה השלב שבו שרת VPS עם GPU מתחיל להצדיק את מחירו.

מתי כדאי להשתמש ב-GPU?

תרשיםWhisper large-v2 on an RTX 3070 Ti, 13 minutes of audio (published project figures)
הנתונים שמאחורי התרשים
[
  {
    "label": "openai/whisper, fp16",
    "x_realtime": 5.5,
    "seconds": 143,
    "memory_mb": "4,708"
  },
  {
    "label": "faster-whisper, fp16",
    "x_realtime": 12.4,
    "seconds": 63,
    "memory_mb": "4,525"
  },
  {
    "label": "faster-whisper, int8",
    "x_realtime": 13.2,
    "seconds": 59,
    "memory_mb": "2,926"
  },
  {
    "label": "faster-whisper, int8, batch 8",
    "x_realtime": 48.8,
    "seconds": 16,
    "memory_mb": "4,500"
  }
]

על גבי ה-GPU, המודל הגדול בפורמט int8 רץ במהירות של 13.2x מהזמן האמיתי תוך שימוש ב-2,926 MB של VRAM, ושימוש ב-batching מעלה את המהירות ל-48.8x. שימו לב היטב למה ששני התרשימים אינם מציינים. הם מריצים מודלים שונים: שורות ה-GPU מתייחסות ל-large-v2, ושורות ה-CPU מתייחסות למודל small. ה-GPU לא הופך את המודל הקטן למהיר פי שישה; הוא הופך את המודל המדויק לשימושי.

מאיפה הגיעו הנתונים האלו

שני התרשימים משחזרים את ה-benchmark שפורסם ב-README של faster-whisper. האודיו הוא קובץ בודד באורך 13 דקות. שורות ה-CPU השתמשו ב-8 threads על מעבד Intel Core i7-12700K, ושורות ה-GPU השתמשו ב-CUDA 12.4 על כרטיס NVIDIA RTX 3070 Ti עם 8 GB של VRAM. עמודות השניות והזיכרון הן הנתונים שפורסמו. עמודת ה-x_realtime היא חישוב אריתמטי המבוסס עליהם: 780 שניות של אודיו חלקי זמן הביצוע שנמדד, מעוגל לספרה אחת אחרי הנקודה. עמודת הזיכרון מתייחסת ל-RAM של המערכת עבור תרשים ה-CPU ול-VRAM עבור תרשים ה-GPU.

תוכנית vCPU משותפת לא תגיע לביצועים של ה-CPU בנתונים אלו. ה-benchmark ההוא השתמש ב-8 threads של רכיב desktop מהיר שהוקצו לו בלבד. התייחסו ל-7.6x כאל תקרה, ומדדו את השרת שלכם עם time על הקלטה אמיתית לפני שאתם מתכננים משהו סביב זה.

ארבעה כללי אצבע שתקפים בפועל:

  • תמלול מזדמן של הקלטות אישיות: CPU, מודל small, פורמט int8. התחילו עם שני vCPU ייעודיים ומדדו את זמן התמלול.
  • עבודת batch לילית כמו יצירת כתוביות: CPU, מודל small או medium, פורמט int8, עטוף ב-nice.
  • כל פעולה אינטראקטיבית, או תמלול של ספרייה שלמה בערב אחד: GPU.
  • Piper: תמיד CPU. מודל קולי בגודל כזה כמעט אינו מרוויח דבר משימוש ב-GPU.

אם אתם מנסים להבין אילו משימות נוספות החומרה שלכם יכולה לשאת, השאלה הרחבה יותר לגבי אילו מודלי AI ניתן לארח באופן עצמי מכסה את הגדלים שמתאימים ושאינם מתאימים.

מצבי כשל והודעות שגיאה נפוצות

error: externally-managed-environment בעת ההתקנה. גרסת ה-Python של המערכת מוגנת על ידי ההפצה. צרו סביבה וירטואלית כפי שהוצג לעיל.

אי-התאמה של cuDNN בשרת GPU. השגיאה נראית כך:

Unable to load any of {libcudnn_ops.so.9.1.0, libcudnn_ops.so.9.1, libcudnn_ops.so.9, libcudnn_ops.so}
Invalid handle. Cannot load symbol cudnnCreateTensorDescriptor

החל מגרסה 4.5.0, CTranslate2 מעביר את גרסאות ה-CUDA 12 שלו ל-cuDNN 9, בעוד המארח משתמש ב-cuDNN 8. עליכם להתקין את cuDNN 9 או לקבע את סביבת הריצה הישנה באמצעות pip install --force-reinstall ctranslate2==4.4.0. בצעו רק אחת משתי הפעולות הללו. ביצוע של שתיהן יחזיר אתכם לנקודת ההתחלה.

This CTranslate2 package was not compiled with CUDA support היא שגיאה שונה עם מאפיינים דומים. גרסת CTranslate2 המותקנת אינה כוללת תמיכה ב-CUDA. חבילות ה-wheels הרשמיות ל-Linux ול-Windows תומכות בהרצה על גבי GPU; בדקו את הפלטפורמה ואת מקור החבילה, ולאחר מכן התקינו גרסה התומכת ב-CUDA. יצירה מחדש של אותה סביבה עם אותה חבילה מבוססת CPU בלבד לא תפתור את הבעיה.

חזרה על משפטים בתמלול. משפט שחוזר על עצמו עשר פעמים מעיד כמעט תמיד על כך ששקט או מוזיקה פוענחו בטעות כדיבור. הפעילו תחילה את vad_filter=True. אם הבעיה נמשכת, האזינו לקטע: אודיו שקט כמעט לחלוטין לא נותן ל-Whisper נקודת אחיזה, והוא חוזר על הניחוש האחרון שהיה בטוח לגביו.

זיהוי שפה שגוי. כברירת מחדל, faster-whisper מבצע ניחוש על סמך 30 השניות הראשונות בלבד. ערך info.language_probability הנמוך משמעותית מ-1.0 מעיד על חוסר ודאות, דבר שקורה כאשר הקלטה נפתחת במוזיקה או בדיבור חופף. העבירו את language="en" אם השפה ידועה לכם מראש, או הגדילו את language_detection_segments כדי שהמערכת תבחן חלונות זמן נוספים לפני קבלת החלטה.

התהליך מדפיס Killed ונעצר. בדקו את dmesg עבור שורת oom-kill תואמת כדי לוודא שה-kernel סיים את התהליך עקב מחסור בזיכרון. המודל large-v3 מוריד מעל 3 GB של משקולות float16, אך שימוש ב-int8 מפחית את צריכת הזיכרון בזמן הטעינה. ה-benchmark שפורסם עבור מודל קטן ב-int8 צורך 1,477 MB של RAM, לכן שרת VPS עם 2 GB זיכרון משאיר מעט מאוד מקום למערכת ההפעלה ולשירותים אחרים.

Piper אינו מוצא את הקול. הנגן מחפש בתיקיית העבודה אלא אם תעבירו את --data-dir. הריצו את ls בתיקייה הרצויה וודאו שגם .onnx וגם .onnx.json קיימים, שכן חוסר באחד מהם יוביל לכשל ודאי בדיוק כמו חוסר בשניהם.

FAQ

האם ניתן להריץ זיהוי דיבור (speech to text) על שרת VPS ללא GPU?

כן, ועבור עיבוד באצ'ים (batch) זו הבחירה ההגיונית. בשימוש ב-faster-whisper עם המודל small בפורמט int8, מדד הביצועים שפורסם עבור הפרויקט מתמלל 13 דקות של אודיו ב-102 שניות על 8 תהליכונים (threads) של מעבד i7 שולחני, במהירות של פי 7.6 מזמן אמת, תוך צריכת 1,477 MB של RAM. תוכנית VPS עם vCPU משותף תרוץ לאט יותר, לכן מומלץ לבצע מדידה על השרת הספציפי שלכם. יצירת דיבור מתוך טקסט (text to speech) באמצעות Piper היא פשוטה אף יותר ואינה דורשת GPU בשום מקרה.

באיזה גודל מודל Whisper כדאי להשתמש?

התחילו עם small בפורמט int8. הוא תופס 484 MB על הדיסק ומטפל היטב בדיבור מוקלט וברור. עברו למודל medium כאשר מבטאים או רעשי רקע גורמים לשגיאות שאינכם יכולים להשלים איתן, ועברו למודל large-v3 רק כאשר הדיוק חשוב יותר מכל דבר אחר, שכן הוא דורש 3,090 MB על הדיסק. צריכת ה-RAM שלו תלויה בסוג החישוב ובעומס העבודה, לכן מדדו אותה לפני בחירת גודל ה-VPS. בכיוון ההפוך, המודל tiny שתופס 75.5 MB שימושי לזיהוי שפה ולבדיקת תקינות ה-pipeline, אך לא עבור תמלולים שאדם אמור לקרוא.

מדוע faster-whisper מהיר יותר מחבילת Whisper המקורית?

המודל זהה, אך סביבת ההרצה שונה. החבילה המקורית מריצה את Whisper בתוך PyTorch, בעוד ש-faster-whisper מריצה את אותם משקלים על CTranslate2, מנוע שנבנה עבור הסקה (inference) של מודלי transformer, המבצע קוונטיזציה (quantization) למשקלים בזמן הטעינה ואינו דורש התקנה של PyTorch. במדד הביצועים שפורסם עבור CPU, החבילה המקורית מגיעה למהירות של פי 1.9 מזמן אמת, לעומת פי 7.6 ב-faster-whisper בפורמט int8, תוך שימוש בפחות זיכרון.

מדוע התמלול שלי חוזר על אותו משפט שוב ושוב?

Whisper מפענח שקט או מוזיקה כדיבור ומסתמך על הניחוש הבטוח האחרון שלו. הגדירו את vad_filter=True בקריאה ל-transcribe(), מה שמפעיל תחילה את מנגנון זיהוי הפעילות הקולית Silero ומסיר את מקטעי השקט לפני שהמודל רואה אותם. אם החזרתיות נמשכת, בדקו את עוצמת האודיו, שכן הקלטה שכמעט שקטה לחלוטין לא מספקת למודל בסיס לעבודה.

כיצד אוכל להקים נקודת קצה (endpoint) לאודיו התואמת ל-OpenAI על השרת שלי?

הריצו שרת המממש את POST /v1/audio/transcriptions ו-POST /v1/audio/speech, ולאחר מכן כוונו את הלקוח אליו באמצעות כתובת בסיס (base URL) חדשה. Speaches היא אפשרות אחת, המופצת כ-container image עם build עבור CPU, ומשתמשת ב-faster-whisper לתמלול וב-Piper או Kokoro לדיבור. vox-box היא אפשרות נוספת, המותקנת עם pip install vox-box ומופעלת עם vox-box start --huggingface-repo-id, המגישה מודל אחד לכל תהליך. אף אחת מהן אינה מפעילה אימות (authentication) כברירת מחדל, לכן בצעו bind ל-localhost והציבו proxy או VPN לפני השירות.

האם המאמר הזה היה מועיל?

#whisper#tts#piper#speech-to-text#self-hosted-ai