Upload 15 files

.gitignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Hugging Face
+.cache/
+.huggingface/ 

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,14 +1,39 @@
----
-title: Genai Content Studio
-emoji: 👁
-colorFrom: yellow
-colorTo: gray
-sdk: gradio
-sdk_version: 5.25.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: A full fletched Genai Content Studio
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# GenAI Content Studio
+
+A free and open-source AI content generation studio with multiple features:
+
+- Text Generation
+- Text Summarization
+- Image Generation
+- Audio Generation
+- Code Generation
+
+## Features
+
+- **Text Generation**: Generate creative text using OPT-350M
+- **Text Summarization**: Summarize long texts using BART
+- **Image Generation**: Create images from text prompts using Stable Diffusion
+- **Audio Generation**: Convert text to speech using MMS-TTS
+- **Code Generation**: Generate Python code using CodeGPT
+
+## Setup
+
+1. Clone the repository
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+3. Run the application:
+```bash
+python app.py
+```
+
+## Deployment
+
+This application is deployed on Hugging Face Spaces:
+[Link to be added after deployment]
+
+## License
+
+MIT License 

app.py

@@ -0,0 +1,281 @@
+import gradio as gr
+import torch
+from models.text_gen import TextGenerator
+from models.summarizer import TextSummarizer
+from models.image_gen import ImageGenerator
+from models.audio_gen import AudioGenerator
+from models.code_gen import CodeGenerator
+
+# Debug GPU availability
+print(f"CUDA available: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    print(f"CUDA device count: {torch.cuda.device_count()}")
+    print(f"Current CUDA device: {torch.cuda.current_device()}")
+    print(f"CUDA device name: {torch.cuda.get_device_name(0)}")
+    print(f"CUDA device properties: {torch.cuda.get_device_properties(0)}")
+
+# Initialize the models
+text_generator = TextGenerator()
+text_summarizer = TextSummarizer()
+image_generator = ImageGenerator()
+audio_generator = AudioGenerator()
+code_generator = CodeGenerator()
+
+def generate_text(prompt, max_length, temperature, top_p):
+    try:
+        generated_text = text_generator.generate_text(
+            prompt=prompt,
+            max_length=max_length,
+            temperature=temperature,
+            top_p=top_p
+        )
+        return generated_text
+    except Exception as e:
+        return f"Error generating text: {str(e)}"
+
+def summarize_text(text, max_length, min_length):
+    try:
+        summary = text_summarizer.summarize(
+            text=text,
+            max_length=max_length,
+            min_length=min_length
+        )
+        return summary
+    except Exception as e:
+        return f"Error generating summary: {str(e)}"
+
+def generate_image(prompt, num_steps, guidance_scale):
+    try:
+        image = image_generator.generate_image(
+            prompt=prompt,
+            num_inference_steps=num_steps,
+            guidance_scale=guidance_scale
+        )
+        return image
+    except Exception as e:
+        return f"Error generating image: {str(e)}"
+
+def generate_audio(text):
+    try:
+        audio, sample_rate = audio_generator.generate_audio(
+            text=text
+        )
+        return (sample_rate, audio)
+    except Exception as e:
+        return f"Error generating audio: {str(e)}"
+
+def generate_code(prompt, max_length, temperature, top_p):
+    try:
+        code = code_generator.generate_code(
+            prompt=prompt,
+            max_length=max_length,
+            temperature=temperature,
+            top_p=top_p
+        )
+        return code
+    except Exception as e:
+        return f"Error generating code: {str(e)}"
+
+# Create the Gradio interface
+with gr.Blocks(title="GenAI Content Studio") as app:
+    gr.Markdown("# 🎨 GenAI Content Studio")
+    gr.Markdown("### Free and Open-Source AI Content Generation")
+    
+    with gr.Tabs():
+        with gr.TabItem("Text Generation"):
+            with gr.Row():
+                with gr.Column():
+                    prompt = gr.Textbox(
+                        label="Enter your prompt",
+                        placeholder="Type your text here...",
+                        lines=3
+                    )
+                    
+                    with gr.Row():
+                        max_length = gr.Slider(
+                            minimum=50,
+                            maximum=500,
+                            value=100,
+                            step=50,
+                            label="Max Length"
+                        )
+                        temperature = gr.Slider(
+                            minimum=0.1,
+                            maximum=1.0,
+                            value=0.7,
+                            step=0.1,
+                            label="Temperature"
+                        )
+                        top_p = gr.Slider(
+                            minimum=0.1,
+                            maximum=1.0,
+                            value=0.9,
+                            step=0.1,
+                            label="Top P"
+                        )
+                    
+                    generate_btn = gr.Button("Generate Text")
+                
+                with gr.Column():
+                    output = gr.Textbox(
+                        label="Generated Text",
+                        lines=10,
+                        interactive=False
+                    )
+            
+            generate_btn.click(
+                fn=generate_text,
+                inputs=[prompt, max_length, temperature, top_p],
+                outputs=output
+            )
+
+        with gr.TabItem("Text Summarization"):
+            with gr.Row():
+                with gr.Column():
+                    text_input = gr.Textbox(
+                        label="Enter text to summarize",
+                        placeholder="Paste your text here...",
+                        lines=10
+                    )
+                    
+                    with gr.Row():
+                        max_summary_length = gr.Slider(
+                            minimum=50,
+                            maximum=200,
+                            value=130,
+                            step=10,
+                            label="Max Summary Length"
+                        )
+                        min_summary_length = gr.Slider(
+                            minimum=10,
+                            maximum=100,
+                            value=30,
+                            step=10,
+                            label="Min Summary Length"
+                        )
+                    
+                    summarize_btn = gr.Button("Summarize Text")
+                
+                with gr.Column():
+                    summary_output = gr.Textbox(
+                        label="Generated Summary",
+                        lines=5,
+                        interactive=False
+                    )
+            
+            summarize_btn.click(
+                fn=summarize_text,
+                inputs=[text_input, max_summary_length, min_summary_length],
+                outputs=summary_output
+            )
+        
+        with gr.TabItem("Image Generation"):
+            with gr.Row():
+                with gr.Column():
+                    image_prompt = gr.Textbox(
+                        label="Enter your image prompt",
+                        placeholder="Describe the image you want to generate...",
+                        lines=3
+                    )
+                    
+                    with gr.Row():
+                        num_steps = gr.Slider(
+                            minimum=20,
+                            maximum=100,
+                            value=50,
+                            step=10,
+                            label="Number of Steps"
+                        )
+                        guidance_scale = gr.Slider(
+                            minimum=1.0,
+                            maximum=20.0,
+                            value=7.5,
+                            step=0.5,
+                            label="Guidance Scale"
+                        )
+                    
+                    generate_image_btn = gr.Button("Generate Image")
+                
+                with gr.Column():
+                    image_output = gr.Image(
+                        label="Generated Image",
+                        type="pil"
+                    )
+            
+            generate_image_btn.click(
+                fn=generate_image,
+                inputs=[image_prompt, num_steps, guidance_scale],
+                outputs=image_output
+            )
+
+        with gr.TabItem("Audio Generation"):
+            with gr.Row():
+                with gr.Column():
+                    audio_text = gr.Textbox(
+                        label="Enter text to convert to speech",
+                        placeholder="Type what you want to hear...",
+                        lines=3
+                    )
+                    
+                    generate_audio_btn = gr.Button("Generate Audio")
+                
+                with gr.Column():
+                    audio_output = gr.Audio(
+                        label="Generated Audio",
+                        type="numpy"
+                    )
+            
+            generate_audio_btn.click(
+                fn=generate_audio,
+                inputs=[audio_text],
+                outputs=audio_output
+            )
+        
+        with gr.TabItem("Code Generation"):
+            with gr.Row():
+                with gr.Column():
+                    code_prompt = gr.Textbox(
+                        label="Enter your code prompt",
+                        placeholder="Describe the code you want to generate...",
+                        lines=3
+                    )
+                    
+                    with gr.Row():
+                        max_length = gr.Slider(
+                            minimum=50,
+                            maximum=500,
+                            value=100,
+                            step=50,
+                            label="Max Length"
+                        )
+                        temperature = gr.Slider(
+                            minimum=0.1,
+                            maximum=1.0,
+                            value=0.7,
+                            step=0.1,
+                            label="Temperature"
+                        )
+                        top_p = gr.Slider(
+                            minimum=0.1,
+                            maximum=1.0,
+                            value=0.9,
+                            step=0.1,
+                            label="Top P"
+                        )
+                    
+                    generate_code_btn = gr.Button("Generate Code")
+                
+                with gr.Column():
+                    code_output = gr.Code(
+                        label="Generated Code",
+                        language="python"
+                    )
+            
+            generate_code_btn.click(
+                fn=generate_code,
+                inputs=[code_prompt, max_length, temperature, top_p],
+                outputs=code_output
+            )
+
+if __name__ == "__main__":
+    app.launch() 

models/audio_gen.py

@@ -0,0 +1,46 @@
+import torch
+from transformers import VitsModel, AutoTokenizer
+import numpy as np
+
+class AudioGenerator:
+    def __init__(self):
+        print("Initializing Audio Generator...")
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+        
+        # Load model and tokenizer
+        self.model_name = "facebook/mms-tts-eng"
+        print(f"Loading model {self.model_name}...")
+        
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        self.model = VitsModel.from_pretrained(self.model_name).to(self.device)
+        print(f"Model loaded and moved to {self.device}")
+
+    def generate_audio(self, text, voice_preset=None):
+        """
+        Generate audio from text using the MMS-TTS model
+        
+        Args:
+            text (str): The text to convert to speech
+            voice_preset (str): Not used in this implementation
+            
+        Returns:
+            tuple: (audio_array, sample_rate)
+        """
+        try:
+            print(f"Generating audio on {self.device}...")
+            
+            # Tokenize the input text
+            inputs = self.tokenizer(text, return_tensors="pt").to(self.device)
+            
+            with torch.no_grad():
+                output = self.model(**inputs).waveform
+            
+            # Convert to numpy array and normalize
+            audio = output.cpu().numpy().squeeze()
+            audio = (audio * 32767).astype(np.int16)
+            
+            return audio, self.model.config.sampling_rate
+
+        except Exception as e:
+            return f"Error generating audio: {str(e)}" 

models/code_gen.py

@@ -0,0 +1,191 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import re
+import textwrap
+
+class CodeGenerator:
+    def __init__(self):
+        print("Initializing Code Generator...")
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+        
+        # Load model and tokenizer
+        self.model_name = "microsoft/CodeGPT-small-py-adaptedGPT2"
+        print(f"Loading model {self.model_name}...")
+        
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            self.model_name,
+            torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+        ).to(self.device)
+        
+        print(f"Model loaded and moved to {self.device}")
+
+    def generate_code(self, prompt, max_length=150, temperature=0.7, top_p=0.95):
+        """
+        Generate code based on the given prompt
+        
+        Args:
+            prompt (str): The prompt describing the code to generate
+            max_length (int): Maximum length of the generated code
+            temperature (float): Controls randomness in generation
+            top_p (float): Controls diversity of generation
+            
+        Returns:
+            str: Generated code
+        """
+        try:
+            print(f"Generating code on {self.device}...")
+            
+            # Format prompt for better code generation
+            formatted_prompt = f"# Python\n# Task: {prompt}\n# Solution:\n"
+            
+            inputs = self.tokenizer(
+                formatted_prompt,
+                return_tensors="pt",
+                truncation=True,
+                max_length=512
+            ).to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_length=max_length + len(inputs["input_ids"][0]),
+                    temperature=temperature,
+                    top_p=top_p,
+                    num_return_sequences=1,
+                    pad_token_id=self.tokenizer.eos_token_id,
+                    do_sample=True,
+                    repetition_penalty=1.1,
+                    no_repeat_ngram_size=3
+                )
+            
+            generated_code = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            # Remove the prompt from the generated code
+            generated_code = generated_code[len(formatted_prompt):]
+            
+            # Format the code
+            formatted_code = self._format_code(generated_code)
+            return formatted_code
+
+        except Exception as e:
+            return f"Error generating code: {str(e)}"
+
+    def _format_code(self, code):
+        """
+        Format the generated code for better readability
+        
+        Args:
+            code (str): The code to format
+            
+        Returns:
+            str: Formatted code
+        """
+        # Remove any trailing whitespace
+        code = code.strip()
+        
+        # Split into lines and remove duplicates
+        lines = code.split('\n')
+        unique_lines = []
+        seen_lines = set()
+        
+        for line in lines:
+            stripped_line = line.strip()
+            if stripped_line and stripped_line not in seen_lines:
+                seen_lines.add(stripped_line)
+                unique_lines.append(line)
+        
+        # Fix common indentation issues
+        formatted_lines = []
+        
+        # Track indentation level
+        indent_level = 0
+        for line in unique_lines:
+            # Skip empty lines
+            if not line.strip():
+                formatted_lines.append('')
+                continue
+                
+            # Calculate current indentation
+            current_indent = len(line) - len(line.lstrip())
+            
+            # Handle indentation changes
+            if line.strip().endswith(':'):
+                # Increase indent after colons
+                indent_level = current_indent + 4
+            elif current_indent > indent_level:
+                # Decrease indent if too deep
+                indent_level = max(0, indent_level - 4)
+            
+            # Apply proper indentation
+            formatted_line = ' ' * indent_level + line.lstrip()
+            formatted_lines.append(formatted_line)
+        
+        # Join lines with proper spacing
+        formatted_code = '\n'.join(formatted_lines)
+        
+        # Add docstrings if missing
+        if 'def ' in formatted_code and '"""' not in formatted_code:
+            formatted_code = self._add_docstrings(formatted_code)
+        
+        # Ensure proper spacing between functions/classes
+        formatted_code = re.sub(r'\n{3,}', '\n\n', formatted_code)
+        
+        # Remove any duplicate code blocks
+        formatted_code = self._remove_duplicate_blocks(formatted_code)
+        
+        return formatted_code
+
+    def _remove_duplicate_blocks(self, code):
+        """
+        Remove duplicate code blocks
+        
+        Args:
+            code (str): The code to clean
+            
+        Returns:
+            str: Code with duplicates removed
+        """
+        # Split into blocks (functions/classes)
+        blocks = re.split(r'(?=\n\s*(?:def|class)\s)', code)
+        unique_blocks = []
+        seen_blocks = set()
+        
+        for block in blocks:
+            # Normalize block by removing whitespace
+            normalized = re.sub(r'\s+', ' ', block.strip())
+            if normalized and normalized not in seen_blocks:
+                seen_blocks.add(normalized)
+                unique_blocks.append(block)
+        
+        return ''.join(unique_blocks).strip()
+
+    def _add_docstrings(self, code):
+        """
+        Add docstrings to functions if missing
+        
+        Args:
+            code (str): The code to add docstrings to
+            
+        Returns:
+            str: Code with docstrings
+        """
+        lines = code.split('\n')
+        formatted_lines = []
+        i = 0
+        
+        while i < len(lines):
+            line = lines[i]
+            formatted_lines.append(line)
+            
+            # Check for function definition
+            if line.strip().startswith('def '):
+                # Add docstring if next line doesn't have one
+                if i + 1 < len(lines) and '"""' not in lines[i + 1]:
+                    indent = len(line) - len(line.lstrip())
+                    docstring = f'{indent * " "}    """\n{indent * " "}    Docstring\n{indent * " "}    """'
+                    formatted_lines.append(docstring)
+            
+            i += 1
+        
+        return '\n'.join(formatted_lines) 

