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 classifier des entrées indépendantes 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 les résultats pour appliquer les règles de votre application, par exemple en filtrant le contenu, en transmettant une requête pour révision ou en intervenant auprès des comptes qui soumettent du contenu signalé.

Le modèle omni-moderation-latest accepte du texte et des images en entrée. Il ne classifie pas l’audio. L’utilisation du point de terminaison de modération est gratuite, et la taille des fichiers image peut atteindre 20 Mo.

Sécurité des enfants : N’envoyez aucun matériel pédopornographique (CSAM) avéré ou présumé à l’API de modération. Cette API n’est pas conçue pour détecter ou traiter ce type de contenu et ne remplace pas les mesures de protection spécifiques à la sécurité des enfants. Consultez nos recommandations concernant le matériel pédopornographique pour connaître les mesures de prévention, de détection, de réponse et de signalement à prendre concernant ce matériel.

Choisissez un workflow de modération

Workflow	À utiliser lorsque
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.
Classifiez des entrées indépendantes	Votre application doit classifier du texte ou des images sans générer de réponse du modèle.
Comprenez les résultats de modération	Votre application doit interpréter les signalements, les catégories, les scores ou les types d’entrée auxquels ils s’appliquent.
Consultez les catégories prises en charge	Votre application doit savoir quelles catégories de contenu préjudiciable s’appliquent au texte, aux images ou aux deux.

Modérez le contenu généré

Lorsque votre application a besoin à la fois de texte généré et de scores de modération, passez un objet moderation au premier niveau de la requête de génération. L’API renvoie des scores de modération pour l’entrée du modèle et la sortie générée, sans requête de modération distincte.

Le modèle continue de générer du contenu normalement. Examinez les résultats de modération avant de présenter la sortie à un utilisateur ou de déclencher des actions en aval.

Définissez 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.

Définissez moderation.model lors de la création d’une complétion de discussion :

Générez une complétion de discussion 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
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)

Chat Completions renvoie des conteneurs de résultats de modération dans completion.moderation.input et completion.moderation.output. Pour une requête qui génère un seul choix, lisez le premier résultat d’entrée et le premier résultat de sortie dans results[0]. Si vous demandez plusieurs choix, completion.moderation.output.results[i] correspond à completion.choices[i].

Les résultats de modération intégrés utilisent les mêmes champs de catégorie qu’un résultat de modération indépendant. Commencez par flagged pour prendre une première décision, puis examinez categories et category_scores pour la journalisation, le routage, les pistes d’audit ou les files de révision humaine. Un refus ou une autre réponse tenant compte de la sécurité peut tout de même déclencher un signalement si la réponse aborde du contenu préjudiciable. Considérez les scores de modération comme des signaux pour appliquer les règles de votre application, et non comme une décision de blocage automatique.

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

Pour les requêtes faisant 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 pas les noms, les descriptions ou les schémas des outils, ni les schémas de format de réponse.

Si vous diffusez une réponse générée en streaming, les scores de modération arrivent une fois la sortie générée entièrement disponible. Ils ne sont pas inclus dans les fragments de sortie partiels.

Classifiez des entrées indépendantes

Utilisez le point de terminaison de modération pour classifier du texte ou des images en entrée 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 :

Obtenez des informations de classification pour une entrée textuelle

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..."
  }'

Obtenez des informations de classification pour des images et du texte 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"
        }
      }
    ]
  }'

Comprenez les résultats de modération

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

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"]
      }
    }
  ]
}

La réponse JSON contient des champs qui indiquent les catégories présentes dans l’entrée et le degré de confiance du modèle pour chaque catégorie.

Catégorie de sortie	Description
`flagged`	Vaut `true` si le modèle classe le contenu comme potentiellement préjudiciable, `false` sinon.
`categories`	Contient un dictionnaire de signalements d’infraction par catégorie. Pour chaque catégorie, la valeur est `true` si le modèle signale une infraction dans la catégorie correspondante, et `false` sinon.
`category_scores`	Contient un dictionnaire de scores par catégorie. Chaque score représente le degré de confiance du modèle dans la présence de contenu relevant de cette catégorie dans l’entrée. La valeur est comprise entre 0 et 1 : plus elle est élevée, plus le degré de confiance est élevé.
`category_applied_input_types`	Contient les types d’entrée auxquels s’applique le score de la catégorie. Par exemple, si la catégorie `violence/graphic` s’applique à la fois aux images et au texte en entrée, la propriété `violence/graphic` est définie sur `["image", "text"]`.

