Upload folder using huggingface_hub

app.py

@@ -0,0 +1,35 @@
+"""
+CandleFusion Demo App for Hugging Face Spaces
+Entry point for the Gradio demo
+"""
+
+import os
+import sys
+
+# Since HF Spaces runs from the demo directory, we need to add the parent directory
+# to access the training modules
+current_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.dirname(current_dir)
+sys.path.append(parent_dir)
+
+# Import and run the demo
+try:
+    from gradio_demo import main
+    
+    if __name__ == "__main__":
+        main()
+except Exception as e:
+    print(f"Error launching demo: {e}")
+    # Fallback: create a simple error page
+    import gradio as gr
+    
+    def error_interface():
+        return gr.Interface(
+            fn=lambda x: f"Demo temporarily unavailable. Error: {str(e)}",
+            inputs=gr.Textbox(label="Input"),
+            outputs=gr.Textbox(label="Output"),
+            title="CandleFusion Demo - Error"
+        )
+    
+    error_demo = error_interface()
+    error_demo.launch(server_name="0.0.0.0")

gradio_demo.py

@@ -0,0 +1,218 @@
+import gradio as gr
+import torch
+import sys
+import os
+from PIL import Image
+import numpy as np
+from huggingface_hub import hf_hub_download
+
+# Import spaces for GPU support on Hugging Face Spaces
+try:
+    import spaces
+    HF_SPACES = True
+except ImportError:
+    HF_SPACES = False
+    # Create a dummy decorator if not on Spaces
+    def spaces_gpu_decorator(func):
+        return func
+    spaces = type('spaces', (), {'GPU': spaces_gpu_decorator})()
+
+# Add parent directory to path to import our modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from training.model import CrossAttentionModel
+from transformers import BertTokenizer, ViTImageProcessor
+
+class CandleFusionDemo:
+    def __init__(self, model_path=None):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Load model from Hugging Face
+        self.model = CrossAttentionModel()
+        
+        try:
+            # Download model from Hugging Face Hub
+            print("📥 Downloading model from Hugging Face...")
+            model_file = hf_hub_download(
+                repo_id="tuankg1028/candlefusion",
+                filename="pytorch_model.bin",
+                cache_dir="./model_cache"
+            )
+            
+            # Load the downloaded model
+            self.model.load_state_dict(torch.load(model_file, map_location=self.device))
+            print(f"✅ Model loaded from Hugging Face: tuankg1028/candlefusion")
+            
+        except Exception as e:
+            print(f"❌ Error loading model from Hugging Face: {str(e)}")
+            print("⚠️ Using untrained model instead.")
+        
+        self.model.to(self.device)
+        self.model.eval()
+        
+        # Initialize processors
+        self.tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
+        self.processor = ViTImageProcessor.from_pretrained("google/vit-base-patch16-224")
+        
+        # Class labels
+        self.class_labels = ["Bearish", "Bullish"]
+    
+    def preprocess_inputs(self, image, text):
+        """Preprocess image and text inputs for the model"""
+        # Process image
+        if image is None:
+            raise ValueError("Please upload a candlestick chart image")
+        
+        image = Image.fromarray(image).convert("RGB")
+        image_inputs = self.processor(images=image, return_tensors="pt")
+        pixel_values = image_inputs["pixel_values"].to(self.device)
+        
+        # Process text
+        if not text.strip():
+            text = "Market analysis"  # Default text if empty
+        
+        text_inputs = self.tokenizer(
+            text,
+            return_tensors="pt",
+            truncation=True,
+            padding="max_length",
+            max_length=64
+        )
+        input_ids = text_inputs["input_ids"].to(self.device)
+        attention_mask = text_inputs["attention_mask"].to(self.device)
+        
+        return pixel_values, input_ids, attention_mask
+    
+    @spaces.GPU
+    def predict(self, image, text):
+        """Make prediction using the model"""
+        try:
+            # Preprocess inputs
+            pixel_values, input_ids, attention_mask = self.preprocess_inputs(image, text)
+            
+            # Model prediction
+            with torch.no_grad():
+                outputs = self.model(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    pixel_values=pixel_values
+                )
+                
+                logits = outputs["logits"]
+                forecast = outputs["forecast"]
+                
+                # Get classification results
+                probabilities = torch.softmax(logits, dim=1)
+                predicted_class = torch.argmax(logits, dim=1).item()
+                confidence = probabilities[0][predicted_class].item()
+                
+                # Get price forecast
+                predicted_price = forecast.squeeze().item()
+                
+                # Format results
+                classification_result = f"**Prediction:** {self.class_labels[predicted_class]}\n"
+                classification_result += f"**Confidence:** {confidence:.2%}\n\n"
+                classification_result += "**Class Probabilities:**\n"
+                for i, (label, prob) in enumerate(zip(self.class_labels, probabilities[0])):
+                    classification_result += f"- {label}: {prob:.2%}\n"
+                
+                forecast_result = f"**Predicted Next Close Price:** ${predicted_price:.2f}"
+                
+                return classification_result, forecast_result
+                
+        except Exception as e:
+            error_msg = f"Error during prediction: {str(e)}"
+            return error_msg, error_msg
+
+def create_demo():
+    """Create and launch the Gradio demo"""
+    demo_instance = CandleFusionDemo()
+    
+    # Create Gradio interface
+    with gr.Blocks(title="CandleFusion - Candlestick Chart Analysis", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 🕯️ CandleFusion Demo
+        
+        Upload a candlestick chart image and provide market context to get:
+        - **Market Direction Prediction** (Bullish/Bearish)
+        - **Next Close Price Forecast**
+        
+        This model combines visual analysis of candlestick charts with textual market context using BERT + ViT architecture.
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📊 Input")
+                
+                image_input = gr.Image(
+                    label="Candlestick Chart",
+                    type="numpy",
+                    height=300
+                )
+                
+                text_input = gr.Textbox(
+                    label="Market Context",
+                    placeholder="Enter market analysis, news, or context (e.g., 'Strong volume with positive earnings report')",
+                    lines=3,
+                    value="Technical analysis of price action"
+                )
+                
+                predict_btn = gr.Button("🔮 Analyze Chart", variant="primary")
+                
+                gr.Markdown("""
+                ### 💡 Tips:
+                - Upload clear candlestick chart images
+                - Provide relevant market context
+                - Charts should show recent price action
+                """)
+            
+            with gr.Column(scale=1):
+                gr.Markdown("### 📈 Results")
+                
+                classification_output = gr.Markdown(
+                    value="Upload an image and click 'Analyze Chart' to see prediction"
+                )
+                
+                forecast_output = gr.Markdown(
+                    value=""
+                )
+        
+        # Example section
+        gr.Markdown("### 📚 Example")
+        gr.Examples(
+            examples=[
+                ["example_chart.png", "Strong bullish momentum with high volume"],
+                ["example_chart2.png", "Bearish reversal pattern forming"]
+            ],
+            inputs=[image_input, text_input],
+            label="Try these examples:"
+        )
+        
+        # Connect the prediction function
+        predict_btn.click(
+            fn=demo_instance.predict,
+            inputs=[image_input, text_input],
+            outputs=[classification_output, forecast_output]
+        )
+        
+        gr.Markdown("""
+        ---
+        **Note:** This is a demo model. For production trading decisions, always consult with financial professionals and use additional analysis tools.
+        """)
+    
+    return demo
+
+def main():
+    """Main function to launch the demo"""
+    try:
+        demo = create_demo()
+        # Launch with server_name for compatibility on HF Spaces
+        demo.launch(server_name="0.0.0.0")
+    except Exception as e:
+        print(f"Failed to launch Gradio demo: {e}")
+        # Fallback launch with minimal configuration
+        demo = create_demo()
+        demo.launch(server_name="0.0.0.0")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=5.32.0
+torch>=1.9.0
+transformers>=4.20.0
+Pillow>=8.0.0
+numpy>=1.21.0
+pandas>=1.3.0
+huggingface_hub>=0.16.0

training/dataset.py

@@ -0,0 +1,57 @@
+# dataset.py
+
+import os
+import sys
+import torch
+from torch.utils.data import Dataset
+from PIL import Image
+import pandas as pd
+from transformers import BertTokenizer, ViTImageProcessor
+
+class CandlestickDataset(Dataset):
+    def __init__(self, csv_path: str, image_size: int = 224):
+        """
+        Args:
+            csv_path (str): Path to CSV with image_path, text, label
+            image_size (int): Size to resize chart images to (default 224)
+        """
+        self.data = pd.read_csv(csv_path)
+        self.tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
+        self.processor = ViTImageProcessor.from_pretrained("google/vit-base-patch16-224")
+        self.image_size = image_size
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        row = self.data.iloc[idx]
+
+        # === Load and preprocess image ===
+        image_path = row["image_path"]
+        image = Image.open(image_path).convert("RGB")
+        image_inputs = self.processor(images=image, return_tensors="pt")
+        pixel_values = image_inputs["pixel_values"].squeeze(0)  # (3, 224, 224)
+
+        # === Tokenize text ===
+        text = row["text"]
+        text_inputs = self.tokenizer(
+            text,
+            return_tensors="pt",
+            truncation=True,
+            padding="max_length",
+            max_length=64  # can be adjusted
+        )
+        input_ids = text_inputs["input_ids"].squeeze(0)
+        attention_mask = text_inputs["attention_mask"].squeeze(0)
+
+        # === Label ===
+        label = torch.tensor(row["label"], dtype=torch.long)
+        next_close = torch.tensor(row["next_close"], dtype=torch.float)
+
+        return {
+            "pixel_values": pixel_values,
+            "input_ids": input_ids,
+            "attention_mask": attention_mask,
+            "label": label,
+            "next_close": next_close
+        }

training/main.py

@@ -0,0 +1,57 @@
+import argparse
+import pandas as pd
+import os
+
+from dataset import CandlestickDataset
+from model import CrossAttentionModel
+from train import train
+
+from torch.utils.data import DataLoader
+
+def main():
+    parser = argparse.ArgumentParser(description="Train candlestick classifier using BERT + ViT")
+    parser.add_argument("--data_dir", type=str, default="../data", help="Directory containing dataset")
+    parser.add_argument("--batch_size", type=int, default=8)
+    parser.add_argument("--epochs", type=int, default=3)
+    parser.add_argument("--lr", type=float, default=2e-5)
+    parser.add_argument("--device", type=str, default="cuda")
+    parser.add_argument("--push_to_hub", action="store_true", help="Push model to Hugging Face Hub")
+    parser.add_argument("--hub_model_id", type=str, help="Hugging Face model ID (e.g., 'username/candlefusion')")
+    parser.add_argument("--hub_token", type=str, help="Hugging Face token (or set HF_TOKEN env var)")
+    args = parser.parse_args()
+
+    # === Paths
+    index_csv = os.path.join(args.data_dir, "dataset_index.csv")
+    
+    if not os.path.exists(index_csv):
+        print(f"❌ Dataset index not found at {index_csv}")
+        print("Please run the build_dataset script first.")
+        return
+
+    # === Create checkpoints directory
+    os.makedirs("./checkpoints", exist_ok=True)
+
+    # === Dataset & Loader
+    dataset = CandlestickDataset(csv_path=index_csv)
+    dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True)
+
+    # === Model
+    model = CrossAttentionModel()
+
+    # === Get HF token from env if not provided
+    hub_token = args.hub_token or os.getenv("HF_TOKEN")
+
+    # === Train
+    train(
+        model, 
+        dataloader, 
+        epochs=args.epochs, 
+        lr=args.lr, 
+        device=args.device,
+        push_to_hub=args.push_to_hub,
+        hub_model_id=args.hub_model_id,
+        hub_token=hub_token
+    )
+
+if __name__ == "__main__":
+    main()

