Diffugen

🚀 DiffuDiff Documentation

DiffuDiff is an image generation tool based on diffusion models, aiming to provide high - performance and flexible configuration. It supports multiple pre - trained models and allows users to customize models and output settings.

🚀 Quick Start

Installation Steps

1. Download the Project

   • Clone the repository on GitHub:

     git clone https://github.com/CLOUDWERX-DEV/diffuDiff.git
     

   • Navigate to the project directory:

     cd diffuDiff
     

2. Install Dependencies

   • Make sure you have installed the following tools:
     • Git: For version control and code management.
     • CMake: For generating build files.
     • NVIDIA CUDA Toolkit (Optional): If you have a GPU and want to accelerate inference, you need to install CUDA and cuDNN.
   • If you encounter problems during installation, refer to the official documentation.

3. Build the Project

   • Create a build directory:

     mkdir build && cd build
     

   • Generate build files (using CMake):

     cmake ..
     

   • Compile the project:

     make
     

4. Run Examples

   • Run the default example in the build directory:

     ./diffuDiff.sh "Your prompt"
     

   • You can also specify the output path and model:

     ./diffuDiff.sh --output-dir ./outputs/ --model flux-schnell "Your prompt"
     

📦 Installation

Configuration File

Configuration Structure

The project configuration is stored in the config.json file, located in the root directory of the project. Here is an example configuration:

{
  "models": {
    "flux-schnell": {
      "path": "./weights/flux_schnell.pth",
      "device": "cuda:0"
    },
    "stable-diffusion": {
      "path": "./weights/stable_diffusion.pth",
      "device": "cpu"
    }
  },
  "output_settings": {
    "save_location": "./outputs/",
    "max_images_per_batch": 4,
    "jpeg_quality": 90
  },
  "api": {
    "enable_api": true,
    "port": 5199,
    "allowed_hosts": ["*"]
  }
}

Configuration Parameters

• models: Defines available models and their path and device information.
• output_settings: Specifies the save location of output images, the maximum number of images per batch, and JPEG quality.
• api: Configures the OpenAPI service, including whether to enable the API, the listening port, and allowed hosts.

💻 Usage Examples

Command - Line Arguments

When running the script, you can use the following options:

Usage: ./diffuDiff.sh [OPTIONS] <PROMPT>

Options:
  -h, --help             Show help information and exit.
  -o, --output-dir PATH   Specify the output directory, default is "./outputs/".
  -m, --model MODEL_NAME  Specify the model to use, default is "flux-schnell".
  -s, --seed SEED_VALUE   Set the random seed to generate reproducible results.
  -v, --verbose          Enable debug mode and display detailed log information.

Examples

Basic Usage

./diffuDiff.sh "A cat sitting under the moonlight"

Specify Model and Output Directory

./diffuDiff.sh --model stable-diffusion --output-dir ./custom_outputs/ "A sunflower in Van Gogh's style"

🔧 Technical Details

Acceleration Techniques

1. GPU Acceleration:

   • Ensure that CUDA and cuDNN are correctly installed.
   • Specify the device used by the model in the configuration file, such as "device": "cuda:0".

2. Parallel Processing:

   • Adjust max_images_per_batch in output_settings to control the maximum number of images generated per batch.

3. Memory Optimization:

   • Use low - resolution or smaller models to reduce memory usage.
   • Avoid loading too many models into memory at the same time.

Tutorials and Examples

Quick Start Tutorial

1. Install dependencies and the project (see Installation).
2. Download pre - trained models:

   ./diffuDiff.sh download-models
   

3. Run basic inference:

   ./diffuDiff.sh "A flying bird"
   

Advanced Tutorials

• Customize models: Modify the model path in config.json and add new pre - trained models.
• Batch generation: Set --max_images_per_batch to improve generation efficiency.
• API integration: After enabling the API, you can generate images through HTTP requests.

Troubleshooting

Common Issues

1. Unable to start the script

   • Ensure that all dependencies are correctly installed.
   • Check the log file logs/output.log for more information.

2. Insufficient memory

   • Reduce the resolution of generated images.
   • Use the CPU for inference to avoid overloading the GPU.

3. Model loading failure

   • Confirm that the model path is correct and the file exists.
   • Check if the device settings in the configuration file match the hardware.

Development Guide

Code Structure

The project directory structure is as follows:

diffuDiff/
├── src/                 # Core source code
│   ├── main.cpp        # Main program entry
│   └── ModelLoader.cpp # Model loader
├── CMakeLists.txt       # CMake configuration file
└── config.json          # Project configuration file

Contribution Guide

1. Fork the repository:

   git clone https://github.com/CLOUDWERX-DEV/diffuDiff.git
   cd diffuDiff
   git checkout feature/your-feature
   

2. Submit code

   • Create a feature branch:

     git branch feature/your-feature
     

   • Commit changes:

     git add .
     git commit -m "Add new feature: Your commit message"
     

   • Push to the remote repository and create a pull request.

📚 Documentation

Project Background

DiffuDiff is an image generation tool based on diffusion models, aiming to provide high - performance and flexible configuration. It supports multiple pre - trained models and allows users to customize models and output settings.

Related Links

• GitHub Repository
• Official Documentation
• Issue Feedback

Appendix

Log Files

Log information is stored in the logs/output.log file for debugging and monitoring the running status.

📄 License

The project follows the MIT license. For specific content, see LICENSE.

With the above documentation, you can successfully install, configure, and use DiffuDiff for image generation. If you need further support or encounter problems, please refer to the ISSUES in the GitHub repository or contact the maintenance team.