import gradio as gr from transformers import AutoModelForCausalLM, AutoTokenizer import random from datetime import datetime from PyPDF2 import PdfReader import json from dotenv import load_dotenv load_dotenv() class TweetDatasetProcessor: def __init__(self, fine_tuned_model_name, pdf_path=None): self.tweets = [] self.personality_profile = {} self.used_tweets = set() # Track used tweets to avoid repetition self.pdf_path = pdf_path # Load fine-tuned model and tokenizer self.model = AutoModelForCausalLM.from_pretrained(fine_tuned_model_name) self.tokenizer = AutoTokenizer.from_pretrained(fine_tuned_model_name) @staticmethod def _process_line(line): """Process a single line.""" line = line.strip() if not line or line.startswith('http'): # Skip empty lines and URLs return None return { 'content': line, 'timestamp': datetime.now(), 'mentions': [word for word in line.split() if word.startswith('@')], 'hashtags': [word for word in line.split() if word.startswith('#')] } def extract_text_from_pdf(self): """Extract text content from PDF file.""" if not self.pdf_path: return "" reader = PdfReader(self.pdf_path) text = "" for page in reader.pages: text += page.extract_text() return text def process_pdf_content(self, text): """Process PDF content and clean extracted tweets.""" if not text.strip(): raise ValueError("The provided PDF appears to be empty.") lines = text.split('\n') clean_tweets = [TweetDatasetProcessor._process_line(line) for line in lines] self.tweets = [tweet for tweet in clean_tweets if tweet] if not self.tweets: raise ValueError("No tweets were extracted from the PDF. Ensure the content is properly formatted.") return self.tweets def analyze_personality(self, max_tweets=50): """Comprehensive personality analysis using a limited subset of tweets.""" if not self.tweets: raise ValueError("No tweets available for personality analysis.") all_tweets = [tweet['content'] for tweet in self.tweets][:max_tweets] analysis_prompt = f"""Perform a deep psychological analysis of the author based on these tweets: Core beliefs, emotional tendencies, cognitive patterns, etc. Tweets for analysis: {json.dumps(all_tweets, indent=2)} """ input_ids = self.tokenizer.encode(analysis_prompt, return_tensors='pt') output = self.model.generate(input_ids, max_length=500, num_return_sequences=1, temperature=0.7) personality_analysis = self.tokenizer.decode(output[0], skip_special_tokens=True) self.personality_profile = personality_analysis return self.personality_profile def generate_tweet(self, context="", sample_size=3): """Generate a new tweet by sampling random tweets and avoiding repetition.""" if not self.tweets: return "Error: No tweets available for generation." # Randomly sample unique tweets available_tweets = [tweet for tweet in self.tweets if tweet['content'] not in self.used_tweets] if len(available_tweets) < sample_size: self.used_tweets.clear() # Reset used tweets if all have been used available_tweets = self.tweets sampled_tweets = random.sample(available_tweets, sample_size) sampled_contents = [tweet['content'] for tweet in sampled_tweets] # Update the used tweets tracker self.used_tweets.update(sampled_contents) # Truncate personality profile to avoid token overflow personality_profile_excerpt = self.personality_profile[:400] if len(self.personality_profile) > 400 else self.personality_profile # Construct the prompt prompt = f"""Based on this personality profile: {personality_profile_excerpt} Current context or topic (if any): {context} Tweets for context: {', '.join(sampled_contents)} **Only generate the tweet. Do not include analysis, explanation, or any other content.** """ input_ids = self.tokenizer.encode(prompt, return_tensors='pt') output = self.model.generate(input_ids, max_length=150, num_return_sequences=1, temperature=1.0) generated_tweet = self.tokenizer.decode(output[0], skip_special_tokens=True).strip() return generated_tweet # Gradio Interface Function def gradio_interface(pdf_file, context="AI-powered tweet generation"): # Initialize the processor with uploaded PDF path fine_tuned_model_name = 'Manasa1/GPT2_Finetuned_tweets' # Replace with the path to your fine-tuned model processor = TweetDatasetProcessor(fine_tuned_model_name, pdf_path=pdf_file.name) # Extract text from PDF and process it text = processor.extract_text_from_pdf() tweets = processor.process_pdf_content(text) # Analyze personality based on tweets personality_analysis = processor.analyze_personality(max_tweets=50) # Generate tweet based on the personality analysis and context generated_tweet = processor.generate_tweet(context=context, sample_size=3) return personality_analysis, generated_tweet # Gradio app setup iface = gr.Interface( fn=gradio_interface, inputs=[ gr.File(label="Upload PDF with Tweets"), gr.Textbox(label="Context for Tweet Generation (optional)", placeholder="e.g., AI-powered tweet generation") ], outputs=[ gr.Textbox(label="Personality Analysis"), gr.Textbox(label="Generated Tweet") ], live=True, title="AI Personality and Tweet Generation", description="Automatically analyze personality and generate tweets based on a provided PDF of tweets." ) # Launch the app if __name__ == "__main__": iface.launch() import gradio as gr from transformers import AutoModelForCausalLM, AutoTokenizer import random from datetime import datetime from PyPDF2 import PdfReader import json from dotenv import load_dotenv load_dotenv() class TweetDatasetProcessor: def __init__(self, fine_tuned_model_name, pdf_path=None): self.tweets = [] self.personality_profile = {} self.used_tweets = set() # Track used tweets to avoid repetition self.pdf_path = pdf_path # Load fine-tuned model and tokenizer self.model = AutoModelForCausalLM.from_pretrained(fine_tuned_model_name) self.tokenizer = AutoTokenizer.from_pretrained(fine_tuned_model_name) @staticmethod def _process_line(line): """Process a single line.""" line = line.strip() if not line or line.startswith('http'): # Skip empty lines and URLs return None return { 'content': line, 'timestamp': datetime.now(), 'mentions': [word for word in line.split() if word.startswith('@')], 'hashtags': [word for word in line.split() if word.startswith('#')] } def extract_text_from_pdf(self): """Extract text content from PDF file.""" if not self.pdf_path: return "" reader = PdfReader(self.pdf_path) text = "" for page in reader.pages: text += page.extract_text() return text def process_pdf_content(self, text): """Process PDF content and clean extracted tweets.""" if not text.strip(): raise ValueError("The provided PDF appears to be empty.") lines = text.split('\n') clean_tweets = [TweetDatasetProcessor._process_line(line) for line in lines] self.tweets = [tweet for tweet in clean_tweets if tweet] if not self.tweets: raise ValueError("No tweets were extracted from the PDF. Ensure the content is properly formatted.") return self.tweets def analyze_personality(self, max_tweets=50): """Comprehensive personality analysis using a limited subset of tweets.""" if not self.tweets: raise ValueError("No tweets available for personality analysis.") all_tweets = [tweet['content'] for tweet in self.tweets][:max_tweets] analysis_prompt = f"""Perform a deep psychological analysis of the author based on these tweets: Core beliefs, emotional tendencies, cognitive patterns, etc. Tweets for analysis: {json.dumps(all_tweets, indent=2)} """ input_ids = self.tokenizer.encode(analysis_prompt, return_tensors='pt') output = self.model.generate(input_ids, max_length=500, num_return_sequences=1, temperature=0.7) personality_analysis = self.tokenizer.decode(output[0], skip_special_tokens=True) self.personality_profile = personality_analysis return self.personality_profile def generate_tweet(self, context="", sample_size=3): """Generate a new tweet by sampling random tweets and avoiding repetition.""" if not self.tweets: return "Error: No tweets available for generation." # Randomly sample unique tweets available_tweets = [tweet for tweet in self.tweets if tweet['content'] not in self.used_tweets] if len(available_tweets) < sample_size: self.used_tweets.clear() # Reset used tweets if all have been used available_tweets = self.tweets sampled_tweets = random.sample(available_tweets, sample_size) sampled_contents = [tweet['content'] for tweet in sampled_tweets] # Update the used tweets tracker self.used_tweets.update(sampled_contents) # Truncate personality profile to avoid token overflow personality_profile_excerpt = self.personality_profile[:400] if len(self.personality_profile) > 400 else self.personality_profile # Construct the prompt prompt = f"""Based on this personality profile: {personality_profile_excerpt} Current context or topic (if any): {context} Tweets for context: {', '.join(sampled_contents)} **Only generate the tweet. Do not include analysis, explanation, or any other content.** """ input_ids = self.tokenizer.encode(prompt, return_tensors='pt') output = self.model.generate(input_ids, max_length=150, num_return_sequences=1, temperature=1.0) generated_tweet = self.tokenizer.decode(output[0], skip_special_tokens=True).strip() return generated_tweet # Gradio Interface Function def gradio_interface(pdf_file, context="AI-powered tweet generation"): # Initialize the processor with uploaded PDF path fine_tuned_model_name = 'Manasa1/GPT2_Finetuned_tweets' # Replace with the path to your fine-tuned model processor = TweetDatasetProcessor(fine_tuned_model_name, pdf_path=pdf_file.name) # Extract text from PDF and process it text = processor.extract_text_from_pdf() tweets = processor.process_pdf_content(text) # Analyze personality based on tweets personality_analysis = processor.analyze_personality(max_tweets=50) # Generate tweet based on the personality analysis and context generated_tweet = processor.generate_tweet(context=context, sample_size=3) return personality_analysis, generated_tweet # Gradio app setup iface = gr.Interface( fn=gradio_interface, inputs=[ gr.File(label="Upload PDF with Tweets"), gr.Textbox(label="Context for Tweet Generation (optional)", placeholder="e.g., AI-powered tweet generation") ], outputs=[ gr.Textbox(label="Personality Analysis"), gr.Textbox(label="Generated Tweet") ], live=True, title="AI Personality and Tweet Generation", description="Automatically analyze personality and generate tweets based on a provided PDF of tweets." ) # Launch the app if __name__ == "__main__": iface.launch() import gradio as gr from transformers import AutoModelForCausalLM, AutoTokenizer import random from datetime import datetime from PyPDF2 import PdfReader import json from dotenv import load_dotenv load_dotenv() class TweetDatasetProcessor: def __init__(self, fine_tuned_model_name, pdf_path=None): self.tweets = [] self.personality_profile = {} self.used_tweets = set() # Track used tweets to avoid repetition self.pdf_path = pdf_path # Load fine-tuned model and tokenizer self.model = AutoModelForCausalLM.from_pretrained(fine_tuned_model_name) self.tokenizer = AutoTokenizer.from_pretrained(fine_tuned_model_name) @staticmethod def _process_line(line): """Process a single line.""" line = line.strip() if not line or line.startswith('http'): # Skip empty lines and URLs return None return { 'content': line, 'timestamp': datetime.now(), 'mentions': [word for word in line.split() if word.startswith('@')], 'hashtags': [word for word in line.split() if word.startswith('#')] } def extract_text_from_pdf(self): """Extract text content from PDF file.""" if not self.pdf_path: return "" reader = PdfReader(self.pdf_path) text = "" for page in reader.pages: text += page.extract_text() return text def process_pdf_content(self, text): """Process PDF content and clean extracted tweets.""" if not text.strip(): raise ValueError("The provided PDF appears to be empty.") lines = text.split('\n') clean_tweets = [TweetDatasetProcessor._process_line(line) for line in lines] self.tweets = [tweet for tweet in clean_tweets if tweet] if not self.tweets: raise ValueError("No tweets were extracted from the PDF. Ensure the content is properly formatted.") return self.tweets def analyze_personality(self, max_tweets=50): """Comprehensive personality analysis using a limited subset of tweets.""" if not self.tweets: raise ValueError("No tweets available for personality analysis.") all_tweets = [tweet['content'] for tweet in self.tweets][:max_tweets] analysis_prompt = f"""Perform a deep psychological analysis of the author based on these tweets: Core beliefs, emotional tendencies, cognitive patterns, etc. Tweets for analysis: {json.dumps(all_tweets, indent=2)} """ input_ids = self.tokenizer.encode(analysis_prompt, return_tensors='pt') output = self.model.generate(input_ids, max_length=500, num_return_sequences=1, temperature=0.7) personality_analysis = self.tokenizer.decode(output[0], skip_special_tokens=True) self.personality_profile = personality_analysis return self.personality_profile def generate_tweet(self, context="", sample_size=3): """Generate a new tweet by sampling random tweets and avoiding repetition.""" if not self.tweets: return "Error: No tweets available for generation." # Randomly sample unique tweets available_tweets = [tweet for tweet in self.tweets if tweet['content'] not in self.used_tweets] if len(available_tweets) < sample_size: self.used_tweets.clear() # Reset used tweets if all have been used available_tweets = self.tweets sampled_tweets = random.sample(available_tweets, sample_size) sampled_contents = [tweet['content'] for tweet in sampled_tweets] # Update the used tweets tracker self.used_tweets.update(sampled_contents) # Truncate personality profile to avoid token overflow personality_profile_excerpt = self.personality_profile[:400] if len(self.personality_profile) > 400 else self.personality_profile # Construct the prompt prompt = f"""Based on this personality profile: {personality_profile_excerpt} Current context or topic (if any): {context} Tweets for context: {', '.join(sampled_contents)} **Only generate the tweet. Do not include analysis, explanation, or any other content.** """ input_ids = self.tokenizer.encode(prompt, return_tensors='pt') output = self.model.generate(input_ids, max_length=150, num_return_sequences=1, temperature=1.0) generated_tweet = self.tokenizer.decode(output[0], skip_special_tokens=True).strip() return generated_tweet # Gradio Interface Function def gradio_interface(pdf_file, context="AI-powered tweet generation"): # Initialize the processor with uploaded PDF path fine_tuned_model_name = 'Manasa1/GPT2_Finetuned_tweets' # Replace with the path to your fine-tuned model pdf_path = 'Dataset (4).pdf' processor = TweetDatasetProcessor(fine_tuned_model_name, pdf_path=pdf_path) # Extract text from PDF and process it text = processor.extract_text_from_pdf() tweets = processor.process_pdf_content(text) # Analyze personality based on tweets personality_analysis = processor.analyze_personality(max_tweets=50) # Generate tweet based on the personality analysis and context generated_tweet = processor.generate_tweet(context=context, sample_size=3) return personality_analysis, generated_tweet # Gradio app setup iface = gr.Interface( fn=gradio_interface, inputs=[ gr.File(label="Upload PDF with Tweets"), gr.Textbox(label="Context for Tweet Generation (optional)", placeholder="e.g., AI-powered tweet generation") ], outputs=[ gr.Textbox(label="Personality Analysis"), gr.Textbox(label="Generated Tweet") ], live=True, title="AI Personality and Tweet Generation", description="Automatically analyze personality and generate tweets based on a provided PDF of tweets." ) # Launch the app if __name__ == "__main__": iface.launch()