Modération | OpenAI API

Utilisez les modèles de modération d’OpenAI pour détecter les contenus préjudiciables dans les textes et les images. Vous pouvez classer des entrées indépendamment de toute génération avec le point de terminaison de modération ou demander des scores de modération en même temps qu’une réponse générée. Utilisez ces résultats pour appliquer les règles de votre application, par exemple pour filtrer du contenu, transmettre une requête pour examen ou prendre des mesures à l’égard des comptes qui soumettent des contenus signalés.

Le modèle omni-moderation-latest accepte du texte et des images en entrée. Il ne classe pas les contenus audio. L’utilisation du point de terminaison de modération est gratuite. La taille maximale d’un fichier image est de 20 Mo.

Protection des enfants : N’envoyez à l’API de modération aucun contenu dont vous savez ou soupçonnez qu’il s’agit de matériel pédopornographique. L’API n’est pas conçue pour détecter ou traiter ce type de matériel et ne remplace pas les dispositifs spécifiquement destinés à protéger les enfants. Consultez nos recommandations sur le matériel pédopornographique pour connaître les mesures de prévention, savoir détecter ce matériel, réagir en sa présence et le signaler.

Choisissez un workflow de modération

Workflow	Quand l’utiliser
Modérez le contenu généré	Votre application génère du texte avec l’API Responses ou l’API Chat Completions et a besoin de signaux de modération.
Classez des entrées indépendamment de la génération	Votre application doit classer du texte ou des images sans générer de réponse du modèle.
Interprétez les résultats de modération	Votre application doit interpréter les signalements, les catégories, les scores ou les types d’entrées auxquels ces scores s’appliquent.
Consultez les catégories prises en charge	Votre application doit déterminer quelles catégories de contenus préjudiciables s’appliquent au texte, aux images ou aux deux.

Modérez le contenu généré

Si votre application a besoin à la fois du texte généré et des scores de modération, incluez un objet moderation à la racine de la requête de génération. L’API renvoie les scores de modération de l’entrée du modèle et de la sortie générée sans nécessiter de requête de modération distincte.

Le modèle génère sa réponse comme d’habitude. Examinez les résultats de modération avant de présenter la sortie à un utilisateur ou de lancer d’autres actions à partir de cette sortie.

Renseignez moderation.model lors de la création d’une réponse :

Générez une réponse avec des scores de modération

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content:
        "A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative.",
    },
  ],
  moderation: { model: "omni-moderation-latest" },
});

const inputModeration = response.moderation.input;
const outputModeration = response.moderation.output;
if (inputModeration.type === "error") {
  throw new Error(inputModeration.message);
}
if (outputModeration.type === "error") {
  throw new Error(outputModeration.message);
}

console.log(inputModeration.flagged);
console.log(outputModeration.flagged);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": (
                "A user asks for instructions to make a harmful weapon. "
                "Draft a brief refusal and offer a safer alternative."
            ),
        }
    ],
    moderation={"model": "omni-moderation-latest"},
)

input_moderation = response.moderation.input
output_moderation = response.moderation.output
if input_moderation.type == "error":
    raise RuntimeError(input_moderation.message)
if output_moderation.type == "error":
    raise RuntimeError(output_moderation.message)

print(input_moderation.flagged)
print(output_moderation.flagged)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44package main

