Photon Flash

photon-flash

Photon Flash is an advanced flash tool that enhances lighting conditions for photography, offering custom settings for high-quality images

Fast Inference

REST API

Try in Console API Docs Examples

Model Information

Response Time~8 sec

StatusActive

Version

0.0.1

Updatedabout 2 months ago

Live Demo

Average runtime: ~8 seconds

Input

Configure model parameters

Prompt

Text prompt for image generation

Hand reaching up for falling purple flower petals, subdue, realistic camera.

aspect_ratio

An enumeration.

Image Reference Url

URL of a reference image to guide generation

Enter your image reference url

Image Reference Weight

Weight of the reference image. Larger values will make the reference image have a stronger influence on the generated image.

0.85

Style Reference Url

URL of a style reference image

Enter your style reference url

Style Reference Weight

Weight of the style reference image

0.85

Character Reference Url

URL of a character reference image

Enter your character reference url

Seed

Random seed. Set for reproducible generation

Enter your seed

Output

View generated results

Result

Preview, share or download your results with a single click.

Each execution costs $0.011 With $1 you can run this model about 90 times.

API Reference

View Full Documentation

Prerequisites

Create an API Key from the Eachlabs Console
Install the required dependencies for your chosen language (e.g., requests for Python)

API Integration Steps

1. Create a Prediction

Send a POST request to create a new prediction. This will return a prediction ID that you'll use to check the result. The request should include your model inputs and API key.

import requests
import time

API_KEY = "YOUR_API_KEY"  # Replace with your API key
HEADERS = {
    "X-API-Key": API_KEY,
    "Content-Type": "application/json"
}

def create_prediction():
    response = requests.post(
        "https://api.eachlabs.ai/v1/prediction/",
        headers=HEADERS,
        json={
            "model": "photon-flash",
            "version": "0.0.1",
            "input": {
  "seed": 0,
  "prompt": "your prompt here",
  "aspect_ratio": "16:9",
  "image_reference_url": "your image reference url here",
  "style_reference_url": "your style reference url here",
  "image_reference_weight": 0.85,
  "style_reference_weight": 0.85,
  "character_reference_url": "your character reference url here"
}
        }
    )
    prediction = response.json()
    
    if prediction["status"] != "success":
        raise Exception(f"Prediction failed: {prediction}")
    
    return prediction["predictionID"]

2. Get Prediction Result

Poll the prediction endpoint with the prediction ID until the result is ready. The API uses long-polling, so you'll need to repeatedly check until you receive a success status.

def get_prediction(prediction_id):
    while True:
        result = requests.get(
            f"https://api.eachlabs.ai/v1/prediction/{prediction_id}",
            headers=HEADERS
        ).json()
        
        if result["status"] == "success":
            return result
        elif result["status"] == "error":
            raise Exception(f"Prediction failed: {result}")
        
        time.sleep(1)  # Wait before polling again

3. Complete Example

Here's a complete example that puts it all together, including error handling and result processing. This shows how to create a prediction and wait for the result in a production environment.

try:
    # Create prediction
    prediction_id = create_prediction()
    print(f"Prediction created: {prediction_id}")
    
    # Get result
    result = get_prediction(prediction_id)
    print(f"Output URL: {result['output']}")
    print(f"Processing time: {result['metrics']['predict_time']}s")
except Exception as e:
    print(f"Error: {e}")

Additional Information

The API uses a two-step process: create prediction and poll for results
Response time: ~8 seconds
Rate limit: 60 requests/minute
Concurrent requests: 10 maximum
Use long-polling to check prediction status until completion

Overview

Photon Flush is designed to generate high-quality images based on user-provided prompts and references. With a focus on flexibility, it allows users to combine textual descriptions with visual inputs, ensuring precise and creative outputs. Photon Flush supports adjustable parameters for aspect ratios, weights, and style references, making it suitable for a wide range of creative needs.

Technical Specifications

Reproducibility: Facilitates consistent results using the seed parameter for controlled variations.
Adaptive Visual Rendering: Employs advanced algorithms to synthesize outputs with high fidelity and detail.
Customizable Parameters: Photon Flush offers a wide range of inputs for personalized and specific content creation.
Reference Integration: Photon Flush supports multiple reference types (image, style, character) for contextual and stylistic guidance.
Aspect Ratio Flexibility: Ensures compatibility with diverse display formats, from square to ultra-wide.

Key Considerations

URL Validity: Ensure all reference URLs are accessible and point to appropriate image files.

Prompt Clarity: Ambiguous prompts may lead to unexpected results. Avoid vague or overly complex descriptions.

Weight Balancing: Extreme weight values may overly emphasize one reference, reducing overall coherence.

Aspect Ratio: Incorrect aspect ratio selection might result in cropped or distorted outputs.

Legal Information for Photon Flash

By using this model, you agree to:

Luma Privacy
Luma Terms of Use

Tips & Tricks

Aspect Ratio Selection:

1:1: Best for social media posts and profile images. Balanced and versatile.
3:4: Ideal for portrait-oriented outputs, such as posters or personal artwork.
4:3: Suited for traditional photography or web display.
9:16: Perfect for mobile-first designs or vertical content like stories.
16:9: Best for widescreen visuals, such as presentations or video thumbnails.
9:21 and 21:9: Use for ultra-tall or cinematic outputs, respectively.

Prompt Optimization: Use specific keywords (e.g., "vibrant", "moody", "realistic") to define tone and style.

Image Reference Weight: Start with a neutral value (e.g., 0.5). Increase for more influence or decrease for subtler effects.

Style Reference Weight: Adjust based on desired stylistic consistency. Higher values lead to a stronger stylistic presence.

Character Reference Weight: Use moderate values for detailed character incorporation without overpowering the overall image.

Capabilities

Combine textual prompts with visual references for tailored outputs.

Generate diverse aspect ratios to suit various use cases.

Fine-tune outputs with adjustable weights for image, style, and character references.

What can I use for?

Content Creation: Photon Flush generates images for blogs, websites, or social media.

Design Prototypes: Photon Flush visualizes ideas for branding, packaging, or layouts.

Storyboarding: Develop visual elements for narratives or presentations.

Creative Exploration: Experiment with styles, themes, and characters for artistic projects.

Things to be aware of

Combine a descriptive prompt with a strong style reference to mimic famous art styles with Photon Flush

Use high weights for character references to create distinct portraits.

Experiment with seeds to explore variations of the same concept.

Choose 9:16 for Instagram stories or 16:9 for cinematic visuals.

Limitations

Outputs depend heavily on the quality and relevance of inputs.

Over-reliance on reference images might limit the model’s creative flexibility.

High reference weights can overshadow the prompt’s influence.

Output Format: JPG

Related AI Models