models/image_gen.py

@@ -0,0 +1,55 @@
+from diffusers import StableDiffusionPipeline
+import torch
+from PIL import Image
+import io
+
+class ImageGenerator:
+    def __init__(self, model_name="CompVis/stable-diffusion-v1-4"):
+        # Explicit GPU detection and setup
+        if torch.cuda.is_available():
+            self.device = torch.device("cuda")
+            print(f"Image Generator: Using GPU - {torch.cuda.get_device_name(0)}")
+            print(f"GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
+        else:
+            self.device = torch.device("cpu")
+            print("Image Generator: Using CPU")
+        
+        print(f"Loading model {model_name}...")
+        self.pipe = StableDiffusionPipeline.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16 if self.device.type == "cuda" else torch.float32,
+            safety_checker=None,  # Disable safety checker for better performance
+            variant="fp16" if self.device.type == "cuda" else None  # Use fp16 weights on GPU
+        ).to(self.device)
+        print(f"Model loaded and moved to {self.device}")
+    
+    def generate_image(self, prompt, num_inference_steps=30, guidance_scale=7.0):
+        """
+        Generate an image based on the given prompt
+        
+        Args:
+            prompt (str): The text prompt to generate from
+            num_inference_steps (int): Number of denoising steps
+            guidance_scale (float): Scale for classifier-free guidance
+            
+        Returns:
+            PIL.Image: Generated image
+        """
+        try:
+            print(f"Generating image on {self.device}...")
+            
+            # Add quality prompts
+            enhanced_prompt = f"{prompt}, high quality, detailed, 4k, professional photography"
+            
+            image = self.pipe(
+                enhanced_prompt,
+                num_inference_steps=num_inference_steps,
+                guidance_scale=guidance_scale,
+                negative_prompt="blurry, low quality, distorted, deformed",
+                width=512,  # Reduced resolution for faster generation
+                height=512  # Reduced resolution for faster generation
+            ).images[0]
+            
+            return image
+        except Exception as e:
+            return f"Error generating image: {str(e)}" 

