使用 OpenAI 内容审核模型可以检测文本和图像中的有害内容。您可以通过内容审核端点对输入单独进行分类,也可以在请求生成回复时一并获取审核分数。您可以根据审核结果执行应用的内容策略,例如过滤内容、将请求转交复核,或对提交了被标记内容的账号采取干预措施。
omni-moderation-latest 模型接受文本和图像输入,不支持对音频进行分类。内容审核端点可免费使用,每个图像文件最大为 20 MB。
儿童安全: 严禁提交已确认的儿童性虐待材料(CSAM)。请勿向 omni-moderation-latest 发送疑似 CSAM。经批准的组织可以使用 OpenAI CSAM 图像分类器检查图像中是否可能含有 CSAM。有关如何预防、检测和报告 CSAM,请参阅我们的 CSAM 指南。
| 工作流 |
适用场景 |
| 审核生成的内容 |
您的应用使用 Responses API 或 Chat Completions API 生成文本,同时需要获取审核信号。 |
| 对输入单独进行分类 |
您的应用需要对文本或图像进行分类,无需生成模型回复。 |
| 解读审核结果 |
您的应用需要解读标记、类别、分数或分数适用的输入类型。 |
| 查看支持的类别 |
您的应用需要了解各有害内容类别适用于文本、图像还是两者。 |
如果您的应用需要同时获取生成的文本和审核分数,请在生成请求中传入顶层 moderation 对象。API 会返回模型输入和生成输出的审核分数,无需单独发送审核请求。
模型仍会正常生成内容。在向用户展示输出或执行后续操作之前,请先检查审核结果。
Responses API 和 Chat Completions API 均不支持在生成请求中使用 omni-moderation-csam-latest 进行审核。如需单独发送图像审核请求,请参阅 CSAM 分类器指南。
创建回复时,请设置 moderation.model:
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 OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-6.2-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" },
});
if (!response.moderation) {
throw new Error("The API did not return the requested moderation results.");
}
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.2-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.2-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.2-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.2-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)
Responses API 返回的输入 moderation_result 对象位于 response.moderation.input,输出 moderation_result 对象位于 response.moderation.output。
创建聊天补全时,请设置 moderation.model:
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
30import OpenAI from "openai";
const client = new OpenAI();
const completion = await client.chat.completions.create({
model: "gpt-6.2-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" },
});
if (!completion.moderation) {
throw new Error("The API did not return the requested moderation results.");
}
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.2-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.2-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.2-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.2-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 API 返回的输入和输出审核结果容器分别位于 completion.moderation.input 和 completion.moderation.output。如果请求只生成一个候选回复,请分别读取两个容器中位于 results[0] 的第一项结果。如果您请求多个候选回复,completion.moderation.output.results[i] 对应 completion.choices[i]。
随生成请求返回的审核结果与单独请求的审核结果使用相同的类别字段。先根据 flagged 作初步判断,再查看 categories 和 category_scores,以便记录日志、分派请求、保留审计记录或将内容加入人工复核队列。即使模型拒绝了请求或给出了其他考虑到安全性的回复,只要回复中讨论了有害内容,仍有可能被标记。请将审核分数作为执行应用策略时的判断依据,避免仅凭分数自动拦截内容。
如果您的应用需要处理审核失败的情况,请先检查审核结果类型,再读取分数。如果某个审核步骤未能完成,对应的输入或输出审核字段可能会包含错误信息,而非审核分数。
对于涉及工具调用的请求,审核范围包括出现在对话内容中的工具调用参数和工具输出。审核范围不包括工具名称、工具描述、工具模式或响应格式模式。
如果您以流式方式接收生成的回复,只有在完整输出生成后才会收到审核分数。逐步返回的增量输出不包含审核分数。
使用内容审核端点可对文本或图像输入进行分类,无需生成模型回复。以下选项卡展示了如何使用 OpenAI 客户端库和 omni-moderation-latest 模型:
审核文本输入
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..."
}'
审核图像和文本
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"
}
}
]
}'
以下示例展示了审核一帧战争电影画面后返回的完整结果。模型在图像中识别出暴力迹象,violence 类别的分数超过 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"]
}
}
]
}
JSON 响应中的字段说明输入包含哪些类别的内容,以及模型对每个类别的判断有多大把握。
| 输出字段 | 说明 |
|---|
flagged | 如果模型将内容判定为可能有害,则为 true,否则为 false。 |
categories | 包含一个字典,记录各类别的违规标记。如果模型将内容标记为某一类别的违规内容,该类别的值为 true,否则为 false。 |
category_scores | 包含一个字典,记录各类别的分数。每个分数表示模型认为输入包含该类别内容的置信度。取值范围为 0 到 1,分数越高,置信度越高。 |
category_applied_input_types | 列出各类别分数适用的输入类型。例如,如果 violence/graphic 类别同时适用于图像和文本输入,violence/graphic 属性的值为 ["image", "text"]。 |
我们计划持续升级内容审核端点的底层模型。因此,随着模型升级,您可能需要重新校准依赖 category_scores 的自定义策略。
下表列出了内容审核端点可检测的内容类别,以及每个类别支持的输入类型。
标为“仅文本”的类别不支持图像输入。如果您仅向 omni-moderation-latest 模型发送图像,不附带文本,模型会为这些不支持图像的类别返回 0 分。每个图像文件最大为 20 MB。
| 类别 | 说明 | 输入类型 |
|---|
harassment | 使用骚扰性言语针对任何对象,或煽动、鼓吹他人使用此类言语的内容。 | 仅文本 |
harassment/threatening | 针对任何对象的骚扰内容,其中还涉及对该对象施加暴力或造成严重伤害。 | 仅文本 |
hate | 基于种族、性别、族裔、宗教、国籍、性取向、残障状况或种姓表达、煽动或宣扬仇恨的内容。针对非受保护群体(例如国际象棋棋手)的仇恨内容归入骚扰类别。 | 仅文本 |
hate/threatening | 基于种族、性别、族裔、宗教、国籍、性取向、残障状况或种姓针对特定群体的仇恨内容,其中还涉及对该群体施加暴力或造成严重伤害。 | 仅文本 |
illicit | 就如何实施违法行为提供建议或指导的内容。例如,“如何在商店行窃”就属于这一类别。 | 仅文本 |
illicit/violent | 属于 illicit 类别,同时还提及暴力或获取武器的内容。 | 仅文本 |
self-harm | 宣扬、鼓励或描绘自我伤害行为的内容,例如自杀、割伤自己或与进食障碍有关的行为。 | 文本和图像 |
self-harm/intent | 发言者表示自己正在或打算实施自我伤害行为的内容,例如自杀、割伤自己或与进食障碍有关的行为。 | 文本和图像 |
self-harm/instructions | 鼓励他人实施自我伤害行为,或就如何实施此类行为提供指导或建议的内容。此类行为包括自杀、割伤自己或与进食障碍有关的行为。 | 文本和图像 |
sexual | 旨在引起性兴奋的内容(例如对性行为的描述),或宣传性服务的内容。性教育和性健康内容除外。 | 文本和图像 |
sexual/minors | 涉及未满 18 周岁者的性内容。 | 仅文本 |
violence | 描绘死亡、暴力或身体伤害的内容。 | 文本和图像 |
violence/graphic | 露骨、细致地描绘死亡、暴力或身体伤害的内容。 | 文本和图像 |