File size: 6,115 Bytes
6c226f9
 
 
8e787d3
6c226f9
d790c0b
 
 
88183ad
6c226f9
a5bfe25
9d6fa91
66efbc3
d790c0b
6c226f9
 
 
 
 
 
 
 
 
 
202fe0b
 
 
 
 
 
 
 
 
d803ee9
3c0cd8e
 
18ea2dd
 
 
 
 
202fe0b
 
 
 
 
6c226f9
 
 
 
 
 
 
 
 
 
d790c0b
 
3c0cd8e
d790c0b
 
 
 
3c0cd8e
d790c0b
 
 
3c0cd8e
d790c0b
 
 
 
 
3c0cd8e
d790c0b
 
 
 
3c0cd8e
d790c0b
3c0cd8e
d790c0b
 
 
 
 
 
6c226f9
c5012b6
6c226f9
66efbc3
d790c0b
 
 
 
 
6c226f9
b97a3c2
 
c5012b6
 
 
 
 
 
2b07e95
 
 
 
 
6c226f9
 
2090681
c2b9c56
2090681
 
 
6c226f9
 
 
 
 
3c0cd8e
202fe0b
c5012b6
3c0cd8e
 
 
 
 
 
 
 
 
 
 
609dcbe
202fe0b
18ea2dd
6c226f9
 
 
 
 
 
 
 
 
7097513
 
202fe0b
 
18ea2dd
7097513
6c226f9
 
 
 
 
 
 
3c0cd8e
6c226f9
7097513
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
import torch

import gradio as gr
import yt_dlp as youtube_dl
from transformers import pipeline
from transformers.pipelines.audio_utils import ffmpeg_read

import tempfile
import os

MODEL_NAME = "openai/whisper-large-v3"
BATCH_SIZE = 8
FILE_LIMIT_MB = 1000
YT_LENGTH_LIMIT_S = 3600  # limit to 1 hour YouTube files

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

pipe = pipeline(
    task="automatic-speech-recognition",
    model=MODEL_NAME,
    chunk_length_s=30,
    device=device,
)