import (
	"context"
	"errors"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative."),
		},
		Moderation: responses.ResponseNewParamsModeration{
			Model: "omni-moderation-latest",
		},
	})
	if err != nil {
		panic(err)
	}

	switch inputModeration := response.Moderation.Input.AsAny().(type) {
	case responses.ResponseModerationInputModerationResult:
		fmt.Println(inputModeration.Flagged)
	case responses.ResponseModerationInputError:
		panic(errors.New(inputModeration.Message))
	default:
		panic("unexpected input moderation result")
	}
	switch outputModeration := response.Moderation.Output.AsAny().(type) {
	case responses.ResponseModerationOutputModerationResult:
		fmt.Println(outputModeration.Flagged)
	case responses.ResponseModerationOutputError:
		panic(errors.New(outputModeration.Message))
	default:
		panic("unexpected output moderation result")
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.JsonValue;
import com.openai.models.responses.ResponseCreateParams;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input(
            "A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative.")
        .putAdditionalBodyProperty(
            "moderation", JsonValue.from(Map.of("model", "omni-moderation-latest")))
        .build();

var response = client.responses().create(params);
var moderation =
    response
        .moderation()
        .orElseThrow(
            () -> new IllegalStateException("The response did not include moderation results"));
List<Boolean> flags = new ArrayList<>();

var input = moderation.input();
if (input.isError()) {
  throw new IllegalStateException(input.asError().message());
}
if (!input.isModerationResult()) {
  throw new IllegalStateException("Missing input moderation flag");
}
flags.add(input.asModerationResult().flagged());

var output = moderation.output();
if (output.isError()) {
  throw new IllegalStateException(output.asError().message());
}
if (!output.isModerationResult()) {
  throw new IllegalStateException("Missing output moderation flag");
}
flags.add(output.asModerationResult().flagged());

flags.forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11require "openai"

client = OpenAI::Client.new

response = client.responses.create(
  model: "gpt-6-astra",
  input: "A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative.",
  moderation: { model: "omni-moderation-latest" }
)

puts(response.moderation)

L’API Responses renvoie un objet moderation_result pour l’entrée dans response.moderation.input et un objet moderation_result pour la sortie dans response.moderation.output.

Renseignez moderation.model lors de la création d’une réponse avec l’API Chat Completions :

Générez une réponse avec des scores de modération via l’API Chat Completions

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26import OpenAI from "openai";

const client = new OpenAI();

const completion = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages: [
    {
      role: "user",
      content:
        "A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative.",
    },
  ],
  moderation: { model: "omni-moderation-latest" },
});

const inputResult = completion.moderation.input;
const outputResult = completion.moderation.output;
if (inputResult.type === "error") throw new Error(inputResult.message);
if (outputResult.type === "error") throw new Error(outputResult.message);

const inputModeration = inputResult.results[0];
const outputModeration = outputResult.results[0];

console.log(inputModeration.flagged);
console.log(outputModeration.flagged);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30from openai import OpenAI

client = OpenAI()

completion = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[
        {
            "role": "user",
            "content": (
                "A user asks for instructions to make a harmful weapon. "
                "Draft a brief refusal and offer a safer alternative."
            ),
        }
    ],
    moderation={"model": "omni-moderation-latest"},
)

input_result = completion.moderation.input
output_result = completion.moderation.output
if input_result.type == "error":
    raise RuntimeError(input_result.message)
if output_result.type == "error":
    raise RuntimeError(output_result.message)

input_moderation = input_result.results[0]
output_moderation = output_result.results[0]

print(input_moderation.flagged)
print(output_moderation.flagged)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49package main

