Genera immagini utilizzando prompt di testo

Console

1. Nella console Google Cloud, apri la scheda Vertex AI Studio > Media nella dashboard di Vertex AI.

   Vai alla scheda Vertex AI Studio

2. Nel campo Scrivi il prompt, inserisci una descrizione per le immagini che vuoi generare. Per informazioni dettagliate su come scrivere prompt efficaci, consulta la guida ai prompt.

   • Ad esempio: illustrazione acquerello di una piccola barca sull'acqua al mattino

3. Facoltativo. Nella casella Opzioni modello del riquadro Parametri, seleziona la versione del modello da utilizzare. Per ulteriori informazioni, consulta le versioni del modello.

4. Facoltativo. Modificare i parametri standard e avanzati.

5. Per generare le immagini, fai clic su play_arrowGenera.

   

REST

Per ulteriori informazioni sulle richieste del modello imagegeneration, consulta la documentazione di riferimento dell'API del modello imagegeneration.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto Google Cloud.
• MODEL_VERSION: la versione del modello imagegeneration da utilizzare. Valori disponibili:
  • Imagen 3:
    • imagen-3.0-generate-001
    • imagen-3.0-fast-generate-001 - Versione del modello a bassa latenza.
  • Versione del modello predefinita:
    • imagegeneration: utilizza la versione predefinita del modello v.006. Come best practice, devi sempre specificare una versione del modello, in particolare negli ambienti di produzione.

  Per ulteriori informazioni sulle funzionalità e sulle versioni dei modelli, consulta le versioni del modello.

• LOCATION: la regione del progetto. Ad esempio, us-central1, europe-west2 o asia-northeast3. Per un elenco delle regioni disponibili, consulta Località dell'IA generativa su Vertex AI.
• TEXT_PROMPT: il prompt di testo indica le immagini generate dal modello. Questo campo è obbligatorio sia per la generazione che per la modifica.
• IMAGE_COUNT: il numero di immagini generate. Valori interi accettati: 1-8 (v.002), 1-4 (tutte le altre versioni del modello). Valore predefinito: 4.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_VERSION:predict

Corpo JSON della richiesta:

