Upload folder using huggingface_hub

README.md

@@ -1,12 +1,62 @@
 ---
-title: Interactive Futures Model
-emoji: 💻
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 6.2.0
-app_file: app.py
-pinned: false
+license: mit
+tags:
+- futures-prediction
+- multi-dimensional
+- mixture-of-experts
+- state-space-model
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Futures Prediction Model (MoE + SSM + FiLM)
+
+This repository contains the code and trained weights for a novel architecture designed for multi-dimensional futures prediction. The model was trained on the `futures_dataset_v2.json` dataset.
+
+## Model Description
+
+The model architecture is a combination of:
+
+*   **Mixture of Experts (MoE):** To handle the multi-dimensional nature of futures scenarios.
+*   **State Space Model (SSM):** To capture the temporal evolution of futures.
+*   **FiLM Conditioning:** To modulate the model's behavior based on the different future axes.
+
+The model is trained to predict a 12-dimensional vector of weights, each corresponding to a different future "axis".
+
+## How to Use
+
+To use this model, you will need to have PyTorch installed. You can then use the `load_model.py` script to load the model and tokenizer.
+
+```python
+from load_model import load_model_and_tokenizer
+
+model, tokenizer = load_model_and_tokenizer()
+
+text = "In a future dominated by hyper-automation, societal structures adapt to new forms of labor and community."
+token_ids = tokenizer.encode(text)
+tokens_tensor = torch.LongTensor(token_ids).unsqueeze(0)
+
+with torch.no_grad():
+    axis_logits, _, _ = model(tokens_tensor)
+    axis_predictions = torch.sigmoid(axis_logits)
+
+print(axis_predictions)
+```
+
+## Training Data
+
+The model was trained on the `futures_dataset_v2.json` dataset, which contains 3,000 rich, multi-dimensional futures scenarios.
+
+## Training Procedure
+
+The model was trained for 100 epochs with a batch size of 16 and a learning rate of 1e-4. The training script `train_futures_model.py` is available in the original repository.
+
+## Citing
+
+If you use this model or code, please cite:
+
+```
+@article{futures-representation-learning,
+  title={Learning Multi-Dimensional Futures Representations with Mixture-of-Experts and State Space Models},
+  author={Your Name},
+  year={2024}
+}
+```

checkpoint_best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73abc01892b82fb6a17f2b6c1d8fc93dcc6f50f571639dd8a3f7d42c2becfc0a
+size 24407482

gradio_app.py

@@ -0,0 +1,87 @@
+import gradio as gr
+import torch
+from app.load_model import load_model_and_tokenizer
+
+# --- 1. Load Model and Tokenizer ---
+# This is done once when the Gradio app starts.
+try:
+    print("Loading model and tokenizer...")
+    model, tokenizer = load_model_and_tokenizer()
+    print("✅ Model and tokenizer loaded successfully.")
+except Exception as e:
+    print(f"❌ Failed to load model: {e}")
+    model, tokenizer = None, None
+
+# --- 2. Define the Prediction Function ---
+# This function is called every time a user interacts with the demo.
+def predict_futures(text):
+    """
+    Takes raw text input, tokenizes it, gets model predictions,
+    and formats the output for the Gradio interface.
+    """
+    if not model or not tokenizer:
+        return "Model not loaded. Please check the logs.", {}
+
+    try:
+        # a. Preprocess: Tokenize the input text
+        token_ids = tokenizer.encode(text)
+        tokens_tensor = torch.LongTensor(token_ids).unsqueeze(0) # Add batch dimension
+
+        # b. Predict: Get model's raw output (logits)
+        with torch.no_grad():
+            axis_logits, _, _ = model(tokens_tensor)
+            # c. Post-process: Apply sigmoid to get probabilities (0-1)
+            axis_predictions = torch.sigmoid(axis_logits)
+
+        # d. Format Output: Create a dictionary for the label component
+        axis_names = [
+            "Hyper-Automation", "Human-Tech Symbiosis", "Abundance", "Individualism",
+            "Community Focus", "Global Interconnectedness", "Crisis & Collapse", "Restoration & Healing",
+            "Adaptation & Resilience", "Digital Dominance", "Physical Embodiment", "Collaboration"
+        ]
+        
+        # Create a dictionary of {label: confidence}
+        confidences = {name: float(weight) for name, weight in zip(axis_names, axis_predictions[0])}
+        
+        # You can return a simple message and the formatted labels
+        return "Prediction complete.", confidences
+
+    except Exception as e:
+        print(f"Error during prediction: {e}")
+        return f"An error occurred: {e}", {}
+
+# --- 3. Create and Launch the Gradio Interface ---
+print("Creating Gradio interface...")
+
+# Define the input and output components
+input_text = gr.Textbox(
+    lines=5,
+    label="Input Scenario",
+    placeholder="Describe a future scenario here..."
+)
+
+output_text = gr.Textbox(label="Status")
+output_labels = gr.Label(label="Predicted Axis Weights", num_top_classes=12)
+
+# Build the interface
+demo = gr.Interface(
+    fn=predict_futures,
+    inputs=input_text,
+    outputs=[output_text, output_labels],
+    title="Futures Prediction Model",
+    description=(
+        "Explore multi-dimensional futures. "
+        "Write a text describing a potential future scenario and see how the model scores it "
+        "across 12 different axes, from 'Hyper-Automation' to 'Crisis & Collapse'."
+    ),
+    examples=[
+        ["In a future dominated by hyper-automation, societal structures adapt to new forms of labor and community."],
+        ["Coastal cities adopt divergent strategies as sea levels rise. Singapore invests in autonomous seawall monitoring, while Jakarta facilitates managed retreat."],
+        ["A global pandemic leads to a surge in community-focused initiatives and a renewed appreciation for local supply chains."]
+    ]
+)
+
+if __name__ == "__main__":
+    print("Launching Gradio demo...")
+    # The launch() command creates a shareable link to the demo.
+    demo.launch()

