other files

.gitignore

@@ -0,0 +1,87 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environment
+.venv/
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# Docker
+docker-compose.yml
+docker-compose.*.yml
+.dockerignore
+Dockerfile
+docker/
+containers/
+
+# IDE & Editor
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+._*
+*.bak
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb
+
+# Testing
+.coverage
+htmlcov/
+.pytest_cache/
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+
+# Logs
+*.log
+logs/
+
+# Hugging Face cache (large files)
+.cache/
+.huggingface/
+
+# Local data & configs
+data/
+*.csv
+*.jsonl
+*.parquet
+*.db
+*.sqlite3
+
+# System files
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+$RECYCLE.BIN/
+
+# Project-specific (adjust as needed)
+qwen_classifier/__pycache__/
+qwen_classifier.egg-info/

qwen_classifier/cli.py

@@ -0,0 +1,44 @@
+import click
+from .predict import predict_single
+import warnings
+from transformers import logging as hf_logging
+
+def configure_logging(debug):
+    """Configure warning and logging levels based on debug flag"""
+    if not debug:
+        warnings.filterwarnings("ignore", message="Some weights of the model checkpoint")
+        hf_logging.set_verbosity_error()
+    else:
+        hf_logging.set_verbosity_info()
+        warnings.simplefilter("default")
+
+@click.group()
+@click.option('--debug', is_flag=True, help="Enable debug output including warnings")
+@click.pass_context
+def cli(ctx, debug):
+    """Qwen Multi-label Classifier CLI"""
+    ctx.ensure_object(dict)
+    ctx.obj['DEBUG'] = debug
+    configure_logging(debug)
+
+@cli.command()
+@click.argument('text')
+@click.option('--hf-token', envvar="HF_TOKEN", help="HF API token (or set HF_TOKEN env variable)")
+@click.option('--hf-repo', default="KeivanR/Qwen2.5-1.5B-Instruct-MLB-clf_lora-1743189446", help="Hugging Face model repo")
+@click.option('--backend', 
+              type=click.Choice(['local', 'hf'], case_sensitive=False),
+              default='local',
+              help="Inference backend: 'local' (your machine) or 'hf' (Hugging Face API)")
+@click.pass_context
+def predict(ctx, text, hf_repo, backend, hf_token):
+    """Make prediction on a single text"""
+    if ctx.obj['DEBUG']:
+        click.echo("Debug mode enabled - showing all warnings")
+    
+    results = predict_single(
+        text,
+        hf_repo, 
+        backend=backend, 
+        hf_token=hf_token
+    )
+    click.echo(f"Prediction results: {results}")

qwen_classifier/config.py

@@ -0,0 +1,17 @@
+import torch
+
+# Local config
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+# HF API config
+TAG_NAMES = [
+    'games',
+    'geometry',
+    'graphs',
+    'math',
+    'number theory',
+    'other',
+    'probabilities',
+    'strings',
+    'trees'
+    ]

qwen_classifier/evaluate.py

@@ -0,0 +1,8 @@
+import numpy as np
+from sklearn.metrics import classification_report
+
+def evaluate_model(test_data_path):
+    # Load your test data
+    # Implement evaluation logic
+    # Return metrics like precision, recall, f1-score
+    return metrics

qwen_classifier/model.py

@@ -0,0 +1,27 @@
+import torch.nn as nn
+from transformers import AutoModel, PreTrainedModel, AutoConfig
+
+class QwenClassifier(PreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.qwen_model = AutoModel.from_pretrained(config.model_name)  # Load Qwen model
+
+        self.classifier = nn.Linear(self.qwen_model.config.hidden_size, config.num_labels)
+        self.loss_fn = None 
+
+    def forward(self, input_ids, attention_mask, labels=None):
+        outputs = self.qwen_model(input_ids=input_ids, attention_mask=attention_mask)
+        pooled = outputs.last_hidden_state.mean(dim=1)
+        logits = self.classifier(pooled)
+        #logits = nn.functional.sigmoid(logits)
+
+        if labels is not None:
+            loss = self.loss_fn(logits, labels)
+            return loss, logits
+        return logits
+
+    @classmethod
+    def from_pretrained(cls, model_name):
+        config = AutoConfig.from_pretrained(model_name)
+        config.model_name = model_name  # Store model name
+        return super().from_pretrained(model_name, config=config)

qwen_classifier/predict.py

@@ -0,0 +1,55 @@
+import torch
+import requests
+from .config import TAG_NAMES
+
+# Local model setup (only load if needed)
+local_model = None
+local_tokenizer = None
+
+def predict_single(text, hf_repo, backend="local", hf_token=None):
+    if backend == "local":
+        return _predict_local(text, hf_repo)
+    elif backend == "hf":
+        return _predict_hf_api(text, hf_token)
+    else:
+        raise ValueError(f"Unknown backend: {backend}")
+
+def _predict_local(text, hf_repo):
+    global local_model, local_tokenizer
+    
+    # Lazy-loading to avoid slow startup
+    if local_model is None:
+        from .model import QwenClassifier
+        from transformers import AutoTokenizer
+        
+        local_model = QwenClassifier.from_pretrained(hf_repo).eval()
+        local_tokenizer = AutoTokenizer.from_pretrained(hf_repo)
+    
+    inputs = local_tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+    with torch.no_grad():
+        logits = local_model(**inputs)
+    return _process_output(logits)
+
+def _predict_hf_api(text, hf_token=None):
+    # Use your Space endpoint instead of direct model API
+    SPACE_URL = "https://KeivanR/qwen-classifier-demo"
+    
+    try:
+        response = requests.post(
+            f"{SPACE_URL}/predict",
+            json={"text": text},
+            headers={"Authorization": f"Bearer {hf_token}"} if hf_token else {}
+        )
+        return response.json()
+    except Exception as e:
+        raise ValueError(f"Space API Error: {str(e)}")
+
+def _process_output(logits):
+    probs = torch.sigmoid(logits)
+    s = ''
+    for tag, prob in zip(TAG_NAMES, probs[0]):
+        if prob>0.5:
+            s += f"{tag}({prob:.2f}), "
+    return s[:-2]
+
+

setup.py

@@ -0,0 +1,20 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="qwen_classifier",
+    version="0.1",
+    packages=find_packages(),
+    install_requires=[
+        'torch',
+        'transformers',
+        'click',
+        'scikit-learn',
+        'huggingface_hub',
+        'requests'
+    ],
+    entry_points={
+        'console_scripts': [
+            'qwen-clf=qwen_classifier.cli:cli',
+        ],
+    },
+)