Enzo8930302
/

ByteDream

@@ -1,308 +1,158 @@
-# Byte Dream - AI Image Generation Model
 ## Overview
-Byte Dream is a robust, production-ready text-to-image diffusion model optimized for CPU inference. This model uses advanced latent diffusion architecture to generate high-quality images from text prompts. Fully integrated with Hugging Face Hub for easy model sharing, deployment, and cloud API access.
 ## Features
-- **CPU Optimized**: Runs efficiently on CPU without GPU requirement
-- **High Quality**: Generates 512x512 and higher resolution images
-- **Fast Inference**: Optimized for speed with quality preservation
-- **Hugging Face Native**: Full integration with HF Hub (upload, download, deploy)
-- **Cloud API Support**: Use Hugging Face Inference API for cloud-based generation
-- **Spaces Ready**: One-click deployment to Hugging Face Spaces
-- **Flexible**: Supports various sampling methods and customization
-- **Production Ready**: Error handling, memory optimization, batch processing
 ## Installation
-### Using pip
 ```bash
-pip install -r requirements.txt
-```
-### Using conda
-```bash
-conda env create -f environment.yml
-conda activate bytedream
 ```
 ## Usage
-### Basic Image Generation
 ```python
 from bytedream import ByteDreamGenerator
-# Initialize generator
-generator = ByteDreamGenerator()
-# Generate image from prompt
 image = generator.generate(
     prompt="A beautiful sunset over mountains, digital art",
     num_inference_steps=50,
-    guidance_scale=7.5
 )
-# Save image
 image.save("output.png")
 ```
-### Advanced Usage
-```python
-from bytedream import ByteDreamGenerator
-generator = ByteDreamGenerator(model_path="models/bytedream")
-# Generate with custom parameters
-image = generator.generate(
-    prompt="Cyberpunk city at night, neon lights, futuristic",
-    negative_prompt="blurry, low quality, distorted",
-    width=768,
-    height=768,
-    num_inference_steps=100,
-    guidance_scale=9.0,
-    seed=42
-)
-image.save("cyberpunk_city.png")
-```
-### Load Model from Hugging Face Hub
 ```python
-from bytedream import ByteDreamGenerator
-# Load directly from Hugging Face
-generator = ByteDreamGenerator(hf_repo_id="username/ByteDream")
-# Generate image
-image = generator.generate(
-    prompt="A majestic dragon, fantasy art, dramatic lighting",
-    num_inference_steps=50,
-    guidance_scale=7.5
-)
-image.save("dragon.png")
-```
-### Using Pipeline Directly
-```python
-from bytedream.pipeline import ByteDreamPipeline
-# Load pretrained pipeline
-pipeline = ByteDreamPipeline.from_pretrained(
-    "username/ByteDream",
-    device="cpu",
-    dtype=torch.float32
 )
-# Generate image
-result = pipeline(
-    prompt="A peaceful landscape, cottage, sunny day",
-    num_inference_steps=50,
-    guidance_scale=7.5,
-    height=512,
-    width=512
 )
-result[0].save("landscape.png")
-```
-### Command Line Interface
-```bash
-# Basic usage
-python infer.py --prompt "A dragon flying over castle" --output dragon.png
-# With advanced options
-python infer.py --prompt "Fantasy landscape" --negative "ugly, blurry" --steps 75 --guidance 8.0
-# Load from Hugging Face
-python infer.py --prompt "Cyberpunk city" --hf_repo "username/ByteDream" --output city.png
-```
-### Gradio Web Interface
-```bash
-# Run with local model
-python app.py
-# Run with model from Hugging Face
-HF_REPO_ID=username/ByteDream python app.py
 ```
-## Model Architecture
-Byte Dream uses a latent diffusion model with:
-- **Text Encoder**: CLIP-based text understanding
-- **UNet**: Noise prediction network with cross-attention
-- **VAE**: Variational Autoencoder for image compression
-- **Scheduler**: Advanced DDIM/PNDM sampling
 ## Training
