Bulk Transcribe Youtube Videos from Playlists

Introduction

This Python-based tool is designed for transcribing YouTube videos and playlists into text. It integrates various technologies like faster-whisper for transcription, SpaCy for natural language processing, and CUDA for GPU acceleration, aimed at processing video content efficiently. The script is capable of handling both individual videos and entire playlists, outputting accurate transcripts along with metadata.

Bulk Transcripts Have Never Been This Easy!

Functional Overview

Core Components

• YouTube Downloading: Uses pytube to download the audio from YouTube videos or playlists.
• Audio Transcription:
• Local Inference: Leverages faster_whisper.WhisperModel for converting audio to text. This model is a variant of OpenAI's Whisper designed for speed and accuracy.
• OpenAI API: Optionally uses the OpenAI API for transcription, though this uses an older and less accurate version of the Whisper model.
• NLP Processing: Optionally, integrates SpaCy for sophisticated sentence splitting, enhancing the readability and structure of the transcript.
• CUDA Acceleration: Implements CUDA support for GPU utilization, enhancing processing speed for compatible hardware.
• Progress Tracking: Utilizes tqdm for displaying progress bars during transcription.

Detailed Workflow

1. Initialization:
2. The script starts by determining whether to process a single video or a playlist based on the convert_single_video flag.

3. It sets up necessary directories for storing downloaded audio, transcripts, and metadata.

4. Environment Configuration:

5. Adds CUDA Toolkit path to the system environment for GPU utilization.

6. Configures the number of workers for transcription based on the CPU core count.

7. Video Processing:

8. For each video in the playlist or the single video, the script downloads the audio.

9. It ensures unique naming for each audio file to avoid overwrites.

10. Transcription:

11. The audio files are passed to either the local WhisperModel or the OpenAI API for transcription.
12. The script handles GPU acceleration if available, defaulting to CPU otherwise for local inference.

13. Transcription results are split into sentences, either using SpaCy or a custom regex-based splitter.

14. Metadata Generation:

15. Along with the transcript, the script generates metadata including timestamps and confidence scores for each segment.

16. Output:

17. The transcripts are saved in plain text, CSV, and JSON formats, providing both the raw transcript and structured metadata.

18. Display/Read:

19. To make the transcripts easier to read, an html file is provided, transcript_reader.html, which does further clean up and offers a "Reader Mode" where you can choose the font, text size, text width, and toggle dark mode. Simply open this html file in your browser and paste in the transcript text from one of the generated files in the generated_transcript_combined_texts folder.

Screenshot of it in Action

Paste Transcript Text into the Transcript Reader HTML File	Reader using Dark Mode and Cambria Font

Use Cases

• Content Analysis: Useful for researchers and analysts working with video content.
• Accessibility: Assists in creating subtitles and closed captions for videos.
• Educational Purposes: Helps in creating study materials from educational videos.
• Archival: Transcribes and archives video content for long-term storage and retrieval.

Setup Instructions

1. Clone the Repository

git clone https://github.com/Dicklesworthstone/bulk_transcribe_youtube_videos_from_playlist.git
cd bulk_transcribe_youtube_videos_from_playlist

2. Install Pyenv and Python 3.12 (Optional)

If you prefer to use pyenv for managing Python versions, follow these steps:

# Install pyenv if not already installed
if ! command -v pyenv &> /dev/null; then
    git clone https://github.com/pyenv/pyenv.git ~/.pyenv
    echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
    echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
    echo 'eval "$(pyenv init --path)"' >> ~/.bashrc
    source ~/.bashrc
fi

# Update pyenv and install Python 3.12
cd ~/.pyenv && git pull && cd -
pyenv install 3.12

# Set local Python version for the project
pyenv local 3.12

3. Set Up Python Environment

Choose one of the following methods:

Option A: Using system Python

# Create a virtual environment
python3 -m venv venv

# Activate the virtual environment
source venv/bin/activate

# Upgrade pip and install wheel
python3 -m pip install --upgrade pip
python3 -m pip install wheel

# Install dependencies
pip install -r requirements.txt

Option B: Using pyenv

# Create a virtual environment
python -m venv venv

# Activate the virtual environment
source venv/bin/activate

# Upgrade pip and install wheel
python -m pip install --upgrade pip
python -m pip install wheel

# Install dependencies
pip install -r requirements.txt

4. Configure the Script

Open the bulk_transcribe_youtube_videos_from_playlist.py file and set the following variables according to your preferences:

• convert_single_video: Set to 1 for a single video, 0 for a playlist
• use_spacy_for_sentence_splitting: Set to 1 to use SpaCy, 0 for regex-based splitting
• use_openai_api_for_transcription: Set to 1 to use OpenAI API, 0 for local Whisper model
• openai_api_key: If using OpenAI API, replace with your API key
• single_video_url: URL of the single video (if convert_single_video is 1)
• playlist_url: URL of the playlist (if convert_single_video is 0)

5. Running the Script

Execute the script with Python:

python bulk_transcribe_youtube_videos_from_playlist.py

Notes:

• If you're using the OpenAI API for transcription, make sure you have a valid API key and sufficient credits.
• The script will create necessary directories for storing downloaded audio and generated transcripts.
• Progress bars will display the transcription progress for each video.
• Remember that local inference using the Whisper model provides higher accuracy compared to the OpenAI API version.

