Upload app.py

app.py

@@ -0,0 +1,174 @@
+import gradio as gr
+import torch
+from transformers import (
+    AutoModelForCausalLM, 
+    AutoTokenizer, 
+    AutoModelForSequenceClassification, 
+    T5ForConditionalGeneration, 
+    T5Tokenizer
+)
+import pandas as pd
+import numpy as np
+import io
+import json
+
+class FinancialAnalyzer:
+    def __init__(self):
+        # Initialize models and tokenizers
+        print("Loading models...")
+        self.tiny_tokenizer = AutoTokenizer.from_pretrained("TinyLlama/TinyLlama-1.1B-Chat")
+        self.tiny_model = AutoModelForCausalLM.from_pretrained("TinyLlama/TinyLlama-1.1B-Chat")
+        
+        self.finbert_tokenizer = AutoTokenizer.from_pretrained("yiyanghkust/finbert-tone")
+        self.finbert_model = AutoModelForSequenceClassification.from_pretrained("yiyanghkust/finbert-tone")
+        
+        self.t5_tokenizer = T5Tokenizer.from_pretrained("t5-base")
+        self.t5_model = T5ForConditionalGeneration.from_pretrained("t5-base")
+        
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self._move_models_to_device()
+        print("Models loaded successfully!")
+
+    def _move_models_to_device(self):
+        self.tiny_model.to(self.device)
+        self.finbert_model.to(self.device)
+        self.t5_model.to(self.device)
+
+    def process_file(self, file, file_type):
+        """Process uploaded file based on its type"""
+        if file_type == "csv":
+            df = pd.read_csv(file)
+            return df.to_string()
+        elif file_type == "excel":
+            df = pd.read_excel(file)
+            return df.to_string()
+        elif file_type == "markdown":
+            return file.read().decode('utf-8')
+        else:
+            raise ValueError(f"Unsupported file type: {file_type}")
+
+    def analyze_financials(self, balance_sheet_file, income_statement_file, file_type="csv"):
+        """Main analysis function for Gradio interface"""
+        try:
+            # Process uploaded files
+            balance_sheet_data = self.process_file(balance_sheet_file, file_type)
+            income_statement_data = self.process_file(income_statement_file, file_type)
+
+            # Generate insights using TinyLlama
+            insights = self.generate_insights(balance_sheet_data, income_statement_data)
+            
+            # Generate sentiment analysis using FinBERT
+            sentiment = self.analyze_sentiment(balance_sheet_data, income_statement_data)
+            
+            # Generate recommendations using T5
+            recommendations = self.generate_recommendations(balance_sheet_data, income_statement_data)
+            
+            # Generate roadmap
+            roadmap = self.generate_roadmap(insights, sentiment, recommendations)
+
+            # Combine results
+            analysis_results = {
+                "Financial Insights": insights,
+                "Sentiment Analysis": sentiment,
+                "Recommendations": recommendations,
+                "Strategic Roadmap": roadmap
+            }
+
+            return json.dumps(analysis_results, indent=2)
+
+        except Exception as e:
+            return f"Error during analysis: {str(e)}"
+
+    def generate_insights(self, balance_sheet, income_statement):
+        prompt = f"""Analyze these financial statements and provide key insights:
+        Balance Sheet:
+        {balance_sheet[:1000]}
+        
+        Income Statement:
+        {income_statement[:1000]}
+        """
+        
+        inputs = self.tiny_tokenizer(prompt, return_tensors="pt").to(self.device)
+        outputs = self.tiny_model.generate(
+            inputs["input_ids"],
+            max_length=500,
+            temperature=0.7
+        )
+        return self.tiny_tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+    def analyze_sentiment(self, balance_sheet, income_statement):
+        financial_text = f"{balance_sheet[:500]}\n{income_statement[:500]}"
+        inputs = self.finbert_tokenizer(financial_text, return_tensors="pt").to(self.device)
+        outputs = self.finbert_model(**inputs)
+        probabilities = torch.nn.functional.softmax(outputs.logits, dim=1)
+        sentiment_labels = ['negative', 'neutral', 'positive']
+        
+        return {
+            'sentiment': sentiment_labels[probabilities.argmax().item()],
+            'confidence': f"{probabilities.max().item():.2f}"
+        }
+
+    def generate_recommendations(self, balance_sheet, income_statement):
+        prompt = f"generate financial recommendations based on: {balance_sheet[:200]} {income_statement[:200]}"
+        inputs = self.t5_tokenizer(prompt, return_tensors="pt").to(self.device)
+        outputs = self.t5_model.generate(inputs["input_ids"], max_length=200)
+        return self.t5_tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+    def generate_roadmap(self, insights, sentiment, recommendations):
+        return {
+            "Short-term Actions (0-12 months)": self._generate_short_term_actions(insights, sentiment),
+            "Medium-term Strategy (1-2 years)": self._generate_medium_term_strategy(recommendations),
+            "Long-term Vision (3-5 years)": self._generate_long_term_vision(insights, recommendations)
+        }
+
+    def _generate_short_term_actions(self, insights, sentiment):
+        prompt = f"Generate short-term actions based on: {insights[:100]} Sentiment: {sentiment}"
+        inputs = self.t5_tokenizer(prompt, return_tensors="pt").to(self.device)
+        outputs = self.t5_model.generate(inputs["input_ids"], max_length=100)
+        return self.t5_tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+    def _generate_medium_term_strategy(self, recommendations):
+        prompt = f"Generate medium-term strategy based on: {recommendations}"
+        inputs = self.t5_tokenizer(prompt, return_tensors="pt").to(self.device)
+        outputs = self.t5_model.generate(inputs["input_ids"], max_length=100)
+        return self.t5_tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+    def _generate_long_term_vision(self, insights, recommendations):
+        prompt = f"Generate long-term vision based on: {insights[:100]} {recommendations[:100]}"
+        inputs = self.t5_tokenizer(prompt, return_tensors="pt").to(self.device)
+        outputs = self.t5_model.generate(inputs["input_ids"], max_length=100)
+        return self.t5_tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+# Create Gradio interface
+def create_gradio_interface():
+    analyzer = FinancialAnalyzer()
+    
+    def analyze_files(balance_sheet, income_statement, file_type):
+        return analyzer.analyze_financials(balance_sheet, income_statement, file_type)
+
+    iface = gr.Interface(
+        fn=analyze_files,
+        inputs=[
+            gr.File(label="Upload Balance Sheet"),
+            gr.File(label="Upload Income Statement"),
+            gr.Radio(
+                choices=["csv", "excel", "markdown"],
+                label="File Type",
+                value="csv"
+            )
+        ],
+        outputs=gr.Textbox(label="Analysis Results", lines=20),
+        title="Financial Statement Analyzer",
+        description="Upload your financial statements (Balance Sheet and Income Statement) to get AI-powered insights, recommendations, and strategic roadmap.",
+        examples=[
+            ["balance_sheet.csv", "income_statement.csv", "csv"],
+            ["balance_sheet.xlsx", "income_statement.xlsx", "excel"],
+            ["balance_sheet.md", "income_statement.md", "markdown"]
+        ]
+    )
+    
+    return iface
+
+if __name__ == "__main__":
+    iface = create_gradio_interface()
+    iface.launch()