---
language: en
license: mit
tags:
- image-classification
- imagenet
- multi-scale
- crystal-geometry
- david
datasets:
- imagenet-1k
metrics:
- accuracy
model-index:
- name: David-partial_shared-deep_efficiency
  results:
  - task:
      type: image-classification
    dataset:
      name: ImageNet-1K
      type: imagenet-1k
    metrics:
    - type: accuracy
      value: 83.66
---

# David: Multi-Scale Crystal Classifier

**David** is a multi-scale deep learning classifier that uses crystal geometry (pentachora/4-simplexes) 
as class prototypes with role-weighted similarity computation (Rose Loss).

## Model Details

### Architecture
- **Preset**: clip_vit_bigg14
- **Sharing Mode**: partial_shared
- **Fusion Mode**: deep_efficiency
- **Scales**: [384, 512, 768, 1024, 1280, 1536, 1792, 2048]
- **Feature Dim**: 1280
- **Parameters**: 60,814,373

### Training Configuration
- **Dataset**: AbstractPhil/imagenet-clip-features-orderly
- **Model Variant**: clip_vit_laion_bigg14
- **Epochs**: 10
- **Batch Size**: 1024
- **Learning Rate**: 0.001
- **Rose Loss Weight**: 0.1 → 0.5
- **Cayley Loss**: False

## Performance

### Best Results
- **Validation Accuracy**: 83.66%
- **Best Epoch**: 0
- **Final Train Accuracy**: 82.11%

### Per-Scale Performance
- **Scale 384**: 83.27%
- **Scale 512**: 83.31%
- **Scale 768**: 83.59%
- **Scale 1024**: 83.50%
- **Scale 1280**: 83.66%
- **Scale 1536**: 83.51%
- **Scale 1792**: 83.40%
- **Scale 2048**: 83.60%


## Usage

### Quick Model Lookup

**Check `MODELS_INDEX.json` in the repo root** - it lists all trained models sorted by accuracy with links to weights and configs.

### Repository Structure

```
AbstractPhil/gated-david/
├── MODELS_INDEX.json                # 📊 Master index of all models (sorted by accuracy)
├── README.md                         # This file
├── best_model.json                   # Latest best model info
├── weights/
│   └── david_clip_vit_bigg14/
│       └── 20251012_181608/
│           ├── MODEL_SUMMARY.txt     # 🎯 Human-readable performance summary
│           ├── training_history.json # 📈 Epoch-by-epoch training curve
│           ├── best_model_acc83.66.safetensors  # ⭐ Accuracy in filename!
│           ├── best_model_acc83.66_metadata.json
│           ├── final_model.safetensors
│           ├── checkpoint_epoch_X_accYY.YY.safetensors
│           ├── david_config.json
│           └── train_config.json
└── runs/
    └── david_clip_vit_bigg14/
        └── 20251012_181608/
            └── events.out.tfevents.* # TensorBoard logs
```

### Loading the Model

```python
from geovocab2.train.model.core.david import David, DavidArchitectureConfig
from huggingface_hub import hf_hub_download

# Browse available models in MODELS_INDEX.json first!

# Specify model variant and run
model_name = "david_clip_vit_bigg14"
run_id = "20251012_181608"
accuracy = "83.66"  # From MODELS_INDEX.json

# Download config
config_path = hf_hub_download(
    repo_id="AbstractPhil/gated-david", 
    filename=f"weights/{model_name}/{run_id}/david_config.json"
)
config = DavidArchitectureConfig.from_json(config_path)

# Download weights (accuracy in filename!)
weights_path = hf_hub_download(
    repo_id="AbstractPhil/gated-david", 
    filename=f"weights/{model_name}/{run_id}/best_model_acc{accuracy}.safetensors"
)

# Download training history (optional - see full training curve)
history_path = hf_hub_download(
    repo_id="AbstractPhil/gated-david", 
    filename=f"weights/{model_name}/{run_id}/training_history.json"
)

# Load model
from safetensors.torch import load_file
david = David.from_config(config)
david.load_state_dict(load_file(weights_path))
david.eval()
```

### Inference

```python
import torch
import torch.nn.functional as F

# Assuming you have CLIP features (512-dim for ViT-B/16)
features = get_clip_features(image)  # [1, 512]

# Load anchors
anchors_dict = torch.load("anchors.pth")

# Forward pass
with torch.no_grad():
    logits, _ = david(features, anchors_dict)
    predictions = logits.argmax(dim=-1)
```

## Architecture Overview

### Multi-Scale Processing
David processes inputs at multiple scales (384, 512, 768, 1024, 1280, 1536, 1792, 2048), 
allowing it to capture both coarse and fine-grained features.

### Crystal Geometry
Each class is represented by a pentachoron (4-simplex) in embedding space with 5 vertices:
- **Anchor**: Primary class representative
- **Need**: Complementary direction
- **Relation**: Contextual alignment
- **Purpose**: Functional direction
- **Observer**: Meta-perspective

### Rose Loss
Similarity computation uses role-weighted cosine similarities:
```
score = w_anchor * sim(z, anchor) + w_need * sim(z, need) + ...
```

### Fusion Strategy
**deep_efficiency**: Intelligently combines predictions from multiple scales.

## Training Details

### Loss Components
- **Cross-Entropy**: Standard classification loss
- **Rose Loss**: Pentachora role-weighted margin loss (weight: 0.1→0.5)
- **Cayley Loss**: Geometric regularization (disabled)

### Optimization
- **Optimizer**: AdamW
- **Weight Decay**: 1e-05
- **Scheduler**: cosine_restarts
- **Gradient Clip**: 10.0
- **Mixed Precision**: False

## Citation

```bibtex
@software{david_classifier_2025,
  title = {David: Multi-Scale Crystal Classifier},
  author = {AbstractPhil},
  year = {2025},
  url = {https://huggingface.co/AbstractPhil/gated-david},
  note = {Run ID: 20251012_181608}
}
```

## License

MIT License

## Acknowledgments

Built with crystal lattice geometry and multi-scale deep learning.
Special thanks to Claude (Anthropic) for debugging assistance.

---

*Generated on 2025-10-12 18:19:44*