Show HN: Cool site full of AI models
Replicate
    How it works 
You can get started with any open-source model with just one
                line of code. But as you do more complex things, you fine-tune
                models or deploy your own custom code.
       
Run open-source models
 
Our community has already published thousands of models that
                    are ready to use in production. You can run these with one
                    line of code.
    import replicate

output = replicate.run(
  "black-forest-labs/flux-schnell:f2ab8a5bfe79f02f0789a146cf5e73d2a4ff2684a98c2b303d1e1ff3814271db",
  input={
  "prompt": "An astronaut riding a rainbow unicorn, cinematic, dramatic",  
  "num_outputs": 1,
    "aspect_ratio": "1:1",
    "output_format": "webp",
    "output_quality": 90
  }
)

print(output)     
Fine-tune models with your own data
 
You can improve open-source models with your own data to
                    create new models that are better suited to specific tasks.
 
Image models like Flux can generate images of a particular
                    person, object, or style.
     Train a model:  import replicate

training = replicate.trainings.create(
    version="ostris/flux-dev-lora-trainer:1296f0ab2d695af5a1b5eeee6e8ec043145bef33f1675ce1a2cdb0f81ec43f02",
    input={
        "input_images": "https://my-domain/my-input-images.zip",
    },
    destination="electricdreams/flux-fine-tuned"
)

print(training)    
This will result in a new model:
     
Then, you can run it with one line of code:
  output = replicate.run(
    "electricdreams/flux-fine-tuned:abcde1234...",
    input={"prompt": "a photo of TOK riding a rainbow unicorn"},
)       
Deploy custom models
 
You aren’t limited to the models on Replicate: you can
                        deploy your own custom models using Cog, our open-source tool for packaging machine learning
                        models.
 
Cog takes care of generating an API server and deploying
                        it on a big cluster in the cloud. We scale up and down
                        to handle demand, and you only pay for the compute that
                        you use.
     
First, define the environment your model runs in with
                          cog.yaml:
  build:
  gpu: true
  system_packages:
    - "libgl1-mesa-glx"
    - "libglib2.0-0"
  python_version: "3.10"
  python_packages:
    - "torch==1.13.1"
predict: "predict.py:Predictor"    
Next, define how predictions are run on your model
                          with predict.py:
  from cog import BasePredictor, Input, Path
import torch

class Predictor(BasePredictor):
    def setup(self):
        """Load the model into memory to make running multiple predictions efficient"""
        self.model = torch.load("./weights.pth")

    # The arguments and types the model takes as input
    def predict(self,
          image: Path = Input(description="Grayscale input image")
    ) -> Path:
        """Run a single prediction on the model"""
        processed_image = preprocess(image)
        output = self.model(processed_image)
        return postprocess(output)          