training/model.py

@@ -0,0 +1,60 @@
+# model.py
+
+import torch
+import torch.nn as nn
+from transformers import BertModel, ViTModel
+
+class CrossAttentionModel(nn.Module):
+    def __init__(self, 
+                 text_model_name="bert-base-uncased",
+                 image_model_name="google/vit-base-patch16-224", 
+                 hidden_dim=768,
+                 num_classes=2):
+        super().__init__()
+
+        # Encoders
+        self.bert = BertModel.from_pretrained(text_model_name)
+        self.vit = ViTModel.from_pretrained(image_model_name)
+
+        # Cross-Attention layer
+        self.cross_attention = nn.MultiheadAttention(embed_dim=hidden_dim, num_heads=8, batch_first=True)
+
+        # Classification Head
+        self.classifier = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(hidden_dim, num_classes)
+        )
+
+        # Forecasting Head (regression)
+        self.regressor = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(hidden_dim, 1)  # Predict next closing price
+        )
+
+    def forward(self, input_ids, attention_mask, pixel_values):
+        # === Text Encoding ===
+        text_outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        text_cls = text_outputs.last_hidden_state[:, 0:1, :]  # (B, 1, H)
+
+        # === Image Encoding ===
+        image_outputs = self.vit(pixel_values=pixel_values)
+        image_tokens = image_outputs.last_hidden_state[:, 1:, :]  # skip CLS token
+
+        # === Cross-Attention ===
+        fused_cls, _ = self.cross_attention(
+            query=text_cls,
+            key=image_tokens,
+            value=image_tokens
+        )  # (B, 1, H)
+
+        fused_cls = fused_cls.squeeze(1)  # (B, H)
+
+        # === Dual Heads ===
+        logits = self.classifier(fused_cls)     # Classification
+        forecast = self.regressor(fused_cls)    # Regression (next price)
+
+        return {"logits": logits, "forecast": forecast}