-### Prepare Dataset
-```bash
-python prepare_dataset.py --data_dir ./dataset --output_dir ./processed_data
-```
-### Train Model
-```bash
-python train.py \
-  --train_data ./processed_data \
-  --output_dir ./models/bytedream \
-  --epochs 100 \
-  --batch_size 4 \
-  --learning_rate 1e-5
-```
-## Hugging Face Deployment
-### Upload Your Trained Model to Hugging Face Hub
-First, get your Hugging Face token from: https://huggingface.co/settings/tokens
 ```bash
-# Method 1: Using publish_to_hf.py (recommended)
-python publish_to_hf.py
-# You'll be prompted for:
-# - Your HF token
-# - Repository ID (e.g., username/ByteDream)
-# Method 2: Using upload_to_hf.py
-python upload_to_hf.py \
-  --model_path ./models/bytedream \
-  --repo_id username/ByteDream \
-  --token YOUR_HF_TOKEN
-# Method 3: Programmatically from Python
-from bytedream import ByteDreamGenerator
-# Train your model first
-generator = ByteDreamGenerator(model_path="./models/bytedream")
-# Push to Hub
-generator.push_to_hub(
-    repo_id="username/ByteDream",
-    token="YOUR_HF_TOKEN",
-    private=False
-)
 ```
-### Download Model from Hugging Face Hub
-```python
-from bytedream import ByteDreamGenerator
-# Load directly from HF Hub
-generator = ByteDreamGenerator(hf_repo_id="username/ByteDream")
-# Or using pipeline
-from bytedream.pipeline import ByteDreamPipeline
-pipeline = ByteDreamPipeline.from_pretrained("username/ByteDream")
-```
-### Deploy to Hugging Face Spaces
-#### Option 1: Automatic Deployment (Recommended)
 ```bash
-python deploy_to_spaces.py --repo_id your_username/ByteDream-Space
 ```
-#### Option 2: Manual Deployment
-1. **Create a new Space**: Go to https://huggingface.co/spaces and click "Create new Space"
-2. **Choose Gradio SDK**: Select Gradio as the SDK
-3. **Upload files**: Push all your files to the repository
-4. **Set environment variable** (optional): In your Space settings, set `HF_REPO_ID=username/ByteDream`
-5. **Deploy**: The app will automatically deploy with CPU hardware
-Your Gradio app will be available at: `https://huggingface.co/spaces/your_username/ByteDream-Space`
-## Hugging Face API Integration
-### Use Cloud Inference API
-Generate images using Hugging Face cloud infrastructure (no local computation):
-```python
-from bytedream import ByteDreamHFClient
-# Initialize API client
-client = ByteDreamHFClient(
-    repo_id="Enzo8930302/ByteDream",
-    use_api=True,  # Use cloud API
-)
-# Generate image in the cloud
-image = client.generate(
-    prompt="A futuristic city at night, cyberpunk style",
-    num_inference_steps=50,
-)
-image.save("output.png")
 ```
-### Complete API Examples
-See `examples_hf_api.py` for comprehensive examples:
-- Download models from HF Hub
-- Upload trained models
-- Deploy to Spaces automatically
-- Use cloud inference API
-- Batch generation
-- Compare local vs cloud inference
-## Configuration
-Edit `config.yaml` for custom settings:
-- Model dimensions
-- Sampling parameters
-- Training hyperparameters
-- CPU optimization settings
-## Performance Optimization
-### CPU Optimization
-- OpenVINO integration available
-- ONNX runtime support
-- Mixed precision (FP16/FP32)
-- Batch processing
-### Memory Management
-- Gradient checkpointing
-- Model offloading
-- Progressive generation
-## File Structure
 ```
-Byte Dream/
 ├── bytedream/          # Core package
 │   ├── __init__.py
 │   ├── model.py        # Model architecture
-│   ├── pipeline.py     # Generation pipeline
-│   ├── scheduler.py    # Diffusion scheduler
-│   └── utils.py        # Utilities
 ├── train.py            # Training script
-├── infer.py            # Inference script
-├── app.py              # Gradio web interface
-├── config.yaml         # Configuration
-├── requirements.txt    # Dependencies
-└── README.md           # This file
 ```
-## Examples
-Generate various types of images:
-- Digital art and illustrations
-- Photorealistic scenes
-- Abstract concepts
-- Character designs
-- Landscapes and environments
 ## License
-MIT License - See LICENSE file for details
 ## Citation
-If you use Byte Dream in your research:
 ```bibtex
 @software{bytedream2024,
   title={Byte Dream: CPU-Optimized Text-to-Image Generation},
@@ -310,6 +160,16 @@ If you use Byte Dream in your research:
 }
 ```
 ## Support
-For issues and questions, please open a GitHub issue or contact the maintainers.

