Create app.py

app.py

@@ -0,0 +1,194 @@
+import gradio as gr
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+from transformers import (
+    DonutProcessor, 
+    VisionEncoderDecoderModel,
+    pipeline
+)
+import json
+
+class CryptoChartAnalyzer:
+    def __init__(self):
+        # Cihaz olarak CPU'yu kullanıyoruz
+        self.device = "cpu"
+        
+        # Donut Model for Chart Understanding
+        self.processor = DonutProcessor.from_pretrained("naver-clova-ix/donut-base-finetuned-cord-v2")
+        self.donut_model = VisionEncoderDecoderModel.from_pretrained(
+            "naver-clova-ix/donut-base-finetuned-cord-v2"
+        ).to(self.device)
+
+        # Financial LLM Pipeline (CPU için)
+        self.fin_llm = pipeline(
+            "text-generation",
+            model="mistralai/Mistral-7B-Instruct-v0.2",
+            device=self.device
+        )
+
+    def detect_trend_lines(self, gray_img):
+        """Detect trend lines using OpenCV."""
+        edges = cv2.Canny(gray_img, 50, 150)
+        lines = cv2.HoughLinesP(edges, 1, np.pi/180, threshold=50, 
+                                minLineLength=50, maxLineGap=10)
+        return len(lines) if lines is not None else 0
+
+    def detect_support_resistance(self, gray_img):
+        """Detect support and resistance levels."""
+        blur = cv2.GaussianBlur(gray_img, (5, 5), 0)
+        _, thresh = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+        contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        return len(contours)
+
+    def detect_fibonacci_levels(self, gray_img):
+        """Basic Fibonacci retracement detection (mock)."""
+        height, _ = gray_img.shape
+        levels = [0, 0.236, 0.382, 0.5, 0.618, 1]
+        return [int(height * level) for level in levels]
+
+    def detect_harmonic_patterns(self, img):
+        """Detect harmonic patterns in the chart (mock logic)."""
+        patterns = [{"pattern": "ABCD", "confidence": 0.85}, {"pattern": "Gartley", "confidence": 0.78}]
+        return patterns
+
+    def detect_chart_patterns(self, gray_img):
+        """Detect classic chart patterns: double top, double bottom, triangles."""
+        # Placeholder logic for detecting patterns
+        patterns = [
+            {"pattern": "Double Top", "confidence": 0.88},
+            {"pattern": "Double Bottom", "confidence": 0.81},
+            {"pattern": "Head and Shoulders", "confidence": 0.76},
+            {"pattern": "Symmetrical Triangle", "confidence": 0.83}
+        ]
+        return patterns
+
+    def detect_technical_features(self, image):
+        """Combine all detection methods."""
+        img = np.array(image)
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        
+        return {
+            "trend_lines": self.detect_trend_lines(gray),
+            "key_levels": self.detect_support_resistance(gray),
+            "fibonacci_levels": self.detect_fibonacci_levels(gray),
+            "harmonic_patterns": self.detect_harmonic_patterns(img),
+            "chart_patterns": self.detect_chart_patterns(gray)
+        }
+
+    def analyze_chart_content(self, image):
+        """Analyze chart content using the Donut model."""
+        task_prompt = "<s_chart_analysis>"
+        prepared_img = self.processor(image, return_tensors="pt").pixel_values.to(self.device)
+        
+        decoder_input_ids = self.processor.tokenizer(
+            task_prompt, add_special_tokens=False, return_tensors="pt"
+        ).input_ids.to(self.device)
+
+        outputs = self.donut_model.generate(
+            prepared_img,
+            decoder_input_ids=decoder_input_ids,
+            max_length=512,
+            early_stopping=True,
+            pad_token_id=self.processor.tokenizer.pad_token_id,
+            eos_token_id=self.processor.tokenizer.eos_token_id,
+            use_cache=True,
+            num_beams=3,
+            temperature=0.3,
+            output_scores=True
+        )
+
+        return self.processor.decode(outputs[0].squeeze().cpu().numpy())
+
+    def generate_analysis(self, image, question):
+        """Complete analysis pipeline."""
+        # Detect features
+        technical_features = self.detect_technical_features(image)
+        chart_description = self.analyze_chart_content(image)
+        
+        # Prompt engineering for analysis
+        analysis_prompt = f"""
+        [ROLE] Senior Crypto Technical Analyst with 15 years of experience.
+        [CHART DESCRIPTION] {chart_description}
+        [TECHNICAL FEATURES]
+        - Trend Lines: {technical_features['trend_lines']}
+        - Key Levels: {technical_features['key_levels']}
+        - Fibonacci Levels: {technical_features['fibonacci_levels']}
+        - Harmonic Patterns: {technical_features['harmonic_patterns']}
+        - Chart Patterns: {technical_features['chart_patterns']}
+        
+        [ANALYSIS TASKS]
+        1. Detailed candlestick pattern analysis.
+        2. Price action evaluation.
+        3. Trend analysis with confidence levels.
+        4. Support/Resistance levels identification.
+        5. Risk/Reward ratio calculation.
+        6. {question}
+        
+        [RESPONSE FORMAT]
+        {{
+          "analysis": {{
+            "candlestick_patterns": [{{"pattern": "...", "location": "...", "confidence": 0.X}}],
+            "trend_analysis": {{"direction": "...", "strength": "...", "confidence": 0.X}},
+            "key_levels": {{"support": [...], "resistance": [...]}},
+            "price_action": "...",
+            "fibonacci_levels": [...],
+            "harmonic_patterns": [...],
+            "chart_patterns": [...]
+          }},
+          "forecast": {{
+            "short_term": "...",
+            "medium_term": "..."
+          }}
+        }}
+        """
+        
+        # LLM analysis
+        response = self.fin_llm(
+            analysis_prompt,
+            max_new_tokens=1024,
+            temperature=0.2,
+            do_sample=True,
+            top_p=0.9
+        )[0]['generated_text']
+
+        # Attempt to parse JSON
+        try:
+            return json.loads(response)
+        except json.JSONDecodeError:
+            return {"error": "Failed to parse LLM response. Check the prompt or model output."}
+
+# Initialize analyzer
+analyzer = CryptoChartAnalyzer()
+
+# Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🔥 **Crypto Technical Analysis Pro**")
+    
+    with gr.Row():
+        with gr.Column():
+            image_input = gr.Image(type="pil", label="Upload Chart")
+            question_input = gr.Textbox(
+                label="Analysis Request",
+                value="Identify key reversal patterns and calculate potential price targets"
+            )
+            submit_btn = gr.Button("Analyze", variant="primary")
+        
+        with gr.Column():
+            analysis_output = gr.JSON(label="Technical Analysis Report")
+    
+    examples = [
+        ["sample_chart1.png", "Analyze bullish/bearish divergence in RSI"],
+        ["sample_chart2.jpg", "Identify head and shoulders pattern"]
+    ]
+    
+    gr.Examples(examples=examples, inputs=[image_input, question_input])
+    
+    submit_btn.click(
+        fn=analyzer.generate_analysis,
+        inputs=[image_input, question_input],
+        outputs=analysis_output
+    )
+
+app.launch(debug=False)