models/summarizer.py

@@ -0,0 +1,37 @@
+import torch
+from transformers import BartForConditionalGeneration, BartTokenizer
+
+class TextSummarizer:
+    def __init__(self):
+        print("Initializing Text Summarizer...")
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+        
+        # Load model and tokenizer
+        self.model_name = "facebook/bart-large-cnn"
+        self.tokenizer = BartTokenizer.from_pretrained(self.model_name)
+        self.model = BartForConditionalGeneration.from_pretrained(self.model_name).to(self.device)
+        print(f"Loaded {self.model_name} model and moved to {self.device}")
+
+    def summarize(self, text, max_length=130, min_length=30):
+        try:
+            # Tokenize the input text
+            inputs = self.tokenizer(text, return_tensors="pt", max_length=1024, truncation=True)
+            inputs = inputs.to(self.device)
+
+            # Generate summary
+            summary_ids = self.model.generate(
+                inputs["input_ids"],
+                max_length=max_length,
+                min_length=min_length,
+                num_beams=4,
+                length_penalty=2.0,
+                early_stopping=True
+            )
+
+            # Decode the generated summary
+            summary = self.tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+            return summary
+
+        except Exception as e:
+            return f"Error generating summary: {str(e)}" 

models/text_gen.py

@@ -0,0 +1,108 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+class TextGenerator:
+    def __init__(self):
+        print("Initializing Text Generator...")
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+        
+        # Load model and tokenizer
+        self.model_name = "facebook/opt-350m"
+        print(f"Loading model {self.model_name}...")
+        
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            self.model_name,
+            torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+        ).to(self.device)
+        
+        print(f"Model loaded and moved to {self.device}")
+
+    def generate_text(self, prompt, max_length=200, temperature=0.7, top_p=0.9):
+        """
+        Generate text based on the given prompt
+        
+        Args:
+            prompt (str): The text generation prompt
+            max_length (int): Maximum length of the generated text
+            temperature (float): Controls randomness in generation
+            top_p (float): Controls diversity of generation
+            
+        Returns:
+            str: Generated text
+        """
+        try:
+            print(f"Generating text on {self.device}...")
+            
+            # Format prompt for better generation
+            formatted_prompt = f"Instruction: {prompt}\n\nResponse:"
+            
+            inputs = self.tokenizer(
+                formatted_prompt,
+                return_tensors="pt",
+                truncation=True,
+                max_length=512
+            ).to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_length=max_length + len(inputs["input_ids"][0]),
+                    temperature=temperature,
+                    top_p=top_p,
+                    num_return_sequences=1,
+                    pad_token_id=self.tokenizer.eos_token_id,
+                    do_sample=True,
+                    repetition_penalty=1.2,
+                    no_repeat_ngram_size=3,
+                    num_beams=5,
+                    early_stopping=True
+                )
+            
+            generated_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            # Remove the prompt from the generated text
+            generated_text = generated_text[len(formatted_prompt):]
+            
+            # Format the text
+            formatted_text = self._format_text(generated_text)
+            return formatted_text
+
+        except Exception as e:
+            return f"Error generating text: {str(e)}"
+
+    def _format_text(self, text):
+        """
+        Format the generated text for better readability
+        
+        Args:
+            text (str): The text to format
+            
+        Returns:
+            str: Formatted text
+        """
+        # Split into paragraphs
+        paragraphs = text.split('\n\n')
+        
+        # Format each paragraph
+        formatted_paragraphs = []
+        for para in paragraphs:
+            if para.strip():
+                # Capitalize first letter
+                para = para.strip()
+                if para:
+                    para = para[0].upper() + para[1:]
+                
+                # Add proper spacing
+                para = ' '.join(para.split())
+                
+                formatted_paragraphs.append(para)
+        
+        # Join paragraphs with proper spacing
+        formatted_text = '\n\n'.join(formatted_paragraphs)
+        
+        # Ensure proper punctuation
+        if formatted_text and formatted_text[-1] not in '.!?':
+            formatted_text += '.'
+        
+        return formatted_text 

requirements.txt

@@ -0,0 +1,14 @@
+--find-links https://download.pytorch.org/whl/torch_stable.html
+torch>=2.0.0
+transformers>=4.30.0
+gradio>=3.50.0
+diffusers>=0.21.0
+accelerate>=0.21.0
+sentencepiece>=0.1.99
+protobuf>=3.20.0
+numpy>=1.24.0
+pillow>=9.5.0
+scipy>=1.10.0
+tqdm>=4.65.0
+requests>=2.31.0
+langchain>=0.1.0