Nous prévoyons d’améliorer en continu le modèle sous-jacent au point de terminaison de modération. Les règles personnalisées qui reposent sur category_scores pourraient donc nécessiter un recalibrage au fil du temps.

Consultez les catégories prises en charge

Le tableau ci-dessous décrit les catégories de contenu que le point de terminaison de modération peut détecter et les types d’entrée pris en charge par chaque catégorie.

Les catégories indiquées comme « Texte uniquement » ne prennent pas en charge les images en entrée. Si vous envoyez uniquement des images (sans texte d’accompagnement) au modèle omni-moderation-latest, il renverra un score de 0 pour ces catégories non prises en charge. La taille des fichiers image est limitée à 20 Mo.

Catégorie	Description	Entrées
`harassment`	Contenu qui exprime des propos relevant du harcèlement, incite à en tenir ou en fait la promotion, quelle que soit la cible.	Texte uniquement
`harassment/threatening`	Contenu relevant du harcèlement qui comporte également de la violence ou des atteintes graves, quelle que soit la cible.	Texte uniquement
`hate`	Contenu qui exprime de la haine, y incite ou en fait la promotion sur la base 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. Le contenu haineux visant des groupes non protégés (par exemple, les joueurs d’échecs) relève du harcèlement.	Texte uniquement
`hate/threatening`	Contenu haineux qui comporte également de la violence ou des atteintes graves envers le groupe ciblé sur la base 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.	Texte uniquement
`illicit`	Contenu qui donne des conseils ou des instructions pour commettre des actes illicites. Une expression comme « comment voler à l’étalage » entrerait dans cette catégorie.	Texte uniquement
`illicit/violent`	Les mêmes types de contenu que ceux signalés dans la catégorie `illicit`, mais avec également des références à la violence ou à l’acquisition d’une arme.	Texte uniquement
`self-harm`	Contenu qui fait la promotion de comportements autodestructeurs, les encourage ou les représente, notamment le suicide, les scarifications et les troubles alimentaires.	Texte et images
`self-harm/intent`	Contenu dans lequel la personne indique qu’elle adopte ou a l’intention d’adopter des comportements autodestructeurs, notamment le suicide, les scarifications et les troubles alimentaires.	Texte et images
`self-harm/instructions`	Contenu qui encourage des comportements autodestructeurs, notamment le suicide, les scarifications et les troubles alimentaires, ou qui fournit des instructions ou des conseils pour adopter de tels comportements.	Texte et images
`sexual`	Contenu destiné à susciter une excitation sexuelle, comme la description d’une activité sexuelle, ou qui fait la promotion de services sexuels (à l’exclusion de l’éducation sexuelle et du bien-être sexuel).	Texte et images
`sexual/minors`	Contenu sexuel impliquant une personne de moins de 18 ans.	Texte uniquement
`violence`	Contenu représentant la mort, la violence ou des blessures physiques.	Texte et images
`violence/graphic`	Contenu représentant la mort, la violence ou des blessures physiques avec des détails crus.	Texte et images

Suggestions

Bien démarrer

Concepts fondamentaux

SDK et CLI

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Conception de prompts

Raisonnement

Images et vidéo

Realtime et audio

Modèles spécialisés

API Agents

SDK Agents

ChatKit

Recherche et récupération

Connectez des outils et des données

Créez des flux de travail avec des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Développez avec la voix

Connexions

Traitement audio

Passez en production

Performances et qualité

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts fondamentaux

Plan

Build

Test and publish

Conversion specs

Guides

Ressources

Bien démarrer

Guides

File Upload

API

Measurement

Advertiser API

Référence de l’API

Bien démarrer

Fondamentaux

Explorer

Disponible sur

Versions

Flux de travail

Capacités

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendez les capacités de ChatGPT et de Codex

Linux

Windows

Flux de travail de développement

Étendre et automatiser

Environnements

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Bien démarrer

ChatGPT Work

Identité et authentification

Accès à l’espace de travail, stratégies et modèles

Contrôles des plugins et des connecteurs

Utilisation, gouvernance et conformité

Déploiement et fournisseurs de modèles

Communauté

Blog

Communauté

Blog