+---
+license: mit
+language: en
+tags:
+  - text-to-image
+  - diffusion
+  - cpu-optimized
+  - bytedream
+  - clip
+pipeline_tag: text-to-image
+---
+# Byte Dream - Text-to-Image Model
 ## Overview
+Byte Dream is a production-ready text-to-image diffusion model optimized for CPU inference.
+It uses CLIP ViT-B/32 for text encoding and a custom UNet architecture for image generation.
 ## Features
+- ✅ **CPU Optimized**: Runs efficiently on CPU (no GPU required)
+- ✅ **High Quality**: Generates 512x512 images
+- ✅ **Fast Inference**: Optimized for speed
+- ✅ **Easy to Use**: Simple Python API and web interface
+- ✅ **Open Source**: MIT License
 ## Installation
 ```bash
+pip install torch pillow transformers
+git lfs install
+git clone https://huggingface.co/Enzo8930302/ByteDream
+cd ByteDream
 ```
 ## Usage
+### Quick Start
 ```python
 from bytedream import ByteDreamGenerator
+# Load model
+generator = ByteDreamGenerator(hf_repo_id="Enzo8930302/ByteDream")
+# Generate image
 image = generator.generate(
     prompt="A beautiful sunset over mountains, digital art",
     num_inference_steps=50,
+    guidance_scale=7.5,
 )
 image.save("output.png")
 ```
+### Using Cloud API
 ```python
+from bytedream import ByteDreamHFClient
+client = ByteDreamHFClient(
+    repo_id="Enzo8930302/ByteDream",
+    use_api=True,
 )
+image = client.generate(
+    prompt="Futuristic city at night, cyberpunk",
 )
+image.save("output.png")
 ```
 ## Training
+Train on your own dataset:
 ```bash
+# Create dataset
+python create_test_dataset.py
+# Train model
+python train.py --config config.yaml --train_data dataset
 ```
+## Web Interface
+Launch Gradio web interface:
 ```bash
+python app.py
 ```
+Or deploy to Hugging Face Spaces:
+```bash
+python deploy_to_spaces.py --repo_id YourUsername/ByteDream-Space
 ```
+## Model Architecture
+- **Text Encoder**: CLIP ViT-B/32 (512 dimensions)
+- **UNet**: Custom architecture with cross-attention
+- **VAE**: Autoencoder for latent space
+- **Scheduler**: DDIM sampling
+### Parameters
+- Cross-attention dimension: 512
+- Block channels: [128, 256, 512, 512]
+- Attention heads: 4
+- Layers per block: 1
+## Examples
+### Prompts that work well:
+- "A serene lake at sunset with mountains"
+- "Futuristic city with flying cars, cyberpunk"
+- "Majestic dragon flying over castle, fantasy"
+- "Peaceful garden with cherry blossoms"
+### Tips:
+- Use detailed, descriptive prompts
+- Add style keywords (digital art, oil painting, etc.)
+- Use negative prompts to avoid unwanted elements
+- Higher guidance scale = more faithful to prompt
+## Files Structure
 ```
+ByteDream/
 ├── bytedream/          # Core package
 │   ├── __init__.py
+│   ├── generator.py    # Main generator
 │   ├── model.py        # Model architecture
+│   ├── pipeline.py     # Pipeline
+│   ├── scheduler.py    # Scheduler
+│   ├── hf_api.py       # HF API client
+│   └��─ utils.py
 ├── train.py            # Training script
+├── infer.py            # Inference
+├── app.py              # Web UI
+├── config.yaml         # Config
+└── requirements.txt    # Dependencies
 ```
+## Requirements
+- Python 3.8+
+- PyTorch
+- Pillow
+- Transformers
+- Gradio (for web UI)
+See `requirements.txt` for full list.
 ## License
+MIT License
 ## Citation
 ```bibtex
 @software{bytedream2024,
   title={Byte Dream: CPU-Optimized Text-to-Image Generation},
 }
 ```
+## Links
+- [GitHub](https://github.com/yourusername/bytedream)
+- [Documentation](https://huggingface.co/Enzo8930302/ByteDream/blob/main/README.md)
+- [Spaces Demo](https://huggingface.co/spaces/Enzo8930302/ByteDream-Space)
 ## Support
+For issues or questions, please open an issue on GitHub.
+---
+**Created by Enzo and the Byte Dream Team** 🎨