If you encounter any issues during setup or execution, please check the project's issue tracker on GitHub or create a new issue with details about the problem.

Implementation Details

Initial Setup and Environment Configuration

• Video Mode Selection: Determines whether to process a single video or a playlist based on the convert_single_video flag. This choice dictates which URL (either single_video_url or playlist_url) will be used for downloading content.
• System Path Modification: add_to_system_path function adds new paths to the system environment, ensuring that dependencies like CUDA Toolkit are accessible. For Windows systems, it also handles the case where the new path contains spaces, enclosing it in quotes.
• CUDA Toolkit Path Detection: get_cuda_toolkit_path locates the CUDA Toolkit directory, crucial for GPU acceleration. It checks the Anaconda packages directory for the toolkit's installation path.
• Directory Setup: Creates necessary directories for storing downloaded audio files, combined transcript texts, and metadata tables.

Video Downloading and Processing

• Video Downloading: download_audio asynchronously downloads audio from YouTube videos. It ensures unique naming for each audio file by appending a counter if a file with the same name already exists. This function returns the path to the downloaded audio file and the filename.
• Audio Stream Handling: The function selects the first available audio stream from the video. If no audio stream is found, it raises an error.

Transcription and Text Processing

• Transcription Setup: compute_transcript_with_whisper_from_audio_func configures either the local WhisperModel or the OpenAI API for transcription. For local inference, it checks CUDA availability and sets the device and compute type accordingly.
• Transcript Computation: This function performs the actual transcription, processing the audio file through the chosen method. It captures segments of transcribed text along with their metadata (start and end times, average log probability).
• Sentence Splitting: Depending on the use_spacy_for_sentence_splitting flag, the script either uses SpaCy or a custom regex-based method for sentence splitting. This is important for structuring the transcript into readable sentences.

Metadata Generation and Output

• Metadata Handling: The script generates detailed metadata for each transcribed segment, including timestamps and a measure of transcription confidence (normalized log probability).
• Output Generation: Transcripts are saved in text format, while metadata is stored in both CSV and JSON formats, providing structured data for further analysis or processing.

Utility Functions

• Filename Cleaning: clean_filename sanitizes video titles for use as filenames, removing special characters and replacing spaces with underscores.
• Pagination Break Removal: remove_pagination_breaks cleans up the transcript text by removing hyphens at line breaks and correcting line break issues, improving readability.
• Log Probability Normalization: normalize_logprobs normalizes the log probabilities of transcription segments, useful for assessing the model's confidence in its transcription.

Main Execution

• The script's main execution starts in the __main__ block, where it selects the URL to process (single video or playlist) and initiates the process_video_or_playlist coroutine.
• Concurrent Downloads and Transcription: process_video_or_playlist handles the asynchronous downloading and transcription of videos. It creates a semaphore to limit the number of simultaneous downloads based on max_simultaneous_youtube_downloads.

Whisper Model Configuration

Local Inference

• Model Initialization: Initializes the WhisperModel with the specified device and compute type. The "large-v3" model variant is chosen, balancing between performance and accuracy.
• Request Time Tracking: The function records the UTC datetime when the transcription request starts. This can be used for performance metrics or logging purposes.

OpenAI API

• API Initialization: Sets up the OpenAI API client with the provided API key.
• Model Selection: Uses the "whisper-1" model for transcription.

Important Note: The OpenAI API version of Whisper uses an older and less accurate version of the Whisper model. Users will achieve significantly higher transcription accuracy using local inference with the latest Whisper model.

Transcription Process

• Transcription Execution: For local inference, calls model.transcribe on a separate thread using asyncio.to_thread to maintain the asynchronous nature of the script. For the OpenAI API, sends a request to the transcription endpoint.
• Transcription Settings: For local inference, the transcription uses a beam_size of 10 and activates the vad_filter. The beam_size parameter affects the trade-off between accuracy and speed during transcription - a higher value can lead to more accurate results but requires more computational resources. The vad_filter (Voice Activity Detection filter) helps in ignoring non-speech segments in the audio, focusing the transcription process on relevant audio parts.

Processing Transcription Results

• Segment Processing: Each segment returned by the transcription process contains the transcribed text, its start and end times in the audio, and (for local inference) an average log probability (a measure of confidence). The function iterates over these segments, compiling the full transcript and generating a list of sentences using sophisticated_sentence_splitter.
• Metadata Generation: For each segment, it rounds off the start and end times and the average log probability (where applicable) to two decimal places and stores this data in a list of dictionaries. This metadata includes timing and confidence information for each transcribed segment.

Output File Generation

• Text File: Writes the combined transcript to a text file, named after the audio file and stored in 'generated_transcript_combined_texts'.
• CSV and JSON: Converts the metadata list into a DataFrame and then exports it to both CSV and JSON formats, allowing for structured access to the transcription metadata.

Return Values

• The function returns the combined transcript text, the list of metadata dictionaries, and the list of transcript sentences. These outputs can be used for further processing or analysis.

SpaCy Sentence Splitting

• Optional Integration: The tool optionally uses SpaCy, an advanced natural language processing library, for sentence splitting. This integration is controlled by the `use_spacy_for_sentence_splittin