Last updated
FROM python:3.9
WORKDIR /code
RUN apt update
RUN apt install ffmpeg -y
RUN pip install --upgrade pip
RUN pip install openai-whisper==20230314
RUN pip install setuptools-rust==1.5.2
RUN pip install fastapi[all]==0.95.1
RUN pip install uvicorn[standard]==0.21.1
COPY ./app /code/app
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]vi app/main.pyfrom fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}version: '3.9'
services:
whisper:
build: .
volumes:
- ./cache:/root/.cache/whisper:rw
ports:
- '80:80'
# gpu사용하면 주석해제
# deploy:
# resources:
# reservations:
# devices:
# - driver: 'nvidia'
# capabilities: [gpu]
# count: 1docker-compose up --build
curl http://localhostvi main.pyfrom fastapi import FastAPI, Path
import whisper
import torch
import time
import os
from threading import Lock
app = FastAPI()
model_name= os.getenv("ASR_MODEL", "base")
@app.get("/")
def read_root():
print("model:",model_name)
if torch.cuda.is_available():
model = whisper.load_model(model_name).cuda()
print("Using GPU:", torch.cuda.get_device_name(0))
else:
model = whisper.load_model(model_name)
print("Using CPU")
model_lock = Lock()
start = time.time()
file = "app/audio/kr.mp3" #mp3 파일 경로를 이용한다.
result = model.transcribe(file)
end = time.time()
print("The time of execution of above program is :", (end-start))
return {"content": result["text"],"processing_seconds": (end-start)}FROM python:3.9
WORKDIR /code
RUN apt update
RUN apt install ffmpeg -y
RUN pip install --upgrade pip
RUN pip install openai-whisper==20230314
RUN pip install setuptools-rust==1.5.2
RUN pip install fastapi[all]==0.95.1
RUN pip install uvicorn[standard]==0.21.1
RUN pip install gunicorn==20.1.0
COPY ./app /code/app
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
# If running behind a proxy like Nginx or Traefik add --proxy-headers
# CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80", "--proxy-headers"]version: '3.9'
services:
whisper:
build: .
volumes:
- ./cache:/root/.cache/whisper:rw
- ./app:/code/app
ports:
- '80:80'
environment:
- ASR_MODEL=tiny
# - ASR_MODEL=base
# - ASR_MODEL=small
# - ASR_MODEL=medium
# - ASR_MODEL=large
# deploy: # gpu사용시 주석해제
# resources:
# reservations:
# devices:
# - driver: 'nvidia'
# capabilities: [gpu]
# count: 1from fastapi import FastAPI, File, UploadFile
import whisper
import torch
import ffmpeg
import numpy as np
import os
from threading import Lock
from typing import BinaryIO
from fastapi.responses import StreamingResponse, RedirectResponse
app = FastAPI()
SAMPLE_RATE=16000
model_name= os.getenv("ASR_MODEL", "base")
deviceType=""
deviceName = ""
if torch.cuda.is_available():
deviceType = "GPU"
deviceName = torch.cuda.get_device_name(0)
print("Using GPU:", deviceName)
model = whisper.load_model(model_name).cuda()
else:
deviceType = "CPU"
print("Using CPU")
model = whisper.load_model(model_name)
model_lock = Lock()
print("Device Type:", deviceType)
if(deviceType == "GPU"):
print("Device Name:", deviceName)
@app.get("/health")
def health():
return {"model": model_name,"deviceType": deviceType, "deviceName": deviceName}
# asr : Automatic Speech Recognition(자동 음성 인식)
@app.post("/asr")
def transcribe(
audio_file: UploadFile = File(...),
):
audio = load_audio(audio_file.file)
with model_lock:
result = model.transcribe(audio)
return result["text"]
def load_audio(file: BinaryIO, sr: int = SAMPLE_RATE):
try:
out, _ = (
ffmpeg.input("pipe:", threads=0)
.output("-", format="s16le", acodec="pcm_s16le", ac=1, ar=sr)
.run(cmd="ffmpeg", capture_stdout=True, capture_stderr=True, input=file.read())
)
except ffmpeg.Error as e:
raise RuntimeError(f"Failed to load audio: {e.stderr.decode()}") from e
return np.frombuffer(out, np.int16).flatten().astype(np.float32) / 32768.0curl -F "audio_file=@~/Desktop/GitHub/my-whisper/app/audio/kr.mp3" http://whisper/asr@app.post("/lang")
def language_detection(
audio_file: UploadFile = File(...),
):
# load audio and pad/trim it to fit 30 seconds
audio = load_audio(audio_file.file)
audio = whisper.pad_or_trim(audio)
# make log-Mel spectrogram and move to the same device as the model
mel = whisper.log_mel_spectrogram(audio).to(model.device)
# detect the spoken language
with model_lock:
_, probs = model.detect_language(mel)
detected_lang_code = max(probs, key=probs.get)
result = { "detected_language": tokenizer.LANGUAGES[detected_lang_code],"language_code" : detected_lang_code }
return resultcurl -F "audio_file=@~/Desktop/GitHub/my-whisper/app/audio/kr.mp3" http://whisper/lang
> {"detected_language":"korean","language_code":"ko"}def transcribe(
audio_file: UploadFile = File(...),
language: Union[str, None] = Query(default=None, enum=LANGUAGE_CODES),
):
audio = load_audio(audio_file.file)
options_dict = {"language" : language }
with model_lock:
result = model.transcribe(audio, **options_dict)
return result["text"]curl -F "audio_file=@kr.mp3" http://whisper/asr\?language\=en
curl -F "audio_file=@kr.mp3" http://whisper/asr\?language\=ko# asr : Automatic Speech Recognition(자동 음성 인식)
@app.post("/asr")
def transcribe(
audio_file: UploadFile = File(...),
language: Union[str, None] = Query(default=None, enum=LANGUAGE_CODES),
task : Union[str, None] = Query(default="transcribe", enum=["transcribe", "translate"]),
):
audio = load_audio(audio_file.file)
options_dict = {"language" : language }
if task:
options_dict["task"] = task
with model_lock:
result = model.transcribe(audio, **options_dict)
return result["text"]curl -F "audio_file=@kr.mp3" http://whisper/asr\?task\=translate