import (
	"context"
	"errors"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()

	completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model: "gpt-6-astra",
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage("A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative."),
		},
		Moderation: openai.ChatCompletionNewParamsModeration{
			Model: "omni-moderation-latest",
		},
	})
	if err != nil {
		panic(err)
	}

	switch inputResult := completion.Moderation.Input.AsAny().(type) {
	case openai.ChatCompletionModerationInputModerationResults:
		if len(inputResult.Results) == 0 {
			panic("missing input moderation result")
		}
		fmt.Println(inputResult.Results[0].Flagged)
	case openai.ChatCompletionModerationInputError:
		panic(errors.New(inputResult.Message))
	default:
		panic("unexpected input moderation result")
	}
	switch outputResult := completion.Moderation.Output.AsAny().(type) {
	case openai.ChatCompletionModerationOutputModerationResults:
		if len(outputResult.Results) == 0 {
			panic("missing output moderation result")
		}
		fmt.Println(outputResult.Results[0].Flagged)
	case openai.ChatCompletionModerationOutputError:
		panic(errors.New(outputResult.Message))
	default:
		panic("unexpected output moderation result")
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.JsonValue;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-6-astra")
        .addUserMessage(
            "A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative.")
        .putAdditionalBodyProperty(
            "moderation", JsonValue.from(Map.of("model", "omni-moderation-latest")))
        .build();

var completion = client.chat().completions().create(params);
var moderation =
    completion
        .moderation()
        .orElseThrow(
            () ->
                new IllegalStateException("The completion did not include moderation results"));
List<Boolean> flags = new ArrayList<>();

var input = moderation.input();
if (input.isError()) {
  throw new IllegalStateException(input.asError().message());
}
if (!input.isModerationResults() || input.asModerationResults().results().isEmpty()) {
  throw new IllegalStateException("Missing input moderation flag");
}
flags.add(input.asModerationResults().results().get(0).flagged());

var output = moderation.output();
if (output.isError()) {
  throw new IllegalStateException(output.asError().message());
}
if (!output.isModerationResults() || output.asModerationResults().results().isEmpty()) {
  throw new IllegalStateException("Missing output moderation flag");
}
flags.add(output.asModerationResults().results().get(0).flagged());

flags.forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16require "openai"

client = OpenAI::Client.new

completion = client.chat.completions.create(
  model: "gpt-6-astra",
  messages: [
    {
      role: :user,
      content: "A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative."
    }
  ],
  moderation: { model: "omni-moderation-latest" }
)

puts(completion.moderation)

L’API Chat Completions regroupe les résultats de modération dans completion.moderation.input et completion.moderation.output. Si la requête génère un seul choix, lisez le premier résultat de l’entrée et celui de la sortie dans le champ results[0] de chaque objet. Si vous demandez plusieurs choix, completion.moderation.output.results[i] correspond à completion.choices[i].

Les résultats de modération inclus dans la réponse utilisent les mêmes champs de catégorie que ceux d’une requête de modération distincte. Consultez d’abord flagged pour prendre une première décision, puis examinez categories et category_scores pour alimenter vos journaux, orienter les requêtes, conserver une piste d’audit ou placer des contenus en file d’attente pour examen humain. Même un refus ou une autre réponse qui tient compte des règles de sécurité peut déclencher un signalement si cette réponse évoque un contenu préjudiciable. Utilisez les scores de modération comme des indicateurs pour appliquer les règles de votre application. Un score ne doit pas entraîner à lui seul un blocage automatique.

Si votre application doit gérer les échecs de modération, vérifiez le type de résultat avant de lire les scores. Si une étape de modération échoue, le champ de modération correspondant à l’entrée ou à la sortie peut contenir une erreur à la place des scores.

Pour les requêtes qui font appel à des outils, la modération couvre les arguments des appels d’outils et les sorties des outils lorsqu’ils figurent dans le contenu de la conversation. Elle ne couvre ni les noms, descriptions et schémas des outils, ni les schémas de format de réponse.

Si vous diffusez une réponse au fil de sa génération, vous recevez les scores de modération une fois la sortie complète disponible. Les fragments de sortie transmis pendant la génération ne contiennent pas ces scores.

Classez des entrées indépendamment de la génération

Utilisez le point de terminaison de modération pour classer du texte ou des images sans générer de réponse du modèle. Les onglets ci-dessous montrent comment utiliser les bibliothèques OpenAI et le modèle omni-moderation-latest :

Obtenir les résultats de classification d’un texte fourni en entrée

Python

1
2
3
4
5
6
7
8
9import OpenAI from "openai";
const openai = new OpenAI();

const moderation = await openai.moderations.create({
  model: "omni-moderation-latest",
  input: "...text to classify goes here...",
});

console.log(moderation);

1
2
3
4
5
6
7
8
9
10from openai import OpenAI

client = OpenAI()

response = client.moderations.create(
    model="omni-moderation-latest",
    input="...text to classify goes here...",
)

print(response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()

	moderation, err := client.Moderations.New(context.Background(), openai.ModerationNewParams{
		Model: openai.ModerationModelOmniModerationLatest,
		Input: openai.ModerationNewParamsInputUnion{
			OfString: openai.String("Text to classify goes here."),
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(moderation.Results[0].Flagged)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.moderations.ModerationCreateParams;

var moderation =
    client
        .moderations()
        .create(
            ModerationCreateParams.builder()
                .model("omni-moderation-latest")
                .input("Text to classify goes here.")
                .build());

System.out.println(moderation.results().get(0).flagged());

1
2
3
4
5
6
7
8
9
10
11
12
13
14using OpenAI.Moderations;

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "omni-moderation-latest";
ModerationClient client = new(model, key);

ModerationResult result = await client.ClassifyTextAsync(
    "Text to classify goes here."
);

Console.WriteLine($"Flagged: {result.Flagged}");
Console.WriteLine(
    $"Violence: {result.Violence.Flagged}; score: {result.Violence.Score:F3}"
);

1
2
3
4
5
6
7
8
9
10require "openai"

client = OpenAI::Client.new

moderation = client.moderations.create(
  model: OpenAI::Models::ModerationModel::OMNI_MODERATION_LATEST,
  input: "Text to classify goes here."
)

puts(moderation.results.fetch(0).flagged)

1
2
3
4
5
6
7
8curl https://api.openai.com/v1/moderations \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "omni-moderation-latest",
    "input": "...text to classify goes here..."
  }'

Obtenir les résultats de classification pour une image et du texte fournis en entrée

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import OpenAI from "openai";
const openai = new OpenAI();

const moderation = await openai.moderations.create({
  model: "omni-moderation-latest",
  input: [
    { type: "text", text: "...text to classify goes here..." },
    {
      type: "image_url",
      image_url: {
        url: "https://example.com/image.png",
        // You can also use a Base64 encoded image URL.
        // url: "data:image/jpeg;base64,abcdefg...",
      },
    },
  ],
});

console.log(moderation);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20from openai import OpenAI

client = OpenAI()

response = client.moderations.create(
    model="omni-moderation-latest",
    input=[
        {"type": "text", "text": "...text to classify goes here..."},
        {
            "type": "image_url",
            "image_url": {
                "url": "https://example.com/image.png",
                # You can also use a Base64 encoded image URL.
                # "url": "data:image/jpeg;base64,abcdefg..."
            },
        },
    ],
)

print(response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()

	moderation, err := client.Moderations.New(context.Background(), openai.ModerationNewParams{
		Model: openai.ModerationModelOmniModerationLatest,
		Input: openai.ModerationNewParamsInputUnion{
			OfModerationMultiModalArray: []openai.ModerationMultiModalInputUnionParam{
				openai.ModerationMultiModalInputParamOfText("Text to classify goes here."),
				openai.ModerationMultiModalInputParamOfImageURL(openai.ModerationImageURLInputImageURLParam{
					URL: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
				}),
			},
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(moderation.Results[0].Flagged)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.moderations.ModerationCreateParams;
import com.openai.models.moderations.ModerationImageUrlInput;
import com.openai.models.moderations.ModerationMultiModalInput;
import com.openai.models.moderations.ModerationTextInput;
import java.util.List;

var moderation =
    client
        .moderations()
        .create(
            ModerationCreateParams.builder()
                .model("omni-moderation-latest")
                .inputOfModerationMultiModalArray(
                    List.of(
                        ModerationMultiModalInput.ofText(
                            ModerationTextInput.builder()
                                .text("Text to classify goes here.")
                                .build()),
                        ModerationMultiModalInput.ofImageUrl(
                            ModerationImageUrlInput.builder()
                                .imageUrl(
                                    ModerationImageUrlInput.ImageUrl.builder()
                                        .url(
                                            "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg")
                                        .build())
                                .build())))
                .build());

System.out.println(moderation.results().get(0).flagged());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22using OpenAI.Moderations;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "omni-moderation-latest";
ModerationClient client = new(model, key);

ModerationResult result = await client.ClassifyInputsAsync(
    [
        ModerationInputPart.CreateTextPart("Text to classify goes here."),
        ModerationInputPart.CreateImagePart(
            new Uri(
                "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
            )
        ),
    ]
);

Console.WriteLine($"Flagged: {result.Flagged}");
Console.WriteLine(
    $"Violence: {result.Violence.Flagged}; score: {result.Violence.Score:F3}; inputs: {result.Violence.ApplicableInputKinds}"
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21require "openai"

client = OpenAI::Client.new

moderation = client.moderations.create(
  model: OpenAI::Models::ModerationModel::OMNI_MODERATION_LATEST,
  input: [
    {
      type: :text,
      text: "Text to classify goes here."
    },
    {
      type: :image_url,
      image_url: {
        url: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
      }
    }
  ]
)

puts(moderation.results.fetch(0).flagged)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16curl https://api.openai.com/v1/moderations \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "omni-moderation-latest",
    "input": [
      { "type": "text", "text": "...text to classify goes here..." },
      {
        "type": "image_url",
        "image_url": {
          "url": "https://example.com/image.png"
        }
      }
    ]
  }'

Interprétez les résultats de modération

Voici un exemple de sortie complète pour une image extraite d’un film de guerre. Le modèle détecte des signes de violence dans l’image et attribue à la catégorie violence un score supérieur à 0,8.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354{
  "id": "modr-970d409ef3bef3b70c73d8232df86e7d",
  "model": "omni-moderation-latest",
  "results": [
    {
      "flagged": true,
      "categories": {
        "sexual": false,
        "sexual/minors": false,
        "harassment": false,
        "harassment/threatening": false,
        "hate": false,
        "hate/threatening": false,
        "illicit": false,
        "illicit/violent": false,
        "self-harm": false,
        "self-harm/intent": false,
        "self-harm/instructions": false,
        "violence": true,
        "violence/graphic": false
      },
      "category_scores": {
        "sexual": 2.34135824776394e-7,
        "sexual/minors": 1.6346470245419304e-7,
        "harassment": 0.0011643905680426018,
        "harassment/threatening": 0.0022121340080906377,
        "hate": 3.1999824407395835e-7,
        "hate/threatening": 2.4923252458203563e-7,
        "illicit": 0.0005227032493135171,
        "illicit/violent": 3.682979260160596e-7,
        "self-harm": 0.0011175734280627694,
        "self-harm/intent": 0.0006264858507989037,
        "self-harm/instructions": 7.368592981140821e-8,
        "violence": 0.8599265510337075,
        "violence/graphic": 0.37701736389561064
      },
      "category_applied_input_types": {
        "sexual": ["image"],
        "sexual/minors": [],
        "harassment": [],
        "harassment/threatening": [],
        "hate": [],
        "hate/threatening": [],
        "illicit": [],
        "illicit/violent": [],
        "self-harm": ["image"],
        "self-harm/intent": ["image"],
        "self-harm/instructions": ["image"],
        "violence": ["image"],
        "violence/graphic": ["image"]
      }
    }
  ]
}

Les champs de la réponse JSON indiquent les catégories détectées dans l’entrée et le degré de confiance du modèle pour chacune d’elles.

Champ de sortie	Description
`flagged`	Vaut `true` si le modèle classe le contenu comme potentiellement préjudiciable, et `false` dans le cas contraire.
`categories`	Contient un dictionnaire de signalements par catégorie. Pour chaque catégorie, la valeur est `true` si le modèle signale une infraction dans cette catégorie, et `false` dans le cas contraire.
`category_scores`	Contient un dictionnaire de scores par catégorie. Chaque score indique le degré de confiance du modèle quant à la présence, dans l’entrée, de contenu relevant de la catégorie. Il varie de 0 à 1. Plus le score est élevé, plus la confiance du modèle est grande.
`category_applied_input_types`	Indique les types d’entrées auxquels s’applique le score de chaque catégorie. Par exemple, si la catégorie `violence/graphic` s’applique à la fois aux images et au texte, la propriété `violence/graphic` vaut `["image", "text"]`.

Nous prévoyons d’améliorer régulièrement le modèle utilisé par le point de terminaison de modération. Si vos règles de modération reposent sur category_scores, vous devrez peut-être les recalibrer au fil du temps.

Consultez les catégories prises en charge

Le tableau ci-dessous décrit les catégories de contenus que le point de terminaison de modération peut détecter et les types d’entrées pris en charge pour chacune d’elles.

Les catégories portant la mention « Texte uniquement » ne prennent pas en charge les images. Si vous envoyez uniquement des images, sans texte, au modèle omni-moderation-latest, il renvoie un score de 0 pour ces catégories. La taille maximale d’un fichier image est de 20 Mo.

Catégorie	Description	Entrées
`harassment`	Contenu qui tient des propos relevant du harcèlement, incite à en tenir ou les encourage, quelle que soit la cible.	Texte uniquement
`harassment/threatening`	Contenu relevant du harcèlement qui comporte aussi des violences ou des atteintes graves à l’encontre de la cible, quelle qu’elle soit.	Texte uniquement
`hate`	Contenu qui exprime, attise ou encourage la haine fondée sur la race, le genre, l’origine ethnique, la religion, la nationalité, l’orientation sexuelle, le handicap ou la caste. Les contenus haineux visant des groupes non protégés, comme les joueurs d’échecs, relèvent du harcèlement.	Texte uniquement
`hate/threatening`	Contenu haineux qui comporte aussi des violences ou des atteintes graves à l’encontre d’un groupe ciblé en raison de la race, du genre, de l’origine ethnique, de la religion, de la nationalité, de l’orientation sexuelle, du handicap ou de la caste de ses membres.	Texte uniquement
`illicit`	Contenu qui donne des conseils ou des instructions pour commettre des actes illicites. Une expression comme « comment voler à l’étalage » relève de cette catégorie.	Texte uniquement
`illicit/violent`	Mêmes types de contenus que ceux signalés dans la catégorie `illicit`, avec en plus des références à la violence ou à l’acquisition d’une arme.	Texte uniquement
`self-harm`	Contenu qui décrit, encourage ou valorise des comportements par lesquels une personne se fait du mal, comme le suicide, les scarifications ou les conduites liées aux troubles alimentaires.	Texte et images
`self-harm/intent`	Contenu dans lequel une personne indique qu’elle se fait du mal ou qu’elle en a l’intention, par exemple en évoquant le suicide, des scarifications ou des conduites liées aux troubles alimentaires.	Texte et images
`self-harm/instructions`	Contenu qui incite une personne à se faire du mal, par exemple par le suicide, les scarifications ou des conduites liées aux troubles alimentaires, ou qui donne des instructions ou des conseils sur la manière de le faire.	Texte et images
`sexual`	Contenu destiné à susciter l’excitation sexuelle, par exemple en décrivant une activité sexuelle, ou qui fait la promotion de services sexuels. L’éducation sexuelle et le bien-être sexuel sont exclus.	Texte et images
`sexual/minors`	Contenu sexuel impliquant une personne de moins de 18 ans.	Texte uniquement
`violence`	Contenu qui représente la mort, des violences ou des blessures physiques.	Texte et images
`violence/graphic`	Contenu qui représente de manière crue et détaillée la mort, des violences ou des blessures physiques.	Texte et images

Suggestions

Premiers pas

Notions fondamentales

SDK et CLI

Fournisseurs de services cloud

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Rédaction de prompts

Raisonnement

Images

Temps réel et audio

Modèles spécialisés

API Agents

Agents SDK

ChatKit

Recherche et récupération d’informations

Connectez des outils et des sources de données

Créez des workflows qui font appel à des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Créer des applications vocales

Connexions

Traitement audio

Mise en production

Performances et qualité

Évaluation

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts clés

Planification

Développement

Tests et publication

Spécifications de conversion

Guides

Ressources

Identité

Utilisation du forfait ChatGPT

Guides

Envoi de fichiers

API

Mesure des performances

API pour les annonceurs

Référence de l’API

Premiers pas

Premiers pas

Notions de base

Explorer

Disponible sur

Versions

Workflows

Capacités

Sites

dots

Espace ChatGPT

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendre les fonctionnalités de ChatGPT et de Codex

Linux

Windows

Workflows de développement

Extensions et automatisation

Environnements

Codex Cloud

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Premiers pas

Configuration des fonctionnalités

Identité et accès