Cara Menjalankan FLUXor Percuma: Panduan Langkah demi Langkah

Flux.1 ialah model teks-ke-imej terbaharu di pasaran, dibawakan kepada kami oleh Black Forest Labs. Ia adalah model terkini yang boleh menjana imej berkualiti tinggi daripada perihalan teks yang mengendalikan perihalan kompleks dan menjana imej berkualiti tinggi dengan butiran halus.

Siapa di belakang Flux.1?

Flux.1 dibangunkan oleh Black Forest Labs, sebuah syarikat yang dicipta oleh sekumpulan bekas pekerja daripada Stability AI.

Bagaimana ia berfungsi?

Tidak seperti model resapan lain, seperti Resapan Stabil yang mencipta imej dengan mengalih keluar hingar secara beransur-ansur dari titik permulaan rawak, Flux.1 menjana imej menggunakan teknik yang dipanggil "padanan aliran" yang mengambil pendekatan yang lebih langsung, mempelajari transformasi tepat yang diperlukan untuk menukar hingar kepada imej yang realistik. Ini membolehkan untuk menjana imej berkualiti tinggi dengan lebih pantas dan dengan langkah yang kurang daripada model resapan biasa.

Selain itu, dengan pendekatan berbeza ini, Flux.1 boleh mengendalikan imej dengan teks di dalamnya, seperti yang di bawah:

Imej fotorealistik komputer riba moden dan anggun dengan halaman web terbuka memaparkan teks "codestackme" dalam reka bentuk yang bersih dan minimalis. Komputer riba hendaklah diletakkan di atas meja putih dengan pencahayaan lembut, menyerlahkan cahaya skrin dan pantulan halus pada selongsong logam. Suasana keseluruhannya hendaklah profesional dan menarik, menyampaikan rasa inovasi dan kemajuan teknologi.

Bagaimana untuk menulis gesaan yang baik untuk Flux.1?

Salah satu ciri menonjol Flux.1 ialah mekanisme gesaan mesra penggunanya. Penyepaduan pengekod teks CLIP (dari OpenAI) dan T5 (daripada GoogleAI) membolehkan model mentafsir penerangan dengan nuansa yang tinggi. CLIP cemerlang dalam menjajarkan teks dengan kandungan visual, manakala T5 meningkatkan keupayaan model untuk memproses input teks berstruktur. Bersama-sama, mereka membolehkan Flux.1 menjana imej yang hampir sepadan dengan gesaan terperinci yang diberikan oleh pengguna.

Apakah jenis model yang ada untuk Flux.1?

Flux.1 didatangkan dalam tiga versi berbeza: Schnell, Dev dan Pro.

• Schnell ialah model terpantas, dioptimumkan untuk kelajuan dan kecekapan. Ia dibenarkan untuk kegunaan komersial, sejak dikeluarkan di bawah lesen Apache 2.0.
• Dev menyediakan rangka kerja yang lebih fleksibel dan eksperimen, ia difokuskan untuk pembangun dan penyelidikan yang ingin memperhalusi atau menyesuaikan ciri tertentu model. Ia dikeluarkan dengan lesen bukan komersial.
• Pro ialah versi yang paling maju dan intensif sumber. Ia menawarkan output resolusi yang lebih tinggi dan boleh menjana imej yang lebih kompleks, namun ia hanya tersedia melalui API Black Forest Labs.

Bagaimana untuk menggunakan Flux.1 secara percuma?

Bagi mereka yang berminat untuk menerokai keupayaan Flux.1 tanpa komitmen kewangan, menggunakan modal.com sebagai penyedia sumber ialah pilihan yang berdaya maju. Modal.com menawarkan elaun kuasa pengiraan bulanan sebanyak $30, yang boleh menyokong penjanaan banyak imej setiap bulan. Anda boleh mengetahui lebih lanjut tentang harga dan tawaran mereka di Harga Modal.com.

Pengesyoran ini tidak ditaja atau disokong oleh platform.

Untuk bermula, anda perlu membuat akaun di modal.com terlebih dahulu dengan melog masuk menggunakan kelayakan GitHub anda.

Seterusnya, anda perlu memasang Modal CLI. Pastikan Python dipasang pada komputer anda. Setelah Python disediakan, buka terminal anda dan laksanakan perintah pip install modal. Selepas pemasangan selesai, jalankan persediaan modal untuk memautkan CLI dengan akaun Modal anda.

Teruskan dengan mengklonkan repositori GitHub ini ke komputer anda dan navigasi ke direktori yang diklon.

Untuk keselamatan, cipta rahsia yang dipanggil flux.1-secret dalam papan pemuka modal anda dengan pembolehubah persekitaran bernama API_KEY dan berikannya rentetan rawak.

Akhir sekali, gunakan perkhidmatan anda dengan menjalankan modal deploy app.py --name flux1 dalam terminal anda. Setelah penggunaan berjaya, modal akan menyediakan URL untuk mengakses perkhidmatan web:

✓ Created objects.
├── ? Created mount PythonPackage:app
├── ? Created function Model.build.
├── ? Created function Model.*.
├── ? Created function Model._inference.
└── ? Created web function Model.web_inference => <PUBLIC_URL>
✓ App deployed in 3.206s! ?

Untuk menggunakan perkhidmatan ini, buat permintaan GET ke URL AWAM yang disediakan. Sertakan kunci x-api yang anda tetapkan lebih awal dalam pengepala dan kodkan gesaan anda dalam parameter pertanyaan. Anda juga boleh menentukan dimensi imej yang diingini melalui parameter pertanyaan. Berikut ialah contoh cara menstruktur permintaan anda:

curl -H "x-api-key: <API_KEY>" <PUBLIC_URL>?width=<WIDTH>&height=<HEIGHT>&prompt=<PROMPT>

Memahami Kod

Mari kita membedah fail app.py, yang penting untuk menjalankan perkhidmatan penjanaan imej Flux.1 kami menggunakan platform modal. Berikut ialah pecahan persediaan dan kefungsian:

import modal

image = modal.Image.debian_slim(python_version="3.10").apt_install(
    "libglib2.0-0", 
    "libsm6", 
    "libxrender1", 
    "libxext6", 
    "ffmpeg", 
    "libgl1",
    "git"
).pip_install(
    "git+https://github.com/huggingface/diffusers.git",
    "invisible_watermark",
    "transformers",
    "accelerate",
    "safetensors",
    "sentencepiece",
)

Blok ini mentakrifkan imej Docker untuk aplikasi kami, menyatakan OS, perpustakaan yang diperlukan dan pakej Python. Persekitaran ini menyokong pelaksanaan model Flux.1 dan utiliti yang berkaitan.

app = modal.App('flux1')

with image.imports():
    import os
    import io
    import torch
    from diffusers import FluxPipeline
    from fastapi import Response, Header

Here, we initialize our app and import necessary Python libraries within the context of our previously defined Docker image. These imports are essential for image processing and handling web requests.

@app.cls(gpu=modal.gpu.A100(), container_idle_timeout=15, image=image, timeout=120, secrets=[modal.Secret.from_name("flux.1-secret")])
class Model:
    @modal.build()
    def build(self):
        from huggingface_hub import snapshot_download

        snapshot_download("black-forest-labs/FLUX.1-schnell")

    @modal.enter()
    def enter(self):
        print("Loading model...")
        self.pipeline = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16).to('cuda')
        print("Model loaded!")

    def inference(self, prompt: str, width: int = 1440, height: int = 1440):
        print("Generating image...")
        image = self.pipeline(
            prompt, 
            output_type='pil', 
            width=width, 
            height=height, 
            num_inference_steps=8,
            generator=torch.Generator("cpu").manual_seed(
                torch.randint(0, 1000000, (1,)).item()
            )
        ).images[0]

        print("Image generated!")

        byte_stream = io.BytesIO()
        image.save(byte_stream, format="PNG")

        return byte_stream.getvalue()

    @modal.web_endpoint(docs=True)
    def web_inference(self, prompt: str, width: int = 1440, height: int = 1440, x_api_key: str = Header(None)):
        api_key = os.getenv("API_KEY")
        if x_api_key != api_key:
            return Response(content="Unauthorized", status_code=401)

        image = self.inference(prompt, width, height)
        return Response(content=image, media_type="image/png")

This section defines the main functionality of our service:

• @modal.build(): Downloads the model when the application builds.
• @modal.enter(): Loads the model into GPU memory the first time the service is invoked.
• @modal.web_endpoint(): Serves as the web endpoint for our service using FastAPI.

If you just want to run it as a local service, you can add @modal.method() and define it as following inside the class.

        @modal.method()
    def _inference(self, prompt: str, width: int = 1440, height: int = 1440):
        return self.inference(prompt, width, height)

And outside it, define a local entry point

@app.local_entrypoint()
def main(prompt: str = "A beautiful sunset over the mountains"):
    image_bytes = Model()._inference.remote(prompt)

    with open("output.png", "wb") as f:
        f.write(image_bytes)

Local entry point will run locally on your machine calling the _inference method remotely, so you still using the modal’s service, without exposing it to the internet.

Conclusion

Flux.1 is not just another tech breakthrough - it's a game-changer for anyone who's ever dreamed of bringing their ideas to life visually. Imagine being able to describe a scene in words and watch as it materializes into a stunning, detailed image right before your eyes. That's the magic of Flux.1. It's like having a super-talented artist at your fingertips, ready to paint your thoughts with incredible precision. Whether you're an artist looking to speed up your creative process, a designer in need of quick visual concepts, or just someone who loves playing with new tech, Flux.1 opens up a world of possibilities. It's not about replacing human creativity - it's about enhancing it, making the journey from imagination to reality smoother and more exciting than ever before.

Atas ialah kandungan terperinci Cara Menjalankan FLUXor Percuma: Panduan Langkah demi Langkah. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!