Spaces:
Running
Running
| from openai import AzureOpenAI | |
| import os | |
| import ffmpeg | |
| from typing import List | |
| from moviepy.editor import VideoFileClip | |
| import nltk | |
| from sklearn.feature_extraction.text import TfidfVectorizer | |
| import gradio as gr | |
| from pytube import YouTube | |
| import requests | |
| import logging | |
| nltk.download('punkt') | |
| nltk.download('stopwords') | |
| class VideoAnalytics: | |
| """ | |
| Class for performing analytics on videos including transcription, summarization, topic generation, | |
| and extraction of important sentences. | |
| """ | |
| def __init__(self): | |
| """ | |
| Initialize the VideoAnalytics object. | |
| Args: | |
| hf_token (str): Hugging Face API token. | |
| """ | |
| # Initialize AzureOpenAI client | |
| self.client = AzureOpenAI() | |
| # Initialize transcribed text variable | |
| self.transcribed_text = "" | |
| # API URL for accessing the Hugging Face model | |
| self.API_URL = "https://api-inference.huggingface.co/models/openai/whisper-large-v3" | |
| # Placeholder for Hugging Face API token | |
| hf_token = os.get_environ("HF_TOKEN") # Replace this with the actual Hugging Face API token | |
| # Set headers for API requests with Hugging Face token | |
| self.headers = {"Authorization": f"Bearer {hf_token}"} | |
| # Configure logging settings | |
| logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') | |
| def transcribe_video(self, vid: str) -> str: | |
| """ | |
| Transcribe the audio of the video. | |
| Args: | |
| vid (str): Path to the video file. | |
| Returns: | |
| str: Transcribed text. | |
| """ | |
| try: | |
| # Load the video file and extract audio | |
| video = VideoFileClip(vid) | |
| audio = video.audio | |
| # Write audio to a temporary file | |
| audio.write_audiofile("output_audio.mp3") | |
| audio_file = open("output_audio.mp3", "rb") | |
| # Define a helper function to query the Hugging Face model | |
| def query(data): | |
| response = requests.post(self.API_URL, headers=self.headers, data=data) | |
| return response.json() | |
| # Send audio data to the Hugging Face model for transcription | |
| output = query(audio_file) | |
| # Update the transcribed_text attribute with the transcription result | |
| self.transcribed_text = output["text"] | |
| # Return the transcribed text | |
| return output["text"] | |
| except Exception as e: | |
| logging.error(f"Error transcribing video: {e}") | |
| return "" | |
| def generate_video_summary(self) -> str: | |
| """ | |
| Generate a summary of the transcribed video. | |
| Returns: | |
| str: Generated summary. | |
| """ | |
| try: | |
| # Define a conversation between system and user | |
| conversation = [ | |
| {"role": "system", "content": "You are a Summarizer"}, | |
| {"role": "user", "content": f"""summarize the following text delimited by triple backticks. | |
| In two format of Outputs given below: | |
| Abstractive Summary: | |
| Extractive Summary: | |
| ```{self.transcribed_text}``` | |
| """} | |
| ] | |
| # Generate completion using ChatGPT model | |
| response = self.client.chat.completions.create( | |
| model="ChatGPT", | |
| messages=conversation, | |
| temperature=0, | |
| max_tokens=1000 | |
| ) | |
| # Get the generated summary message | |
| message = response.choices[0].message.content | |
| return message | |
| except Exception as e: | |
| logging.error(f"Error generating video summary: {e}") | |
| return "" | |
| def generate_topics(self) -> str: | |
| """ | |
| Generate topics from the transcribed video. | |
| Returns: | |
| str: Generated topics. | |
| """ | |
| try: | |
| # Define a conversation between system and user | |
| conversation = [ | |
| {"role": "system", "content": "You are a Topic Generator"}, | |
| {"role": "user", "content": f"""generate single Topics from the following text don't make sentence for topic generation,delimited by triple backticks. | |
| list out the topics: | |
| Topics: | |
| ```{self.transcribed_text}``` | |
| """} | |
| ] | |
| # Generate completion using ChatGPT model | |
| response = self.client.chat.completions.create( | |
| model="ChatGPT", | |
| messages=conversation, | |
| temperature=0, | |
| max_tokens=1000 | |
| ) | |
| # Get the generated topics message | |
| message = response.choices[0].message.content | |
| return message | |
| except Exception as e: | |
| logging.error(f"Error generating topics: {e}") | |
| return "" | |
| def extract_video_important_sentence(self) -> str: | |
| """ | |
| Extract important sentences from the transcribed video. | |
| Returns: | |
| str: Extracted important sentences. | |
| """ | |
| try: | |
| # Tokenize the sentences | |
| sentences = nltk.sent_tokenize(self.transcribed_text) | |
| # Initialize TF-IDF vectorizer | |
| tfidf_vectorizer = TfidfVectorizer() | |
| # Fit the vectorizer on the summary sentences | |
| tfidf_matrix = tfidf_vectorizer.fit_transform(sentences) | |
| # Calculate sentence scores based on TF-IDF values | |
| sentence_scores = tfidf_matrix.sum(axis=1) | |
| # Create a list of (score, sentence) tuples | |
| sentence_rankings = [(score, sentence) for score, sentence in zip(sentence_scores, sentences)] | |
| # Sort sentences by score in descending order | |
| sentence_rankings.sort(reverse=True) | |
| # Set a threshold for selecting sentences | |
| threshold = 2 # Adjust as needed | |
| # Select sentences with scores above the threshold | |
| selected_sentences = [sentence for score, sentence in sentence_rankings if score >= threshold] | |
| # Join selected sentences to form the summary | |
| summary = '\n\n'.join(selected_sentences) | |
| return summary | |
| except Exception as e: | |
| logging.error(f"Error extracting important sentences: {e}") | |
| return "" | |
| def write_text_files(self, text: str, filename: str) -> None: | |
| """ | |
| Write text to a file. | |
| Args: | |
| text (str): Text to be written to the file. | |
| filename (str): Name of the file. | |
| """ | |
| try: | |
| file_path = f"{filename}.txt" | |
| with open(file_path, 'w') as file: | |
| # Write content to the file | |
| file.write(text) | |
| except Exception as e: | |
| logging.error(f"Error writing text to file: {e}") | |
| def Download(self, link: str) -> str: | |
| """ | |
| Download a video from YouTube. | |
| Args: | |
| link (str): YouTube video link. | |
| Returns: | |
| str: Path to the downloaded video file. | |
| """ | |
| try: | |
| # Initialize YouTube object with the provided link | |
| youtubeObject = YouTube(link) | |
| # Get the highest resolution stream | |
| youtubeObject = youtubeObject.streams.get_highest_resolution() | |
| try: | |
| # Attempt to download the video | |
| file_name = youtubeObject.download() | |
| return file_name | |
| except: | |
| # Log any errors that occur during video download | |
| logging.info("An error has occurred") | |
| logging.info("Download is completed successfully") | |
| except Exception as e: | |
| # Log any errors that occur during initialization of YouTube object | |
| logging.error(f"Error downloading video: {e}") | |
| return "" | |
| def main(self, video: str = None, input_path: str = None) -> tuple: | |
| """ | |
| Perform video analytics. | |
| Args: | |
| video (str): Path to the video file. | |
| input_path (str): Input path for the video. | |
| Returns: | |
| tuple: Summary, important sentences, and topics. | |
| """ | |
| try: | |
| # Download the video if input_path is provided, otherwise use the provided video path | |
| if input_path: | |
| input_path = self.Download(input_path) | |
| text = self.transcribe_video(input_path) | |
| elif video: | |
| text = self.transcribe_video(video) | |
| input_path = video | |
| # Generate summary, important sentences, and topics | |
| summary = self.generate_video_summary() | |
| self.write_text_files(summary,"Summary") | |
| important_sentences = self.extract_video_important_sentence() | |
| self.write_text_files(important_sentences,"Important_Sentence") | |
| topics = self.generate_topics() | |
| self.write_text_files(topics,"Topics") | |
| # Return the generated summary, important sentences, and topics | |
| return summary,important_sentences,topics | |
| except Exception as e: | |
| # Log any errors that occur during video analytics | |
| logging.error(f"Error in main function: {e}") | |
| return "", "", "" | |
| def gradio_interface(self): | |
| with gr.Blocks(css="style.css",theme=gr.themes.Soft()) as demo: | |
| gr.HTML("""<center><h1>Video Analytics</h1></center>""") | |
| with gr.Row(): | |
| yt_link = gr.Textbox(label= "Youtube Link",placeholder="https://www.youtube.com/watch?v=") | |
| with gr.Row(): | |
| video = gr.Video(sources="upload",height=200,width=300) | |
| with gr.Row(): | |
| submit_btn = gr.Button(value="Submit") | |
| with gr.Tab("Summary"): | |
| with gr.Row(): | |
| summary = gr.Textbox(show_label=False,lines=10) | |
| with gr.Row(): | |
| summary_download = gr.DownloadButton(label="Download",value="Summary.txt",visible=True,size='lg',elem_classes="download_button") | |
| with gr.Tab("Important Sentences"): | |
| with gr.Row(): | |
| Important_Sentences = gr.Textbox(show_label=False,lines=10) | |
| with gr.Row(): | |
| sentence_download = gr.DownloadButton(label="Download",value="Important_Sentence.txt",visible=True,size='lg',elem_classes="download_button") | |
| with gr.Tab("Topics"): | |
| with gr.Row(): | |
| Topics = gr.Textbox(show_label=False,lines=10) | |
| with gr.Row(): | |
| topics_download = gr.DownloadButton(label="Download",value="Topics.txt",visible=True,size='lg',elem_classes="download_button") | |
| submit_btn.click(self.main,[video,yt_link],[summary,Important_Sentences,Topics]) | |
| demo.launch() | |
| if __name__ == "__main__": | |
| video_analytics = VideoAnalytics() | |
| video_analytics.gradio_interface() |