Create app.py

app.py

@@ -0,0 +1,336 @@
+import gradio as gr
+import yfinance as yf
+import numpy as np
+import pandas as pd
+import json
+from scipy import signal
+from scipy.fft import fft, fftfreq
+from scipy.stats import norm, gaussian_kde
+import warnings
+from datetime import datetime, timedelta
+from skopt import gp_minimize
+from skopt.space import Real, Integer
+from skopt.utils import use_named_args
+
+warnings.filterwarnings('ignore')
+
+# ==============================================================================
+# 1. SİNYAL ÜRETİCİ (İŞÇİ)
+# Sadece verilen parametrelere göre sinyal üreten saf DSP modülü.
+# ==============================================================================
+class SpectralStockAnalyzer:
+    def __init__(self, data, interval='1d'):
+        self.data = data
+        self.interval = interval
+        self.filtered_prices = None
+        self.momentum_signal = None
+        self.volatility = self.calculate_volatility()
+        self.adx = self.calculate_adx()
+
+    def calculate_volatility(self, window=20):
+        returns = self.data['Close'].pct_change()
+        annualization_factor = 52 if self.interval == '1wk' else 252
+        vol = returns.rolling(window=window).std() * np.sqrt(annualization_factor)
+        return vol.fillna(method='bfill').fillna(method='ffill')
+
+    def calculate_adx(self, lookback=14):
+        high, low, close = self.data['High'], self.data['Low'], self.data['Close']
+        tr = pd.concat([high - low, abs(high - close.shift()), abs(low - close.shift())], axis=1).max(axis=1)
+        up_move, down_move = high - high.shift(), low.shift() - low
+        plus_dm = pd.Series(np.where((up_move > down_move) & (up_move > 0), up_move, 0), index=self.data.index)
+        minus_dm = pd.Series(np.where((down_move > up_move) & (down_move > 0), down_move, 0), index=self.data.index)
+        
+        atr = tr.rolling(window=lookback).mean()
+        plus_di = 100 * (plus_dm.ewm(alpha=1/lookback, min_periods=lookback).mean() / atr)
+        minus_di = 100 * (minus_dm.ewm(alpha=1/lookback, min_periods=lookback).mean() / atr)
+        
+        dx = 100 * (abs(plus_di - minus_di) / (plus_di + minus_di).replace(0, 1))
+        adx = dx.ewm(alpha=1/lookback, min_periods=lookback).mean()
+        return adx.fillna(20)
+
+    def process_signal_chain(self, cutoff_freq, filter_order, momentum_thresh, price_thresh):
+        # 1. Filtreleme
+        prices = self.data['Close'].values
+        nyquist = 0.5
+        normalized_cutoff = max(0.01, min(cutoff_freq / nyquist, 0.99))
+        b, a = signal.butter(int(filter_order), normalized_cutoff, btype='low')
+        self.filtered_prices = signal.filtfilt(b, a, prices)
+        
+        # 2. Momentum Sinyali
+        window_size=30
+        momentum_values = []
+        safe_window_size = min(window_size, len(self.filtered_prices) - 1)
+        for i in range(safe_window_size, len(self.filtered_prices)):
+            window_data = self.filtered_prices[i - safe_window_size:i]
+            window_spectrum = fft(window_data)
+            magnitude = np.abs(window_spectrum)
+            dominant_idx = np.argmax(magnitude[1:]) + 1 if len(magnitude) > 1 else 0
+            phase = np.angle(window_spectrum[dominant_idx])
+            momentum = np.cos(phase)
+            momentum_values.append(momentum)
+        self.momentum_signal = np.concatenate([np.zeros(safe_window_size), np.array(momentum_values)])
+
+        # 3. Alım Sinyallerini Tespit Et
+        signals = []
+        for i in range(5, len(self.momentum_signal)):
+            if i >= len(self.filtered_prices) or i >= len(self.data): continue
+            
+            momentum_condition = (self.momentum_signal[i - 1] < momentum_thresh and
+                                  self.momentum_signal[i] > self.momentum_signal[i - 1])
+            recent_change = (self.filtered_prices[i] - self.filtered_prices[i - 5]) / self.filtered_prices[i - 5]
+            price_condition = recent_change < price_thresh
+            
+            if momentum_condition and price_condition:
+                signal_date = self.data.index[i]
+                signals.append({
+                    'date': signal_date,
+                    'price': self.data['Close'].loc[signal_date],
+                    'context': {
+                        'volatility': self.volatility.loc[signal_date],
+                        'adx': self.adx.loc[signal_date],
+                        'momentum': self.momentum_signal[i]
+                    }
+                })
+        return signals
+
+# ==============================================================================
+# 2. ÖĞRENME MOTORU (ÖĞRETMEN)
+# Sinyalleri doğrular, başarılı olanların paternini öğrenir.
+# ==============================================================================
+class SignalFeedbackEngine:
+    def __init__(self, full_data, interval='1d'):
+        self.full_data = full_data
+        self.interval = interval
+        self.param_space = [
+            Real(0.01, 0.25, name='cutoff_freq'), Integer(3, 6, name='filter_order'),
+            Real(-0.9, -0.1, name='momentum_thresh'), Real(-0.15, -0.02, name='price_thresh')]
+        self.successful_signal_profile = None
+
+    def validate_signals(self, signals, forward_periods=20, success_threshold=0.01):
+        validated = []
+        for signal in signals:
+            future_data = self.full_data.loc[signal['date']:]
+            if len(future_data) > forward_periods:
+                end_price = future_data['Close'].iloc[forward_periods]
+                ret = (end_price - signal['price']) / signal['price']
+                signal['outcome'] = {
+                    'return': ret,
+                    'is_success': ret > success_threshold
+                }
+                validated.append(signal)
+        return validated
+
+    def objective_function(self):
+        @use_named_args(self.param_space)
+        def evaluate_params(**params):
+            analyzer = SpectralStockAnalyzer(self.full_data, self.interval)
+            signals = analyzer.process_signal_chain(**params)
+            
+            if len(signals) < 5: return 10 # Çok az sinyal varsa cezalandır
+
+            validated_signals = self.validate_signals(signals)
+            if not validated_signals: return 10
+
+            successes = [s for s in validated_signals if s['outcome']['is_success']]
+            
+            success_rate = len(successes) / len(validated_signals)
+            if success_rate < 0.5: return 5 # Başarı oranı düşükse cezalandır
+
+            # Başarılı sinyallerin ortalama getirisini ve riskini hesaba katan bir skor
+            avg_success_return = np.mean([s['outcome']['return'] for s in successes]) if successes else 0
+            
+            # Kalite Skoru: Başarı oranı * Ortalama Getiri
+            quality_score = success_rate * avg_success_return
+            
+            return -quality_score # Optimizasyon minimize ettiği için negatifini alıyoruz
+        
+        return evaluate_params
+
+    def find_optimal_parameters(self):
+        print("Finding optimal parameters based on historical signal quality...")
+        objective = self.objective_function()
+        result = gp_minimize(func=objective, dimensions=self.param_space, n_calls=40, random_state=42, n_jobs=-1)
+        
+        best_params = {dim.name: val for dim, val in zip(self.param_space, result.x)}
+        print(f"Optimal parameters found with Quality Score: {-result.fun:.4f}")
+        return best_params
+
+    def learn_successful_signal_profile(self, optimal_params):
+        print("Learning the DNA of successful signals...")
+        analyzer = SpectralStockAnalyzer(self.full_data, self.interval)
+        signals = analyzer.process_signal_chain(**optimal_params)
+        validated_signals = self.validate_signals(signals)
+        
+        successes = [s for s in validated_signals if s['outcome']['is_success']]
+        if len(successes) < 5:
+            print("Not enough successful signals to build a reliable profile.")
+            self.successful_signal_profile = None
+            return
+
+        # Başarılı sinyallerin bağlam (context) verilerini topla
+        profile_data = {
+            'volatility': [s['context']['volatility'] for s in successes],
+            'adx': [s['context']['adx'] for s in successes]
+        }
+        
+        # Olasılık yoğunluk fonksiyonları ile paterni öğren
+        self.successful_signal_profile = {
+            'volatility_kde': gaussian_kde(profile_data['volatility']),
+            'adx_kde': gaussian_kde(profile_data['adx']),
+            'volatility_range': (np.min(profile_data['volatility']), np.max(profile_data['volatility'])),
+            'adx_range': (np.min(profile_data['adx']), np.max(profile_data['adx']))
+        }
+        print("Successful signal profile created.")
+
+    def get_confidence_score(self, current_context):
+        if not self.successful_signal_profile: return 0.5 # Profil yoksa nötr skor
+
+        # Mevcut durum, başarılı paternin ne kadar "içinde"?
+        # Yoğunluk fonksiyonundan olasılık alıyoruz
+        vol_score = self.successful_signal_profile['volatility_kde'].evaluate([current_context['volatility']])[0]
+        adx_score = self.successful_signal_profile['adx_kde'].evaluate([current_context['adx']])[0]
+        
+        # Skorları normalize etmek için maksimum yoğunluk değerlerini kullanabiliriz
+        # Basitlik için, şimdilik aralık kontrolü yapalım
+        norm_vol_score = np.interp(vol_score, [0, self.successful_signal_profile['volatility_kde'].pdf(self.successful_signal_profile['volatility_range']).max()], [0, 1])
+        norm_adx_score = np.interp(adx_score, [0, self.successful_signal_profile['adx_kde'].pdf(self.successful_signal_profile['adx_range']).max()], [0, 1])
+        
+        # İki skorun ortalamasını alarak nihai güven skorunu oluştur
+        confidence = (norm_vol_score + norm_adx_score) / 2
+        return confidence
+        
+# ==============================================================================
+# 3. ANA UYGULAMA VE ARAYÜZ
+# ==============================================================================
+def run_intelligent_analysis(stock_symbol, analysis_period, interval_choice):
+    if not stock_symbol: return "Please enter a stock symbol!", "...", None
+
+    interval_map = {"Günlük (Daily)": "1d", "Haftalık (Weekly)": "1wk"}
+    interval = interval_map[interval_choice]
+    
+    try:
+        ticker = yf.Ticker(stock_symbol.strip().upper())
+        full_data = ticker.history(period=analysis_period, interval=interval)
+        if len(full_data) < 150: return f"Insufficient data ({len(full_data)} points).", "...", None
+
+        status_msg = f"Data fetched: {len(full_data)} points ({interval_choice})\n"
+        
+        # 1. Öğrenme
+        engine = SignalFeedbackEngine(full_data, interval)
+        optimal_params = engine.find_optimal_parameters()
+        engine.learn_successful_signal_profile(optimal_params)
+        status_msg += "Learning from historical signals complete.\n"
+        
+        # 2. Canlı Analiz
+        analyzer = SpectralStockAnalyzer(full_data, interval)
+        all_signals = analyzer.process_signal_chain(**optimal_params)
+        
+        current_signal = None
+        # Son 5 gün içinde sinyal var mı diye kontrol et
+        if all_signals and (full_data.index[-1] - all_signals[-1]['date']).days < 5:
+            current_signal = all_signals[-1]
+            status_msg += "Potential signal detected in the current period.\n"
+        else:
+            status_msg += "No active signal in the current period.\n"
+
+        # 3. Raporlama
+        # ... Rapor ve JSON oluşturma ...
+        results = f"## INTELLIGENT ANALYSIS REPORT: {stock_symbol.upper()}\n"
+        results += "### Step 1: Learning from Past Performance\n"
+        results += f"The model analyzed past data to find parameters that maximize **Signal Quality Score** (Success Rate × Avg. Return).\n"
+        results += "**Optimal Parameters Found:**\n"
+        for key, val in optimal_params.items():
+            results += f"- **{key.replace('_', ' ').title()}:** {val:.4f}\n"
+
+        if engine.successful_signal_profile:
+            vol_range = engine.successful_signal_profile['volatility_range']
+            adx_range = engine.successful_signal_profile['adx_range']
+            results += "\n**Learned Profile of a 'Good' Signal (DNA):**\n"
+            results += f"- **Optimal Volatility Range:** {vol_range[0]:.2f} - {vol_range[1]:.2f}\n"
+            results += f"- **Optimal ADX (Trend Strength) Range:** {adx_range[0]:.1f} - {adx_range[1]:.1f}\n"
+
+        results += "\n### Step 2: Current Market Analysis\n"
+        if current_signal:
+            confidence = engine.get_confidence_score(current_signal['context'])
+            current_signal['confidence_score'] = confidence
+            
+            color = "green" if confidence > 0.7 else "orange" if confidence > 0.5 else "red"
+            
+            results += f"**POTENTIAL BUY SIGNAL DETECTED** on {current_signal['date'].strftime('%Y-%m-%d')}\n"
+            results += f"> **Confidence Score:** <span style='color:{color}; font-weight:bold;'>{confidence:.1%}</span>\n"
+            results += f"> This score indicates how closely the current market conditions match the DNA of historical successful signals.\n\n"
+            results += "**Current Market Context:**\n"
+            results += f"- **Volatility:** {current_signal['context']['volatility']:.2f} (Historical sweet spot: {vol_range[0]:.2f}-{vol_range[1]:.2f})\n"
+            results += f"- **ADX:** {current_signal['context']['adx']:.1f} (Historical sweet spot: {adx_range[0]:.1f}-{adx_range[1]:.1f})\n"
+        else:
+            results += "**No active buy signal detected in the last 5 periods.** The model is waiting for market conditions to align with its learned success profile.\n"
+        
+        # JSON oluşturma
+        json_output = {
+            "symbol": stock_symbol.upper(),
+            "analysis_timestamp": datetime.now().isoformat(),
+            "optimal_parameters": optimal_params,
+            "learned_profile": {
+                'volatility_range': engine.successful_signal_profile['volatility_range'] if engine.successful_signal_profile else None,
+                'adx_range': engine.successful_signal_profile['adx_range'] if engine.successful_signal_profile else None
+            },
+            "current_signal": current_signal,
+            "historical_signals_with_optimal_params": all_signals
+        }
+        
+        # Datetime ve numpy türlerini serileştirilebilir hale getir
+        def json_converter(o):
+            if isinstance(o, (datetime, pd.Timestamp)): return o.isoformat()
+            if isinstance(o, (np.integer, np.int64)): return int(o)
+            if isinstance(o, (np.floating, np.float64)): return float(o)
+            if isinstance(o, np.ndarray): return o.tolist()
+            if np.isnan(o): return None
+            return o
+
+        return status_msg, results, json.dumps(json_output, default=json_converter, indent=2)
+
+    except Exception as e:
+        import traceback
+        return f"An error occurred: {e}\n{traceback.format_exc()}", "...", None
+
+
+def create_interface():
+    with gr.Blocks(theme=gr.themes.Soft(), title="Intelligent Spectral Analysis") as demo:
+        gr.HTML("""<div style="text-align: center; background: linear-gradient(90deg, #1A2980 0%, #26D0CE 100%); color: white; padding: 25px; border-radius: 8px;">
+            <h1>Intelligent Spectral Analyzer</h1>
+            <p>Self-Learning Quantitative Model with Signal Feedback & Pattern Recognition</p>
+        </div>""")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                stock_input = gr.Textbox(label="Stock Symbol", placeholder="e.g., NVDA, GOOGL, TSLA")
+                period_input = gr.Dropdown(label="Analysis Period", choices=["1y", "2y", "5y", "10y"], value="5y")
+                interval_input = gr.Dropdown(label="Analysis Interval", choices=["Günlük (Daily)", "Haftalık (Weekly)"], value="Günlük (Daily)")
+                analyze_btn = gr.Button("START INTELLIGENT ANALYSIS", variant="primary")
+                status_output = gr.Textbox(label="Process Log", interactive=False, lines=15)
+            
+            with gr.Column(scale=2):
+                results_output = gr.Markdown(value="Analysis report will appear here...")
+                with gr.Accordion("Show Raw JSON Output for Integration", open=False):
+                    json_output_display = gr.JSON(label="JSON Data")
+
+        analyze_btn.click(
+            fn=run_intelligent_analysis,
+            inputs=[stock_input, period_input, interval_input],
+            outputs=[status_output, results_output, json_output_display]
+        )
+        
+        gr.HTML("""<div style="margin-top: 20px; padding: 15px; background-color: #f2f2f2; border-radius: 8px;">
+            <h4>How It Works (Self-Learning Logic):</h4>
+            <ol>
+                <li><strong>Historical Simulation:</strong> The model runs its DSP strategy on past data with many different parameter sets.</li>
+                <li><strong>Signal Validation:</strong> It checks the outcome of every historical signal it generated. Signals that led to profit are marked 'Successful'.</li>
+                <li><strong>Pattern Recognition (Learning):</strong> It analyzes all 'Successful' signals to find their common characteristics (the "DNA"). What was the market volatility and trend strength like when they occurred?</li>
+                <li><strong>Intelligent Prediction:</strong> It uses the parameters that produced the best historical signals to analyze the current market. If a new signal appears, it's compared against the learned 'DNA' to generate a final <strong>Confidence Score</strong>.</li>
+            </ol>
+        </div>""")
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(share=True)