def chunks_to_srt(chunks):
    srt_format = ""
    for i, chunk in enumerate(chunks, 1):
        start_time, end_time = chunk['timestamp']
        start_time_hms = "{:02}:{:02}:{:02},{:03}".format(int(start_time // 3600), int((start_time % 3600) // 60), int(start_time % 60), int((start_time % 1) * 1000))
        end_time_hms = "{:02}:{:02}:{:02},{:03}".format(int(end_time // 3600), int((end_time % 3600) // 60), int(end_time % 60), int((end_time % 1) * 1000))
        srt_format += f"{i}\n{start_time_hms} --> {end_time_hms}\n{chunk['text']}\n\n"
    return srt_format

def transcribe(inputs, task, return_timestamps, language):
    if inputs is None:
        raise gr.Error("No audio file submitted! Please upload or record an audio file before submitting your request.")
    
    # Map the language names to their corresponding codes
    language_codes = {"English": "en", "Korean": "ko", "Japanese": "ja"}
    language_code = language_codes.get(language, "en")  # Default to "en" if the language is not found
    result = pipe(inputs, batch_size=BATCH_SIZE, generate_kwargs={"task": task, "language": f"<|{language_code}|>"}, return_timestamps=return_timestamps)
    
    if return_timestamps:
        return chunks_to_srt(result['chunks'])
    else:
        return result['text']


def _return_yt_html_embed(yt_url):
    video_id = yt_url.split("?v=")[-1]
    HTML_str = (
        f'<center> <iframe width="500" height="320" src="https://www.youtube.com/embed/{video_id}"> </iframe>'
        " </center>"
    )
    return HTML_str

def download_yt_audio(yt_url, filename):
    info_loader = youtube_dl.YoutubeDL()
    
    try:
        info = info_loader.extract_info(yt_url, download=False)
    except youtube_dl.utils.DownloadError as err:
        raise gr.Error(str(err))
    
    file_length = info["duration_string"]
    file_h_m_s = file_length.split(":")
    file_h_m_s = [int(sub_length) for sub_length in file_h_m_s]
    
    if len(file_h_m_s) == 1:
        file_h_m_s.insert(0, 0)
    if len(file_h_m_s) == 2:
        file_h_m_s.insert(0, 0)
    file_length_s = file_h_m_s[0] * 3600 + file_h_m_s[1] * 60 + file_h_m_s[2]
    
    if file_length_s > YT_LENGTH_LIMIT_S:
        yt_length_limit_hms = time.strftime("%HH:%MM:%SS", time.gmtime(YT_LENGTH_LIMIT_S))
        file_length_hms = time.strftime("%HH:%MM:%SS", time.gmtime(file_length_s))
        raise gr.Error(f"Maximum YouTube length is {yt_length_limit_hms}, got {file_length_hms} YouTube video.")
    
    ydl_opts = {"outtmpl": filename, "format": "worstvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best"}
    
    with youtube_dl.YoutubeDL(ydl_opts) as ydl:
        try:
            ydl.download([yt_url])
        except youtube_dl.utils.ExtractorError as err:
            raise gr.Error(str(err))


def yt_transcribe(yt_url, task, return_timestamps, language, max_filesize=75.0):
    html_embed_str = _return_yt_html_embed(yt_url)

    with tempfile.TemporaryDirectory() as tmpdirname:
        filepath = os.path.join(tmpdirname, "video.mp4")
        download_yt_audio(yt_url, filepath)
        with open(filepath, "rb") as f:
            inputs = f.read()

    inputs = ffmpeg_read(inputs, pipe.feature_extractor.sampling_rate)
    inputs = {"array": inputs, "sampling_rate": pipe.feature_extractor.sampling_rate}
    
    # Map the language names to their corresponding codes
    language_codes = {"English": "en", "Korean": "ko", "Japanese": "ja"}
    language_code = language_codes.get(language, "en")  # Default to "en" if the language is not found
    
    result = pipe(inputs, batch_size=BATCH_SIZE, generate_kwargs={"task": task, "language": f"<|{language_code}|>"}, return_timestamps=return_timestamps)
    
    if return_timestamps:
        return html_embed_str, chunks_to_srt(result['chunks'])
    else:
        return html_embed_str, result['text']


css = """
.gradio-container {background: #f8fafc}
footer {visibility: hidden}
"""
demo = gr.Blocks(css=css)

mf_transcribe = gr.Interface(
    fn=transcribe,
    inputs=[
        gr.inputs.Audio(source="microphone", type="filepath", optional=True),
        gr.inputs.Radio(["transcribe", "translate"], label="Task", default="transcribe"),
        gr.inputs.Checkbox(label="Return timestamps"),
        gr.inputs.Dropdown(choices=["English", "Korean", "Japanese"], label="Language"),
    ],
    outputs="text",
    layout="horizontal",
    theme="huggingface",
    allow_flagging="never",
)

file_transcribe = gr.Interface(
    fn=transcribe,
    inputs=[
        gr.inputs.Audio(source="upload", type="filepath", optional=True, label="Audio file"),
        gr.inputs.Radio(["transcribe", "translate"], label="Task", default="transcribe"),
        gr.inputs.Checkbox(label="Return timestamps"),
        gr.inputs.Dropdown(choices=["English", "Korean", "Japanese"], label="Language"),
    ],
    outputs="text",
    layout="horizontal",
    theme="huggingface",
    allow_flagging="never",
)

yt_transcribe = gr.Interface(
    fn=yt_transcribe,
    inputs=[
        gr.inputs.Textbox(lines=1, placeholder="Paste the URL to a YouTube video here", label="YouTube URL"),
        gr.inputs.Radio(["transcribe", "translate"], label="Task", default="transcribe"),
        gr.inputs.Checkbox(label="Return timestamps"),
        gr.inputs.Dropdown(choices=["English", "Korean", "Japanese"], label="Language"),
    ],
    outputs=["html", "text"],
    layout="horizontal",
    theme="huggingface",
    allow_flagging="never",
)

with demo:
    gr.TabbedInterface([mf_transcribe, file_transcribe, yt_transcribe], ["Microphone", "Audio file", "YouTube"])

demo.launch(enable_queue=True)