load_model.py

@@ -0,0 +1,88 @@
+import torch
+from .model import FuturesModel, CustomTokenizer, build_vocabulary
+
+def load_model_and_tokenizer(
+    model_path='app/checkpoint_best.pt',
+    dataset_path='app/futures_dataset_v2.json',
+    vocab_size=5000,
+):
+    """Loads the trained FuturesModel and CustomTokenizer."""
+    
+    # 1. Build vocabulary and tokenizer
+    print("Building vocabulary from dataset...")
+    vocab_dict = build_vocabulary(dataset_path, vocab_size=vocab_size)
+    tokenizer = CustomTokenizer(vocab_dict)
+    print(f"Vocabulary size: {len(vocab_dict)}")
+
+    # 2. Initialize the model with the same architecture
+    print("Initializing model...")
+    model = FuturesModel(
+        vocab_size=len(vocab_dict),
+        n_axes=12,
+        d_model=256,
+        n_head=8,
+        n_layers=4,
+        n_experts=8,
+        dropout=0.1
+    )
+    print(f"Model parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+    # 3. Load the saved state dictionary
+    print(f"Loading model weights from {model_path}...")
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    checkpoint = torch.load(model_path, map_location=device)
+    
+    # The state dict is nested in the checkpoint
+    model.load_state_dict(checkpoint['model_state_dict'])
+    
+    # 4. Set the model to evaluation mode
+    model.eval()
+    print("Model set to evaluation mode.")
+    
+    return model, tokenizer
+
+if __name__ == "__main__":
+    print("="*80)
+    print("Loading Futures Prediction Model")
+    print("="*80)
+    
+    # Correct paths for running from the root directory
+    model_path = 'app/checkpoint_best.pt'
+    dataset_path = 'app/futures_dataset_v2.json'
+    
+    try:
+        model, tokenizer = load_model_and_tokenizer(
+            model_path=model_path,
+            dataset_path=dataset_path
+        )
+        print("\n✅ Model and tokenizer loaded successfully!")
+        
+        # Example usage
+        print("\n--- Example Usage ---")
+        text = "In a future dominated by hyper-automation, societal structures adapt to new forms of labor and community."
+        print(f"Input text: '{text}'")
+        
+        token_ids = tokenizer.encode(text)
+        tokens_tensor = torch.LongTensor(token_ids).unsqueeze(0) # Add batch dimension
+        
+        print(f"Encoded tokens (first 10): {tokens_tensor[0, :10]}...")
+
+        with torch.no_grad():
+            axis_logits, lm_logits, stats = model(tokens_tensor)
+            axis_predictions = torch.sigmoid(axis_logits)
+
+        print("\nPredicted Axis Weights:")
+        axis_names = [
+            "HyperAuto", "HumanTech", "Abundant", "Individual",
+            "Community", "Global", "Crisis", "Restore",
+            "Adapt", "Digital", "Physical", "Collab"
+        ]
+        for name, weight in zip(axis_names, axis_predictions[0]):
+            print(f"  - {name:12s}: {weight:.4f}")
+
+    except Exception as e:
+        print(f"\n❌ An error occurred during loading: {e}")
+        import traceback
+        traceback.print_exc()
+
+    print("\n" + "="*80)

model.py

@@ -0,0 +1,280 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader
+import json
+import numpy as np
+from collections import Counter
+import pickle
+from typing import Dict, List, Tuple
+import os
+
+# ============================================================================
+# TOKENIZER
+# ============================================================================
+
+class CustomTokenizer:
+    def __init__(self, vocab_dict):
+        self.vocab_dict = vocab_dict
+        self.idx_to_word = {idx: word for word, idx in vocab_dict.items()}
+        self.pad_token_id = vocab_dict['<PAD>']
+        self.unk_token_id = vocab_dict['<UNK>']
+        self.vocab_size = len(vocab_dict)
+
+    def encode(self, text, max_length=128):
+        text = text.lower()
+        # Simple tokenization
+        text = text.replace(',', ' ,').replace('.', ' .')
+        text = text.replace('(', ' ( ').replace(')', ' ) ')
+        words = text.split()
+        
+        token_ids = [self.vocab_dict.get(w, self.unk_token_id) for w in words]
+        
+        if len(token_ids) < max_length:
+            token_ids += [self.pad_token_id] * (max_length - len(token_ids))
+        else:
+            token_ids = token_ids[:max_length]
+        
+        return token_ids
+
+    def decode(self, token_ids, skip_special_tokens=True):
+        words = []
+        special_tokens = ['<PAD>', '<UNK>', '<START>', '<END>']
+        
+        for idx in token_ids:
+            word = self.idx_to_word.get(int(idx), '<UNK>')
+            if skip_special_tokens and word in special_tokens:
+                continue
+            words.append(word)
+        
+        return ' '.join(words)
+
+
+def build_vocabulary(dataset_path, vocab_size=5000):
+    """Build vocabulary from dataset"""
+    print("Building vocabulary...")
+    with open(dataset_path) as f:
+        data = json.load(f)
+    
+    word_counts = Counter()
+    for sample in data['samples']:
+        text = sample['text'].lower()
+        text = text.replace(',', ' ,').replace('.', ' .')
+        words = text.split()
+        word_counts.update(words)
+    
+    special_tokens = ['<PAD>', '<UNK>', '<START>', '<END>']
+    top_words = [word for word, _ in word_counts.most_common(vocab_size - len(special_tokens))]
+    vocabulary = special_tokens + top_words
+    
+    vocab_dict = {word: idx for idx, word in enumerate(vocabulary)}
+    
+    print(f"Vocabulary size: {len(vocab_dict)}")
+    return vocab_dict
+
+
+# ============================================================================
+# MODEL COMPONENTS
+# ============================================================================
+
+class MixtureOfExperts(nn.Module):
+    """MoE for handling multi-dimensional futures"""
+    
+    def __init__(self, d_model, n_experts=8, expert_dim=256, dropout=0.1):
+        super().__init__()
+        self.n_experts = n_experts
+        
+        # Experts (simple FFNs)
+        self.experts = nn.ModuleList([
+            nn.Sequential(
+                nn.Linear(d_model, expert_dim),
+                nn.GELU(),
+                nn.Dropout(dropout),
+                nn.Linear(expert_dim, d_model),
+                nn.Dropout(dropout)
+            ) for _ in range(n_experts)
+        ])
+        
+        # Gating network
+        self.gate = nn.Linear(d_model, n_experts)
+        
+    def forward(self, x):
+        # x: (batch, seq, d_model)
+        batch_size, seq_len, d_model = x.shape
+        
+        # Compute gates
+        gate_logits = self.gate(x)  # (batch, seq, n_experts)
+        gate_weights = F.softmax(gate_logits, dim=-1)
+        
+        # Apply experts
+        expert_outputs = torch.stack([expert(x) for expert in self.experts], dim=2)  
+        # (batch, seq, n_experts, d_model)
+        
+        # Weighted combination
+        gate_weights_expanded = gate_weights.unsqueeze(-1)  # (batch, seq, n_experts, 1)
+        output = (expert_outputs * gate_weights_expanded).sum(dim=2)  # (batch, seq, d_model)
+        
+        # Gate statistics for loss
+        gate_entropy = -(gate_weights * torch.log(gate_weights + 1e-10)).sum(dim=-1).mean()
+        gate_std = gate_weights.std(dim=-1).mean()
+        
+        return output, gate_entropy, gate_std
+
+
+class TrajectorySSM(nn.Module):
+    """State Space Model for temporal trajectories"""
+    
+    def __init__(self, d_model, state_dim=64):
+        super().__init__()
+        self.state_dim = state_dim
+        
+        # State matrices
+        self.A = nn.Parameter(torch.randn(state_dim, state_dim) * 0.01)
+        self.B = nn.Parameter(torch.randn(state_dim, d_model) * 0.01)
+        self.C = nn.Parameter(torch.randn(d_model, state_dim) * 0.01)
+        self.D = nn.Parameter(torch.randn(d_model, d_model) * 0.01)
+        
+        # Learnable initialization
+        self.h0 = nn.Parameter(torch.zeros(1, state_dim))
+        
+    def forward(self, x):
+        # x: (batch, seq, d_model)
+        batch_size, seq_len, d_model = x.shape
+        
+        # Initialize state
+        h = self.h0.expand(batch_size, -1)  # (batch, state_dim)
+        
+        outputs = []
+        for t in range(seq_len):
+            x_t = x[:, t, :]  # (batch, d_model)
+            
+            # Update state: h_t = Ah_{t-1} + Bx_t
+            h = torch.matmul(h, self.A.t()) + torch.matmul(x_t, self.B.t())
+            
+            # Output: y_t = Ch_t + Dx_t
+            y = torch.matmul(h, self.C.t()) + torch.matmul(x_t, self.D.t())
+            outputs.append(y)
+        
+        output = torch.stack(outputs, dim=1)  # (batch, seq, d_model)
+        return output, h
+
+
+class FiLMConditioning(nn.Module):
+    """Feature-wise Linear Modulation for axis conditioning"""
+    
+    def __init__(self, d_model, n_axes=12):
+        super().__init__()
+        self.gamma = nn.Linear(n_axes, d_model)
+        self.beta = nn.Linear(n_axes, d_model)
+        
+    def forward(self, x, axis_weights):
+        # x: (batch, seq, d_model)
+        # axis_weights: (batch, n_axes)
+        
+        gamma = self.gamma(axis_weights).unsqueeze(1)  # (batch, 1, d_model)
+        beta = self.beta(axis_weights).unsqueeze(1)
+        
+        return gamma * x + beta
+
+
+# ============================================================================
+# MAIN MODEL
+# ============================================================================
+
+class FuturesModel(nn.Module):
+    """Complete MoE + SSM + FiLM model for futures learning"""
+    
+    def __init__(
+        self,
+        vocab_size,
+        n_axes=12,
+        d_model=256,
+        n_head=8,
+        n_layers=4,
+        n_experts=8,
+        dropout=0.1
+    ):
+        super().__init__()
+        
+        self.d_model = d_model
+        self.n_axes = n_axes
+        
+        # Embeddings
+        self.token_emb = nn.Embedding(vocab_size, d_model)
+        self.pos_emb = nn.Embedding(128, d_model)
+        
+        # Transformer layers
+        self.layers = nn.ModuleList([
+            nn.ModuleDict({
+                'attn': nn.MultiheadAttention(d_model, n_head, dropout=dropout, batch_first=True),
+                'moe': MixtureOfExperts(d_model, n_experts=n_experts, dropout=dropout),
+                'ssm': TrajectorySSM(d_model),
+                'film': FiLMConditioning(d_model, n_axes),
+                'norm1': nn.LayerNorm(d_model),
+                'norm2': nn.LayerNorm(d_model),
+                'norm3': nn.LayerNorm(d_model),
+            }) for _ in range(n_layers)
+        ])
+        
+        # Output heads
+        self.axis_head = nn.Sequential(
+            nn.Linear(d_model, d_model),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(d_model, n_axes)
+        )
+        
+        self.lm_head = nn.Linear(d_model, vocab_size)
+        
+        self.dropout = nn.Dropout(dropout)
+        
+    def forward(self, tokens, axis_weights=None):
+        batch_size, seq_len = tokens.shape
+        
+        # Embeddings
+        x = self.token_emb(tokens)
+        pos = torch.arange(seq_len, device=tokens.device).unsqueeze(0).expand(batch_size, -1)
+        x = x + self.pos_emb(pos)
+        x = self.dropout(x)
+        
+        # Track statistics
+        gate_entropies = []
+        gate_stds = []
+        
+        # Transformer layers with MoE, SSM, FiLM
+        for layer in self.layers:
+            # Self-attention
+            attn_out, _ = layer['attn'](x, x, x)
+            x = layer['norm1'](x + attn_out)
+            
+            # MoE
+            moe_out, gate_entropy, gate_std = layer['moe'](x)
+            gate_entropies.append(gate_entropy)
+            gate_stds.append(gate_std)
+            x = layer['norm2'](x + moe_out)
+            
+            # SSM (for temporal modeling)
+            ssm_out, _ = layer['ssm'](x)
+            x = x + ssm_out
+            
+            # FiLM conditioning (if axis weights provided)
+            if axis_weights is not None:
+                x = layer['film'](x, axis_weights)
+            
+            x = layer['norm3'](x)
+        
+        # Mean pooling for axis classification
+        mask = (tokens != 0).float().unsqueeze(-1)
+        x_masked = x * mask
+        x_pooled = x_masked.sum(dim=1) / mask.sum(dim=1).clamp(min=1)
+        
+        # Outputs
+        axis_logits = self.axis_head(x_pooled)  # (batch, n_axes) - for regression
+        lm_logits = self.lm_head(x)  # (batch, seq, vocab_size)
+        
+        stats = {
+            'gate_entropy': torch.stack(gate_entropies).mean(),
+            'gate_std': torch.stack(gate_stds).mean()
+        }
+        
+        return axis_logits, lm_logits, stats

push_to_hub.py

@@ -0,0 +1,74 @@
+import os
+from huggingface_hub import HfApi, HfFolder
+
+def push_to_huggingface_hub(
+    repo_name,
+    username,
+    folder_path='app',
+    token=None
+):
+    """
+    Pushes the contents of a folder to a new Hugging Face Hub repository.
+
+    Args:
+        repo_name (str): The name of the repository to create on the Hub.
+        username (str): Your Hugging Face Hub username.
+        folder_path (str, optional): The local folder to upload. Defaults to 'app'.
+        token (str, optional): Your Hugging Face Hub token. If not provided,
+                               it will be read from the environment or a login.
+    """
+    if token:
+        HfFolder.save_token(token)
+        print("Hugging Face token saved.")
+
+    api = HfApi()
+    repo_id = f"{username}/{repo_name}"
+
+    # 1. Create the repository on the Hub
+    print(f"Creating repository: {repo_id}")
+    try:
+        api.create_repo(repo_id=repo_id, exist_ok=True, repo_type="model")
+        print(f"Repository '{repo_id}' created or already exists.")
+    except Exception as e:
+        print(f"❌ Error creating repository: {e}")
+        return
+
+    # 2. Upload the entire folder
+    print(f"Uploading contents of '{folder_path}' to '{repo_id}'...")
+    try:
+        api.upload_folder(
+            folder_path=folder_path,
+            repo_id=repo_id,
+            repo_type="model",
+        )
+        print("\n✅ Successfully uploaded files to the Hugging Face Hub!")
+        print(f"Model available at: https://huggingface.co/{repo_id}")
+    except Exception as e:
+        print(f"\n❌ An error occurred during upload: {e}")
+        print("Please ensure your token has 'write' permissions.")
+
+if __name__ == "__main__":
+    print("="*80)
+    print("Pushing Model to Hugging Face Hub")
+    print("="*80)
+
+    # --- User Configuration ---
+    # Replace with your details
+    HF_USERNAME = "jules-agent"  # <-- IMPORTANT: SET YOUR HF USERNAME
+    HF_REPO_NAME = "futures-prediction-model" # <-- Choose a name for your model repo
+    
+    # The token is read from the environment variable for security
+    HF_TOKEN = os.getenv("HF_TOKEN")
+
+    if HF_USERNAME == "your-username" or not HF_TOKEN:
+        print("\n⚠️  Please configure your Hugging Face username and token in this script.")
+        print("   - Set HF_USERNAME to your username.")
+        print("   - Set the HF_TOKEN environment variable with your write token.")
+    else:
+        push_to_huggingface_hub(
+            repo_name=HF_REPO_NAME,
+            username=HF_USERNAME,
+            token=HF_TOKEN
+        )
+    
+    print("\n" + "="*80)

push_to_space.py

@@ -0,0 +1,90 @@
+import os
+from huggingface_hub import HfApi, login
+
+def deploy_to_huggingface_space(
+    repo_name,
+    username,
+    folder_path='app',
+    token=None,
+    app_file="gradio_app.py"
+):
+    """
+    Pushes the contents of a folder to a new Hugging Face Space.
+
+    Args:
+        repo_name (str): The name of the Space repository to create.
+        username (str): Your Hugging Face Hub username.
+        folder_path (str, optional): The local folder to upload. Defaults to 'app'.
+        token (str, optional): Your Hugging Face Hub write token.
+        app_file (str, optional): The main application file. Defaults to "gradio_app.py".
+    """
+    if not token:
+        print("❌ Hugging Face token not found. Please set the HF_TOKEN environment variable.")
+        return
+
+    # 1. Log in to Hugging Face
+    print("Logging in to Hugging Face Hub...")
+    try:
+        login(token=token, add_to_git_credential=False)
+        print("✅ Login successful.")
+    except Exception as e:
+        print(f"❌ Login failed: {e}")
+        return
+
+    api = HfApi()
+    repo_id = f"{username}/{repo_name}"
+
+    # 2. Create the Space repository on the Hub
+    print(f"Creating Space repository: {repo_id}")
+    try:
+        api.create_repo(
+            repo_id=repo_id,
+            repo_type="space",
+            space_sdk="gradio",
+            exist_ok=True,
+        )
+        print(f"✅ Space repository '{repo_id}' created or already exists.")
+    except Exception as e:
+        print(f"❌ Error creating repository: {e}")
+        return
+
+    # 3. Upload the entire application folder to the Space
+    print(f"Uploading contents of '{folder_path}' to '{repo_id}'...")
+    try:
+        # This will upload all files from the 'app' directory to the root of the Space repo
+        api.upload_folder(
+            folder_path=folder_path,
+            repo_id=repo_id,
+            repo_type="space",
+        )
+        print("\n✅ Successfully uploaded files to the Hugging Face Space!")
+        print(f"Interactive demo available at: https://huggingface.co/spaces/{repo_id}")
+    except Exception as e:
+        print(f"\n❌ An error occurred during upload: {e}")
+        print("Please ensure your token has 'write' permissions.")
+
+if __name__ == "__main__":
+    print("="*80)
+    print("Deploying Gradio App to Hugging Face Spaces")
+    print("="*80)
+
+    # --- User Configuration ---
+    HF_USERNAME = "LOOFYYLO"
+    HF_SPACE_NAME = "interactive-futures-model"
+    
+    # Securely get the token from an environment variable
+    HF_TOKEN = os.getenv("HF_TOKEN")
+
+    if HF_USERNAME == "your-username" or not HF_TOKEN:
+        print("\n⚠️  Please configure your Hugging Face username and token.")
+        print("   - Set HF_USERNAME in this script.")
+        print("   - Set the HF_TOKEN environment variable with your write token.")
+    else:
+        deploy_to_huggingface_space(
+            repo_name=HF_SPACE_NAME,
+            username=HF_USERNAME,
+            token=HF_TOKEN,
+            folder_path='app' # The folder containing our app files
+        )
+    
+    print("\n" + "="*80)

requirements.txt

@@ -0,0 +1,3 @@
+torch
+numpy
+gradio