{
  "instances": [
    {
      "prompt": "TEXT_PROMPT"
    }
  ],
  "parameters": {
    "sampleCount": IMAGE_COUNT
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_VERSION:predict"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_VERSION:predict" | Select-Object -Expand Content

{
  "predictions": [
    {
      "bytesBase64Encoded": "BASE64_IMG_BYTES",
      "mimeType": "image/png"
    },
    {
      "mimeType": "image/png",
      "bytesBase64Encoded": "BASE64_IMG_BYTES"
    }
  ]
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python di Vertex AI.

Per autenticarti a Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

In questo esempio, chiami il metodo generate_images su ImageGenerationModel e salvi le immagini generate localmente. Se vuoi, puoi utilizzare il metodo show() in un notebook per visualizzare le immagini generate. Per ulteriori informazioni su funzionalità e versioni dei modelli, consulta le versioni dei modelli.

import vertexai
from vertexai.preview.vision_models import ImageGenerationModel

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# output_file = "input-image.png"
# prompt = "" # The text prompt describing what you want to see.

vertexai.init(project=PROJECT_ID, location="us-central1")

model = ImageGenerationModel.from_pretrained("imagen-3.0-generate-001")

images = model.generate_images(
    prompt=prompt,
    # Optional parameters
    number_of_images=1,
    language="en",
    # You can't use a seed value and watermark at the same time.
    # add_watermark=False,
    # seed=100,
    aspect_ratio="1:1",
    safety_filter_level="block_some",
    person_generation="allow_adult",
)

images[0].save(location=output_file, include_generation_parameters=False)

# Optional. View the generated image in a notebook.
# images[0].show()

print(f"Created output image using {len(images[0]._image_bytes)} bytes")
# Example response:
# Created output image using 1234567 bytes

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java di Vertex AI.

Per autenticarti a Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

In questo esempio, specifichi il modello imagen-3.0-generate-001 come parte di un EndpointName. EndpointName viene passato al metodo predict che viene chiamato su un PredictionServiceClient. Il servizio genera immagini che vengono poi salvate localmente. Per ulteriori informazioni sulle funzionalità e sulle versioni dei modelli, consulta le versioni dei modelli.

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.gson.Gson;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class GenerateImageSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project-id";
    String location = "us-central1";
    String prompt = ""; // The text prompt describing what you want to see.

    generateImage(projectId, location, prompt);
  }

  // Generate an image using a text prompt using an Imagen model
  public static PredictResponse generateImage(String projectId, String location, String prompt)
      throws ApiException, IOException {
    final String endpoint = String.format("%s-aiplatform.googleapis.com:443", location);
    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder().setEndpoint(endpoint).build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings)) {

      final EndpointName endpointName =
          EndpointName.ofProjectLocationPublisherModelName(
              projectId, location, "google", "imagen-3.0-generate-001");

      Map<String, Object> instancesMap = new HashMap<>();
      instancesMap.put("prompt", prompt);
      Value instances = mapToValue(instancesMap);

      Map<String, Object> paramsMap = new HashMap<>();
      paramsMap.put("sampleCount", 1);
      // You can't use a seed value and watermark at the same time.
      // paramsMap.put("seed", 100);
      // paramsMap.put("addWatermark", false);
      paramsMap.put("aspectRatio", "1:1");
      paramsMap.put("safetyFilterLevel", "block_some");
      paramsMap.put("personGeneration", "allow_adult");
      Value parameters = mapToValue(paramsMap);

      PredictResponse predictResponse =
          predictionServiceClient.predict(
              endpointName, Collections.singletonList(instances), parameters);

      for (Value prediction : predictResponse.getPredictionsList()) {
        Map<String, Value> fieldsMap = prediction.getStructValue().getFieldsMap();
        if (fieldsMap.containsKey("bytesBase64Encoded")) {
          String bytesBase64Encoded = fieldsMap.get("bytesBase64Encoded").getStringValue();
          Path tmpPath = Files.createTempFile("imagen-", ".png");
          Files.write(tmpPath, Base64.getDecoder().decode(bytesBase64Encoded));
          System.out.format("Image file written to: %s\n", tmpPath.toUri());
        }
      }
      return predictResponse;
    }
  }

  private static Value mapToValue(Map<String, Object> map) throws InvalidProtocolBufferException {
    Gson gson = new Gson();
    String json = gson.toJson(map);
    Value.Builder builder = Value.newBuilder();
    JsonFormat.parser().merge(json, builder);
    return builder.build();
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js di Vertex AI.

Per autenticarti a Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * TODO(developer): Update these variables before running the sample.
 */
const projectId = process.env.CAIP_PROJECT_ID;
const location = 'us-central1';
const prompt = 'a dog reading a newspaper';

const aiplatform = require('@google-cloud/aiplatform');

// Imports the Google Cloud Prediction Service Client library
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects
const {helpers} = aiplatform;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: `${location}-aiplatform.googleapis.com`,
};

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function generateImage() {
  const fs = require('fs');
  const util = require('util');
  // Configure the parent resource
  const endpoint = `projects/${projectId}/locations/${location}/publishers/google/models/imagen-3.0-generate-001`;

  const promptText = {
    prompt: prompt, // The text prompt describing what you want to see
  };
  const instanceValue = helpers.toValue(promptText);
  const instances = [instanceValue];

  const parameter = {
    sampleCount: 1,
    // You can't use a seed value and watermark at the same time.
    // seed: 100,
    // addWatermark: false,
    aspectRatio: '1:1',
    safetyFilterLevel: 'block_some',
    personGeneration: 'allow_adult',
  };
  const parameters = helpers.toValue(parameter);

  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);
  const predictions = response.predictions;
  if (predictions.length === 0) {
    console.log(
      'No image was generated. Check the request parameters and prompt.'
    );
  } else {
    let i = 1;
    for (const prediction of predictions) {
      const buff = Buffer.from(
        prediction.structValue.fields.bytesBase64Encoded.stringValue,
        'base64'
      );
      // Write image content to the output file
      const writeFile = util.promisify(fs.writeFile);
      const filename = `output${i}.png`;
      await writeFile(filename, buff);
      console.log(`Saved image ${filename}`);
      i++;
    }
  }
}
await generateImage();