training/train.py

@@ -0,0 +1,248 @@
+# train.py
+
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+from transformers import get_scheduler
+from tqdm import tqdm
+import os
+
+from dataset import CandlestickDataset
+from model import CrossAttentionModel
+
+def train(model, dataloader, val_loader=None, epochs=5, lr=2e-5, alpha=0.5, device="cuda", 
+          push_to_hub=False, hub_model_id=None, hub_token=None):
+    device = torch.device(device if torch.cuda.is_available() else "cpu")
+    model.to(device)
+
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+    total_steps = len(dataloader) * epochs
+    scheduler = get_scheduler("linear", optimizer, num_warmup_steps=0, num_training_steps=total_steps)
+
+    loss_fn_cls = nn.CrossEntropyLoss()
+    loss_fn_reg = nn.MSELoss()
+
+    for epoch in range(epochs):
+        model.train()
+        total_loss = 0
+        total_cls_loss = 0
+        total_reg_loss = 0
+
+        progress_bar = tqdm(dataloader, desc=f"Epoch {epoch+1}/{epochs}")
+
+        for batch in progress_bar:
+            input_ids = batch["input_ids"].to(device)
+            attention_mask = batch["attention_mask"].to(device)
+            pixel_values = batch["pixel_values"].to(device)
+            labels = batch["label"].to(device)
+            target_price = batch["next_close"].to(device)  # shape: (B,)
+
+            optimizer.zero_grad()
+
+            outputs = model(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                pixel_values=pixel_values
+            )
+
+            logits = outputs["logits"]
+            forecast = outputs["forecast"].squeeze(1)  # shape: (B,)
+
+            loss_cls = loss_fn_cls(logits, labels)
+            loss_reg = loss_fn_reg(forecast, target_price)
+            loss = loss_cls + alpha * loss_reg
+
+            loss.backward()
+            optimizer.step()
+            scheduler.step()
+
+            total_loss += loss.item()
+            total_cls_loss += loss_cls.item()
+            total_reg_loss += loss_reg.item()
+
+            progress_bar.set_postfix(loss=loss.item(), cls=loss_cls.item(), reg=loss_reg.item())
+
+        avg_loss = total_loss / len(dataloader)
+        print(f"✅ Epoch {epoch+1} done | Total Loss: {avg_loss:.4f} | CLS: {total_cls_loss/len(dataloader):.4f} | REG: {total_reg_loss/len(dataloader):.4f}")
+
+        if val_loader:
+            evaluate(model, val_loader, device)
+
+    torch.save(model.state_dict(), "./checkpoints/candlefusion_model.pt")
+    print("✅ Model saved to ./checkpoints/candlefusion_model.pt")
+    
+    # Push to Hugging Face Hub if requested
+    if push_to_hub and hub_model_id:
+        try:
+            from huggingface_hub import HfApi, Repository
+            import json
+            
+            # Login to HF Hub
+            if hub_token:
+                from huggingface_hub import login
+                login(token=hub_token)
+            
+            # Create model card and config
+            model_card_content = f"""
+---
+license: apache-2.0
+tags:
+- pytorch
+- candlestick
+- financial-analysis
+- multimodal
+- bert
+- vit
+- cross-attention
+- trading
+- forecasting
+---
+
+# CandleFusion Model
+
+A multimodal financial analysis model that combines textual market sentiment with visual candlestick patterns for enhanced trading signal prediction and price forecasting.
+
+## Architecture Overview
+
+### Core Components
+- **Text Encoder**: BERT (bert-base-uncased) for processing market sentiment and news
+- **Vision Encoder**: Vision Transformer (ViT-base-patch16-224) for candlestick pattern recognition
+- **Cross-Attention Fusion**: Multi-head attention mechanism (8 heads, 768 dim) for text-image integration
+- **Dual Task Heads**: 
+  - Classification head for trading signals (buy/sell/hold)
+  - Regression head for next closing price prediction
+
+### Data Flow
+1. **Text Processing**: Market sentiment -> BERT -> CLS token (768-dim)
+2. **Image Processing**: Candlestick charts -> ViT -> Patch embeddings (197 tokens, 768-dim each)
+3. **Cross-Modal Fusion**: Text CLS as query, Image patches as keys/values -> Fused representation
+4. **Dual Predictions**: 
+   - Fused features -> Classification head -> Trading signal logits
+   - Fused features -> Regression head -> Price forecast
+
+### Model Specifications
+- **Input Text**: Tokenized to max 64 tokens
+- **Input Images**: Resized to 224x224 RGB
+- **Hidden Dimension**: 768 (consistent across encoders)
+- **Output Classes**: {2} (binary: bullish/bearish)
+- **Dropout**: 0.3 in both heads
+
+## Training Details
+- **Epochs**: {epochs}
+- **Learning Rate**: {lr}
+- **Loss Function**: CrossEntropy (classification) + MSE (regression)
+- **Loss Weight (alpha)**: {alpha} for regression term
+- **Optimizer**: AdamW with linear scheduling
+
+## Usage
+```python
+from model import CrossAttentionModel
+import torch
+
+# Load model
+model = CrossAttentionModel()
+model.load_state_dict(torch.load("pytorch_model.bin"))
+model.eval()
+
+# Inference
+outputs = model(input_ids, attention_mask, pixel_values)
+trading_signals = outputs["logits"]
+price_forecast = outputs["forecast"]
+```
+
+## Performance
+The model simultaneously optimizes for:
+- **Classification Task**: Trading signal accuracy
+- **Regression Task**: Price prediction MSE
+
+This dual-task approach enables the model to learn both categorical market direction and continuous price movements.
+"""
+            
+            config = {
+                "model_type": "candlefusion",
+                "architecture": "bert+vit+cross_attention",
+                "num_labels": 3,
+                "epochs": epochs,
+                "learning_rate": lr,
+                "alpha": alpha
+            }
+            
+            # Create repository
+            api = HfApi()
+            api.create_repo(repo_id=hub_model_id, exist_ok=True)
+            
+            # Upload files
+            api.upload_file(
+                path_or_fileobj="./checkpoints/candlefusion_model.pt",
+                path_in_repo="pytorch_model.bin",
+                repo_id=hub_model_id,
+            )
+            
+            # Upload model card
+            with open("./checkpoints/README.md", "w", encoding="utf-8") as f:
+                f.write(model_card_content)
+            api.upload_file(
+                path_or_fileobj="./checkpoints/README.md",
+                path_in_repo="README.md",
+                repo_id=hub_model_id,
+            )
+            
+            # Upload config
+            with open("./checkpoints/config.json", "w") as f:
+                json.dump(config, f, indent=2)
+            api.upload_file(
+                path_or_fileobj="./checkpoints/config.json",
+                path_in_repo="config.json",
+                repo_id=hub_model_id,
+            )
+            
+            print(f"✅ Model pushed to Hugging Face Hub: https://huggingface.co/{hub_model_id}")
+            
+        except ImportError:
+            print("❌ huggingface_hub not installed. Install with: pip install huggingface_hub")
+        except Exception as e:
+            print(f"❌ Error pushing to Hub: {e}")
+
+def evaluate(model, dataloader, device="cuda"):
+    device = torch.device(device if torch.cuda.is_available() else "cpu")
+    model.eval()
+
+    correct = 0
+    total = 0
+    all_preds = []
+    all_labels = []
+    all_forecasts = []
+    all_targets = []
+
+    with torch.no_grad():
+        for batch in dataloader:
+            input_ids = batch["input_ids"].to(device)
+            attention_mask = batch["attention_mask"].to(device)
+            pixel_values = batch["pixel_values"].to(device)
+            labels = batch["label"].to(device)
+            target_price = batch["next_close"].to(device)
+
+            outputs = model(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                pixel_values=pixel_values
+            )
+
+            logits = outputs["logits"]
+            forecast = outputs["forecast"].squeeze(1)
+
+            preds = torch.argmax(logits, dim=1)
+            correct += (preds == labels).sum().item()
+            total += labels.size(0)
+
+            all_preds.extend(preds.tolist())
+            all_labels.extend(labels.tolist())
+            all_forecasts.extend(forecast.tolist())
+            all_targets.extend(target_price.tolist())
+
+    acc = correct / total
+    print(f"📊 Evaluation Accuracy: {acc*100:.2f}%")
+
+    # Optional: print forecasting MSE
+    forecast_mse = nn.MSELoss()(torch.tensor(all_forecasts), torch.tensor(all_targets)).item()
+    print(f"📈 Forecast MSE: {forecast_mse:.4f}")