Console

1. Nella console Google Cloud, apri la scheda Vertex AI Studio > Media nella dashboard di Vertex AI.

   Vai alla scheda Vertex AI Studio

2. Nel campo Scrivi il prompt, inserisci una descrizione per le immagini che vuoi generare. Per informazioni dettagliate su come scrivere prompt efficaci, consulta la guida ai prompt.

   • Ad esempio: illustrazione acquerello di una piccola barca sull'acqua al mattino

3. Facoltativo. Nella casella Opzioni modello del riquadro Parametri, seleziona la versione del modello da utilizzare. Per ulteriori informazioni, consulta le versioni del modello.

4. Facoltativo. Modificare i parametri standard e avanzati.

5. Per generare le immagini, fai clic su play_arrowGenera.

6. Versione del modello 006 e successive: viene aggiunta automaticamente una filigrana digitale alle immagini generate. Non puoi disattivare la filigrana digitale per la generazione di immagini utilizzando la console Google Cloud.

   Puoi selezionare un'immagine per aprire la finestra Dettagli immagine. Le immagini con filigrana contengono un badge local_policeFiligrana digitale. Puoi anche verificare esplicitamente una filigrana immagine.

   

REST

Per ulteriori informazioni sulle richieste del modello imagegeneration, consulta la documentazione di riferimento dell'API del modello imagegeneration.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto Google Cloud.
• MODEL_VERSION: la versione del modello imagegeneration da utilizzare. Valori disponibili:
  • imagen-3.0-generate-001
  • imagen-3.0-fast-generate-001 - Versione del modello a bassa latenza.
  • imagegeneration@006

  Per ulteriori informazioni sulle funzionalità e sulle versioni dei modelli, consulta le versioni del modello.

• LOCATION: la regione del progetto. Ad esempio, us-central1, europe-west2 o asia-northeast3. Per un elenco delle regioni disponibili, consulta Località dell'IA generativa su Vertex AI.
• TEXT_PROMPT: il prompt di testo indica le immagini generate dal modello. Questo campo è obbligatorio sia per la generazione che per la modifica.
• IMAGE_COUNT: il numero di immagini generate. Valori interi accettati: 1-8 (v.002), 1-4 (tutte le altre versioni del modello). Valore predefinito: 4.
• addWatermark: un valore booleano per attivare una filigrana per le immagini generate. Qualsiasi immagine generata quando il campo è impostato su true contiene un SynthID digitale che puoi utilizzare per verificare un'immagine con filigrana. Se ometti questo campo, viene utilizzato il valore predefinito true. Per disattivare questa funzionalità, devi impostare il valore su false. Puoi utilizzare il campo seed per ottenere un output deterministico solo se questo campo è impostato su false.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_VERSION:predict

Corpo JSON della richiesta:

{
  "instances": [
    {
      "prompt": "TEXT_PROMPT"
    }
  ],
  "parameters": {
    "sampleCount": IMAGE_COUNT,
    "addWatermark": true
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_VERSION:predict"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_VERSION:predict" | Select-Object -Expand Content

{
  "predictions": [
    {
      "mimeType": "image/png",
      "bytesBase64Encoded": "BASE64_IMG_BYTES"
    },
    {
      "bytesBase64Encoded": "BASE64_IMG_BYTES",
      "mimeType": "image/png"
    }
  ]
}

SDK Vertex AI per Python

import vertexai
from vertexai.preview.vision_models import ImageGenerationModel

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# output_file = "input-image.png"
# prompt = "" # The text prompt describing what you want to see.

vertexai.init(project=PROJECT_ID, location="us-central1")

model = ImageGenerationModel.from_pretrained("imagen-3.0-generate-001")

images = model.generate_images(
    prompt=prompt,
    # Optional parameters
    number_of_images=1,
    language="en",
    # You can't use a seed value and watermark at the same time.
    # add_watermark=False,
    # seed=100,
    aspect_ratio="1:1",
    safety_filter_level="block_some",
    person_generation="allow_adult",
)

images[0].save(location=output_file, include_generation_parameters=False)

# Optional. View the generated image in a notebook.
# images[0].show()

print(f"Created output image using {len(images[0]._image_bytes)} bytes")
# Example response:
# Created output image using 1234567 bytes

Node.js

/**
 * TODO(developer): Update these variables before running the sample.
 */
const projectId = process.env.CAIP_PROJECT_ID;
const location = 'us-central1';
const prompt = 'a dog reading a newspaper';

const aiplatform = require('@google-cloud/aiplatform');

// Imports the Google Cloud Prediction Service Client library
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects
const {helpers} = aiplatform;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: `${location}-aiplatform.googleapis.com`,
};

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function generateImage() {
  const fs = require('fs');
  const util = require('util');
  // Configure the parent resource
  const endpoint = `projects/${projectId}/locations/${location}/publishers/google/models/imagen-3.0-generate-001`;

  const promptText = {
    prompt: prompt, // The text prompt describing what you want to see
  };
  const instanceValue = helpers.toValue(promptText);
  const instances = [instanceValue];

  const parameter = {
    sampleCount: 1,
    // You can't use a seed value and watermark at the same time.
    // seed: 100,
    // addWatermark: false,
    aspectRatio: '1:1',
    safetyFilterLevel: 'block_some',
    personGeneration: 'allow_adult',
  };
  const parameters = helpers.toValue(parameter);

  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);
  const predictions = response.predictions;
  if (predictions.length === 0) {
    console.log(
      'No image was generated. Check the request parameters and prompt.'
    );
  } else {
    let i = 1;
    for (const prediction of predictions) {
      const buff = Buffer.from(
        prediction.structValue.fields.bytesBase64Encoded.stringValue,
        'base64'
      );
      // Write image content to the output file
      const writeFile = util.promisify(fs.writeFile);
      const filename = `output${i}.png`;
      await writeFile(filename, buff);
      console.log(`Saved image ${filename}`);
      i++;
    }
  }
}
await generateImage();

Console

1. Nella console Google Cloud, apri la scheda Vertex AI Studio > Media nella dashboard di Vertex AI.

   Vai alla scheda Vertex AI Studio

2. Nel riquadro in basso, fai clic su local_policeVerifica.

3. Fai clic su Carica immagine.

4. Seleziona un'immagine generata salvata localmente.

   

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto Google Cloud.
• LOCATION: la regione del progetto. Ad esempio, us-central1, europe-west2 o asia-northeast3. Per un elenco delle regioni disponibili, consulta Località dell'IA generativa su Vertex AI.
• B64_IMAGE: l'immagine da verificare che contiene una filigrana digitale. L'immagine deve essere specificata come stringa di byte codificata in base64. Dimensioni massime: 10 MB.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/imageverification@001:predict

Corpo JSON della richiesta:

{
  "instances": [
    {
      "image": {
        "bytesBase64Encoded": "B64_IMAGE"
      }
    }
  ],
  "parameters": {
    "watermarkVerification": true
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/imageverification@001:predict"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/imageverification@001:predict" | Select-Object -Expand Content

{
  "predictions": [
    {
      "decision": "ACCEPT"
    }
  ]
}

SDK Vertex AI per Python

import vertexai
from vertexai.preview.vision_models import (
    Image,
    WatermarkVerificationModel,
)

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# input_file = "input-image.png"

vertexai.init(project=PROJECT_ID, location="us-central1")

verification_model = WatermarkVerificationModel.from_pretrained(
    "imageverification@001"
)
image = Image.load_from_file(location=input_file)

watermark_verification_response = verification_model.verify_image(image)

print(
    f"Watermark verification result: {watermark_verification_response.watermark_verification_result}"
)
# Example response:
# Watermark verification result: ACCEPT
# or "REJECT" if the image does not contain a digital watermark.

Node.js

/**
 * TODO(developer): Update these variables before running the sample.
 */
const projectId = process.env.CAIP_PROJECT_ID;
const location = 'us-central1';
const inputFile = 'resources/dog_newspaper.png'; // has watermark

const aiplatform = require('@google-cloud/aiplatform');

// Imports the Google Cloud Prediction Service Client library
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects
const {helpers} = aiplatform;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: `${location}-aiplatform.googleapis.com`,
};

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function verifyImageWatermark() {
  const fs = require('fs');
  // Configure the parent resource
  const endpoint = `projects/${projectId}/locations/${location}/publishers/google/models/imageverification@001`;

  const imageFile = fs.readFileSync(inputFile);
  // Convert the image data to a Buffer and base64 encode it.
  const encodedImage = Buffer.from(imageFile).toString('base64');

  const instance = {
    image: {
      bytesBase64Encoded: encodedImage,
    },
  };
  const instanceValue = helpers.toValue(instance);
  const instances = [instanceValue];

  const request = {
    endpoint,
    instances,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);
  const predictions = response.predictions;
  if (predictions.length === 0) {
    console.log('No decision was generated. Check the request image.');
  } else {
    predictions.forEach(prediction => {
      // "ACCEPT" if the image contains a digital watermark
      // "REJECT" if the image does not contain a digital watermark
      console.log(prediction.structValue.fields.decision.stringValue);
    });
  }
}
await verifyImageWatermark();

Console

1. Nella console Google Cloud, apri la scheda Vertex AI Studio > Media nella dashboard di Vertex AI.

   Vai alla scheda Vertex AI Studio

2. Aggiungi il prompt di testo e scegli i parametri di input.

3. Se non è espansa, fai clic su Opzioni avanzate.

4. Fai clic su Impostazioni di sicurezza.

5. Scegli le impostazioni di sicurezza:

   • Generare persone/volti: scegli un'impostazione:
     • Allow (All ages)
     • Allow (Adults only)
     • Don't allow
   • Soglia del filtro di sicurezza: scegli un'impostazione:
     • Block low and above
     • Block medium and above
     • Block only high

6. Fai clic su Salva.

7. Fai clic su play_arrowGenera.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto Google Cloud.
• LOCATION: la regione del progetto. Ad esempio, us-central1, europe-west2 o asia-northeast3. Per un elenco delle regioni disponibili, consulta Località dell'IA generativa su Vertex AI.
• TEXT_PROMPT: il prompt di testo indica le immagini generate dal modello. Questo campo è obbligatorio sia per la generazione che per la modifica.
• IMAGE_COUNT: il numero di immagini generate. Valori interi accettati: 1-8 (v.002), 1-4 (tutte le altre versioni del modello). Valore predefinito: 4.
• SAFETY_SETTING: facoltativo. Un'impostazione che controlla le soglie del filtro di sicurezza per le immagini generate. Valori disponibili:
  • block_low_and_above: la soglia di sicurezza più elevata, che comporta la maggior quantità di immagini generate filtrate. Valore precedente: block_most.
  • block_medium_and_above (valore predefinito): una soglia di sicurezza media che bilancia il filtro per contenuti potenzialmente dannosi e sicuri. Valore precedente: block_some.
  • block_only_high: una soglia di sicurezza che riduce il numero di richieste bloccate a causa dei filtri di sicurezza. Questa impostazione potrebbe aumentare i contenuti discutibili generati da Imagen. Valore precedente: block_few.
• PERSON_SETTING: facoltativo. L'impostazione di sicurezza che controlla il tipo di persone o generazione di volti consentita dal modello. Valori disponibili:
  • allow_all: consenti la generazione di persone di tutte le età. Questa opzione è disponibile solo per i clienti offline.
  • allow_adult (impostazione predefinita): consenti la generazione solo di persone adulte, ad eccezione della generazione di celebrità. La generazione di celebrità non è consentita per nessuna impostazione.
  • dont_allow: disattiva l'inclusione di persone o volti nelle immagini generate.
• INCLUDE_RAI_REASON: facoltativo. Un valore booleano che indica se attivare il codice di motivo filtrato dall'IA responsabile nelle risposte con input o output bloccati. Valore predefinito: false.
• INCLUDE_SAFETY_ATTRIBUTES: facoltativo. Indica se attivare i punteggi dell'IA responsabile arrotondati per un elenco di attributi di sicurezza nelle risposte per input e output non filtrati. Categorie di attributi di sicurezza: "Death, Harm & Tragedy", "Firearms & Weapons", "Hate", "Health", "Illicit Drugs", "Politics", "Porn", "Religion & Belief", "Toxic", "Violence", "Vulgarity", "War & Conflict". Valore predefinito: false.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/imagegeneration@006:predict

Corpo JSON della richiesta:

{
  "instances": [
    {
      "prompt": "TEXT_PROMPT"
    }
  ],
  "parameters": {
    "sampleCount": IMAGE_COUNT,
    "safetySetting": "SAFETY_SETTING",
    "personGeneration": "PERSON_SETTING",
    "includeRaiReason": INCLUDE_RAI_REASON,
    "includeSafetyAttributes": INCLUDE_SAFETY_ATTRIBUTES
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/imagegeneration@006:predict"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/imagegeneration@006:predict" | Select-Object -Expand Content

Console

Se il prompt è in una delle lingue supportate, Imagen rileva e traduce automaticamente il testo e restituisce le immagini generate o modificate.

Se il prompt è in una lingua non supportata, Imagen utilizza il testo verbatim per la richiesta. Ciò potrebbe comportare un output imprevisto.

REST

Per ulteriori informazioni sulle richieste del modello imagegeneration, consulta la documentazione di riferimento dell'API del modello imagegeneration.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto Google Cloud.
• TEXT_PROMPT: il prompt di testo indica le immagini generate dal modello. Questo campo è obbligatorio sia per la generazione che per la modifica.
• PROMPT_LANGUAGE: il codice lingua che corrisponde alla lingua del prompt di testo. In questo esempio, sarà hi. Valori disponibili:
  • auto - Rilevamento automatico. Se Imagen rileva una lingua supportata, il prompt (e, facoltativamente, un prompt negativo) vengono tradotti in inglese. Se la lingua rilevata non è supportata, Imagen utilizza il testo inserito alla lettera, il che potrebbe comportare risultati inattesi. Non viene restituito alcun codice di errore.
  • en - Inglese (valore predefinito se omesso)
  • es - Spagnolo
  • hi - Hindi
  • ja - Giapponese
  • ko - Coreano
  • pt - Portoghese
  • zh-TW - Cinese (tradizionale)
  • zh o zh-CN - Cinese (semplificato)

Metodo HTTP e URL:

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/imagegeneration@005:predict

Corpo JSON della richiesta:

{
  "instances": [
    {
      "prompt": "सूर्यास्त के समय एक समुद्र तट। उड़ते पक्षी, हवा में लहराते नारियल के पेड़। लोग समुद्र तट पर सैर का आनंद ले रहे हैं।"
    }
  ],
  "parameters": {
    "language": "PROMPT_LANGUAGE"
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/imagegeneration@005:predict"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/imagegeneration@005:predict" | Select-Object -Expand Content

{
  "predictions": [
    {
      "bytesBase64Encoded": "BASE64_IMG_BYTES",
      "mimeType": "image/png"
    },
    {
      "mimeType": "image/png",
      "bytesBase64Encoded": "BASE64_IMG_BYTES"
    }
  ]
}

Console

1. Segui le istruzioni per la generazione di immagini con testo per aprire Vertex AI Studio e inserire il prompt di testo.

2. Nel riquadro Parametri, seleziona un'opzione dal menu Rapporto aspetto.

3. Fai clic su play_arrowGenera.

REST

Le proporzioni sono un campo facoltativo nell'oggetto parameters di un corpo della richiesta JSON.

1. Segui le istruzioni per la generazione di immagini con testo per sostituire altre variabili del corpo della richiesta.

2. Sostituisci quanto segue:

   • ASPECT_RATIO: facoltativo. Un parametro della modalità di generazione che controlla le proporzioni. Valori del rapporto supportati e relativo utilizzo previsto:
     • 1:1 (valore predefinito, quadrato)
     • 3:4 (annunci, social media)
     • 4:3 (TV, fotografia)
     • 16:9 (orizzontale)
     • 9:16 (verticale)

   {
     "instances": [
       ...
     ],
     "parameters": {
       "sampleCount": IMAGE_COUNT,
       "aspectRatio": "ASPECT_RATIO"
     }
   }
   

3. Segui le istruzioni per la generazione di immagini con testo per eseguire la richiesta REST.

Console

1. Segui le istruzioni per la generazione di immagini con testo per aprire Vertex AI Studio e inserire il prompt di testo.

2. Nel riquadro Parametri, seleziona un valore intero valido nel campo Numero di risultati.

3. Fai clic su play_arrowGenera.

REST

Per ulteriori informazioni sulle richieste del modello imagegeneration, consulta la documentazione di riferimento dell'API del modello imagegeneration.

Il numero di risultati è un campo dell'oggetto parameters del corpo della richiesta JSON.

1. Segui le istruzioni per la generazione di immagini con testo per sostituire altre variabili del corpo della richiesta.

2. Sostituisci quanto segue:

   • IMAGE_COUNT: il numero di immagini generate. Valori interi accettati: 1-8 (v.002), 1-4 (tutte le altre versioni del modello). Valore predefinito: 4.

   {
     "instances": [
       ...
     ],
     "parameters": { 
       "sampleCount": IMAGE_COUNT
     }
   }
   

3. Segui le istruzioni per la generazione di immagini con testo per eseguire la richiesta REST.

Console

1. Segui le istruzioni per la generazione di immagini con testo per aprire Vertex AI Studio e inserire il prompt di testo.

2. Nel riquadro Parametri, inserisci un prompt negativo nel campo Prompt negativo.

3. Fai clic su play_arrowGenera.

REST

Per ulteriori informazioni sulle richieste del modello imagegeneration, consulta la documentazione di riferimento dell'API del modello imagegeneration.

Il prompt negativo è un campo facoltativo nell'oggetto parameters di un corpo della richiesta JSON.

1. Segui le istruzioni per la generazione di immagini con testo per sostituire altre variabili del corpo della richiesta.

2. Sostituisci quanto segue:

   • NEGATIVE_PROMPT: un prompt negativo per contribuire a generare le immagini. Ad esempio: "animals" (rimuove gli animali), "blurry" (rende l'immagine più chiara), "text" (rimuove il testo) o "cropped" (rimuove le immagini ritagliate).

   {
     "instances": [
       ...
     ],
     "parameters": {
       "sampleCount": IMAGE_COUNT,
       "negativePrompt": "NEGATIVE_PROMPT"
     }
   }
   

3. Segui le istruzioni per la generazione di immagini con testo per eseguire la richiesta REST.

Console

1. Segui le istruzioni per la generazione di immagini con testo per aprire Vertex AI Studio e inserire il prompt di testo.

2. Nel riquadro Parametri, fai clic sulla sezione espandibile expand_moreOpzioni avanzate.

3. Nel campo Seed, inserisci un numero seed.

4. Fai clic su play_arrowGenera.

REST

Per ulteriori informazioni sulle richieste del modello imagegeneration, consulta la documentazione di riferimento dell'API del modello imagegeneration.

Il numero di seed è un campo facoltativo nell'oggetto parameters del corpo della richiesta JSON.

1. Segui le istruzioni per la generazione di immagini con testo per sostituire altre variabili del corpo della richiesta.

2. Sostituisci quanto segue:

   • SEED_NUMBER: qualsiasi numero intero non negativo fornito per rendere deterministiche le immagini di output. Se fornisci lo stesso numero di seed, otterrai sempre le stesse immagini di output. Valori interi accettati: 1 - 2147483647.

   {
     "instances": [
       ...
     ],
     "parameters": {
       "sampleCount": IMAGE_COUNT,
       "seed": SEED_NUMBER,
       // required for model version 006 and greater only when using a seed number
       "addWatermark": false
     }
   }
   

3. Segui le istruzioni per la generazione di immagini con testo per eseguire la richiesta REST.

Console

1. Segui le istruzioni per la generazione di immagini con testo per aprire Vertex AI Studio e inserire il prompt di testo.

2. Nella sezione Stile del riquadro Parametri, scegli uno stile dal menu.

3. Fai clic su play_arrowGenera.

REST

Per ulteriori informazioni sulle richieste del modello imagegeneration, consulta la documentazione di riferimento dell'API del modello imagegeneration.

Lo stile predefinito è un campo facoltativo nell'oggetto parameters del corpo della richiesta JSON.

1. Segui le istruzioni per la generazione di immagini con testo per sostituire altre variabili del corpo della richiesta.

2. Sostituisci quanto segue:

   • IMAGE_STYLE: uno degli stili predefiniti disponibili:
     • photograph
     • digital_art
     • landscape
     • sketch
     • watercolor
     • cyberpunk
     • pop_art

   {
     "instances": [
       ...
     ],
     "parameters": {
       "sampleCount": IMAGE_COUNT,
       "sampleImageStyle": "IMAGE_STYLE"
     }
   }
   

3. Segui le istruzioni per la generazione di immagini con testo per eseguire la richiesta REST.

Console

1. Segui le istruzioni per la generazione di immagini con testo per generare le immagini.

2. Seleziona l'immagine da ridimensionare.

3. Fai clic su downloadEsporta.

4. Seleziona Aumenta la risoluzione delle immagini.

5. Scegli un valore dal campo Fattore di scala.

6. Fai clic su downloadEsporta per salvare l'immagine upscalata.

REST

Per ulteriori informazioni sulle richieste del modello imagegeneration, consulta la documentazione di riferimento dell'API del modello imagegeneration.

La modalità di upscaling è un campo facoltativo nell'oggetto parameters di un corpo della richiesta JSON. Quando esegui l'upscaling di un'immagine utilizzando l'API, specifica "mode": "upscale" e upscaleConfig.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

• LOCATION: la regione del progetto. Ad esempio, us-central1, europe-west2 o asia-northeast3. Per un elenco delle regioni disponibili, consulta Località dell'IA generativa su Vertex AI.
• PROJECT_ID: il tuo ID progetto Google Cloud.
• B64_BASE_IMAGE: l'immagine di base da modificare o aumentare di risoluzione. L'immagine deve essere specificata come stringa di byte codificata in base64. Dimensioni massime: 10 MB.
• IMAGE_SOURCE: la posizione in Cloud Storage dell'immagine che vuoi modificare o ridimensionare. Ad esempio: gs://output-bucket/source-photos/photo.png.
• UPSCALE_FACTOR: facoltativo. Il fattore a cui verrà aumentata la risoluzione dell'immagine. Se non viene specificato, il fattore di aumento verrà determinato dal lato più lungo dell'immagine di input e da sampleImageSize. Valori disponibili: x2 o x4 .

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/imagegeneration@002:predict

Corpo JSON della richiesta:

{
  "instances": [
    {
      "prompt": "",
      "image": {
        // use one of the following to specify the image to upscale
        "bytesBase64Encoded": "B64_BASE_IMAGE"
        "gcsUri": "IMAGE_SOURCE"
        // end of base image input options
      },
    }
  ],
  "parameters": {
    "sampleCount": 1,
    "mode": "upscale",
    "upscaleConfig": {
      "upscaleFactor": "UPSCALE_FACTOR"
    }
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/imagegeneration@002:predict"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/imagegeneration@002:predict" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "predictions": [
    {
      "mimeType": "image/png",
      "bytesBase64Encoded": "iVBOR..[base64-encoded-upscaled-image]...YII="
    }
  ]
}