Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Rilevamento di immagini inappropriate
È possibile utilizzare l'[DetectModerationLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectModerationLabels.html)operazione per determinare se un'immagine contiene contenuti inappropriati o offensivi. Per un elenco delle etichette di moderazione in Amazon Rekognition[, consulta](https://docs.aws.amazon.com/rekognition/latest/dg/moderation.html#moderation-api) Utilizzo della moderazione di immagini e video. APIs
## Rilevamento di contenuti inappropriati in un'immagine
L'immagine deve essere un file in formato .png o .jpg. Puoi fornire un'immagine di input come matrice di byte dell'immagine (byte dell'immagine codificata in formato Base64) o specificare un oggetto di Amazon S3. Nelle procedure descritte viene caricata un'immagine (.jpg o .png) nel bucket S3.
Per eseguire queste procedure, devi avere installato l'SDK AWS CLI o l'SDK appropriato. AWS Per ulteriori informazioni, consulta [Nozioni di base su Amazon Rekognition](getting-started.md). L'account AWS utilizzato deve disporre di autorizzazioni di accesso all'API Amazon Rekognition. Per ulteriori informazioni, consulta la sezione [Operazioni definite da Amazon Rekognition](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonrekognition.html#amazonrekognition-actions-as-permissions).
**Per rilevare le etichette di moderazione in un'immagine (SDK)**
1. Se non lo hai già fatto:
1. Crea o aggiorna un utente con le autorizzazioni `AmazonRekognitionFullAccess` e `AmazonS3ReadOnlyAccess`. Per ulteriori informazioni, consulta [Fase 1: impostazione di un account AWS e creazione di un utente](setting-up.md#setting-up-iam).
1. Installa e configura il AWS CLI e il AWS SDKs. Per ulteriori informazioni, consulta [Passaggio 2: configura AWS CLI e AWS SDKs](setup-awscli-sdk.md).
1. Carica un'immagine nel bucket S3.
Per le istruzioni, consulta [Caricamento di oggetti in Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UploadingObjectsintoAmazonS3.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
1. Utilizzare i seguenti esempi per richiamare l'operazione `DetectModerationLabels`.
------
#### [ Java ]
In questo esempio vengono forniti i nomi di etichetta di contenuti inappropriati, i livelli di affidabilità e l'etichetta padre per le etichette di moderazione rilevate.
Sostituisci i valori di `amzn-s3-demo-bucket` e `photo` con il nome del bucket S3 e il nome del file di immagine utilizzato nella fase 2.
```
//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)
package aws.example.rekognition.image;
import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
import com.amazonaws.services.rekognition.model.DetectModerationLabelsRequest;
import com.amazonaws.services.rekognition.model.DetectModerationLabelsResult;
import com.amazonaws.services.rekognition.model.Image;
import com.amazonaws.services.rekognition.model.ModerationLabel;
import com.amazonaws.services.rekognition.model.S3Object;
import java.util.List;
public class DetectModerationLabels
{
public static void main(String[] args) throws Exception
{
String photo = "input.jpg";
String bucket = "bucket";
AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
DetectModerationLabelsRequest request = new DetectModerationLabelsRequest()
.withImage(new Image().withS3Object(new S3Object().withName(photo).withBucket(bucket)))
.withMinConfidence(60F);
try
{
DetectModerationLabelsResult result = rekognitionClient.detectModerationLabels(request);
List labels = result.getModerationLabels();
System.out.println("Detected labels for " + photo);
for (ModerationLabel label : labels)
{
System.out.println("Label: " + label.getName()
+ "\n Confidence: " + label.getConfidence().toString() + "%"
+ "\n Parent:" + label.getParentName());
}
}
catch (AmazonRekognitionException e)
{
e.printStackTrace();
}
}
}
```
------
#### [ Java V2 ]
Questo codice è tratto dal GitHub repository degli esempi di AWS Documentation SDK. Guarda l'esempio completo [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/DetectModerationLabels.java).
```
//snippet-start:[rekognition.java2.recognize_video_text.import]
//snippet-start:[rekognition.java2.detect_mod_labels.import]
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.Image;
import software.amazon.awssdk.services.rekognition.model.DetectModerationLabelsRequest;
import software.amazon.awssdk.services.rekognition.model.DetectModerationLabelsResponse;
import software.amazon.awssdk.services.rekognition.model.ModerationLabel;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.List;
//snippet-end:[rekognition.java2.detect_mod_labels.import]
/**
* Before running this Java V2 code example, set up your development environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class ModerateLabels {
public static void main(String[] args) {
final String usage = "\n" +
"Usage: " +
" \n\n" +
"Where:\n" +
" sourceImage - The path to the image (for example, C:\\AWS\\pic1.png). \n\n";
if (args.length < 1) {
System.out.println(usage);
System.exit(1);
}
String sourceImage = args[0];
Region region = Region.US_WEST_2;
RekognitionClient rekClient = RekognitionClient.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
.build();
detectModLabels(rekClient, sourceImage);
rekClient.close();
}
// snippet-start:[rekognition.java2.detect_mod_labels.main]
public static void detectModLabels(RekognitionClient rekClient, String sourceImage) {
try {
InputStream sourceStream = new FileInputStream(sourceImage);
SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream);
Image souImage = Image.builder()
.bytes(sourceBytes)
.build();
DetectModerationLabelsRequest moderationLabelsRequest = DetectModerationLabelsRequest.builder()
.image(souImage)
.minConfidence(60F)
.build();
DetectModerationLabelsResponse moderationLabelsResponse = rekClient.detectModerationLabels(moderationLabelsRequest);
List labels = moderationLabelsResponse.moderationLabels();
System.out.println("Detected labels for image");
for (ModerationLabel label : labels) {
System.out.println("Label: " + label.name()
+ "\n Confidence: " + label.confidence().toString() + "%"
+ "\n Parent:" + label.parentName());
}
} catch (RekognitionException | FileNotFoundException e) {
e.printStackTrace();
System.exit(1);
}
}
// snippet-end:[rekognition.java2.detect_mod_labels.main]
```
------
#### [ AWS CLI ]
Questo AWS CLI comando visualizza l'output JSON per l'operazione `detect-moderation-labels` CLI.
Sostituisci `amzn-s3-demo-bucket` e `input.jpg` con il nome del bucket S3 e il nome del file di immagine utilizzato nella fase 2. Sostituisci il valore di `profile_name` con il nome del tuo profilo di sviluppatore. Per utilizzare un adattatore, fornite l'ARN della versione del progetto al parametro `project-version`.
```
aws rekognition detect-moderation-labels --image "{S3Object:{Bucket:,Name:}}" \
--profile profile-name \
--project-version "ARN"
```
Se accedi alla CLI da un dispositivo Windows, usa le virgolette doppie anziché le virgolette singole ed evita le virgolette doppie interne tramite barra rovesciata (ovvero, \$1) per risolvere eventuali errori del parser che potresti riscontrare. Per un esempio, consulta quanto segue:
```
aws rekognition detect-moderation-labels --image "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"image-name\"}}" \
--profile profile-name
```
------
#### [ Python ]
In questo esempio vengono forniti i nomi di etichetta di contenuti inappropriati o offensivi, i livelli di affidabilità e l'etichetta padre per le etichette di contenuto inappropriato rilevate.
Nella funzione `main`, sostituisci i valori di `amzn-s3-demo-bucket` e `photo` con i nomi del bucket S3 e dell'immagine utilizzati nella fase 2. Sostituisci il valore di `profile_name` nella riga che crea la sessione di Rekognition con il nome del tuo profilo di sviluppatore.
```
#Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)
import boto3
def moderate_image(photo, bucket):
session = boto3.Session(profile_name='profile-name')
client = session.client('rekognition')
response = client.detect_moderation_labels(Image={'S3Object':{'Bucket':bucket,'Name':photo}})
print('Detected labels for ' + photo)
for label in response['ModerationLabels']:
print (label['Name'] + ' : ' + str(label['Confidence']))
print (label['ParentName'])
return len(response['ModerationLabels'])
def main():
photo='image-name'
bucket='amzn-s3-demo-bucket'
label_count=moderate_image(photo, bucket)
print("Labels detected: " + str(label_count))
if __name__ == "__main__":
main()
```
------
#### [ .NET ]
In questo esempio vengono forniti i nomi di etichetta di contenuti inappropriati o offensivi, i livelli di affidabilità e l'etichetta padre per le etichette di moderazione rilevate.
Sostituisci i valori di `amzn-s3-demo-bucket` e `photo` con il nome del bucket S3 e il nome del file di immagine utilizzato nella fase 2.
```
//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)
using System;
using Amazon.Rekognition;
using Amazon.Rekognition.Model;
public class DetectModerationLabels
{
public static void Example()
{
String photo = "input.jpg";
String bucket = "amzn-s3-demo-bucket";
AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();
DetectModerationLabelsRequest detectModerationLabelsRequest = new DetectModerationLabelsRequest()
{
Image = new Image()
{
S3Object = new S3Object()
{
Name = photo,
Bucket = bucket
},
},
MinConfidence = 60F
};
try
{
DetectModerationLabelsResponse detectModerationLabelsResponse = rekognitionClient.DetectModerationLabels(detectModerationLabelsRequest);
Console.WriteLine("Detected labels for " + photo);
foreach (ModerationLabel label in detectModerationLabelsResponse.ModerationLabels)
Console.WriteLine("Label: {0}\n Confidence: {1}\n Parent: {2}",
label.Name, label.Confidence, label.ParentName);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
```
------
## DetectModerationLabels richiesta di operazione
L'input per `DetectModerationLabels` è un'immagine. In questo input JSON di esempio, l'immagine di origine viene caricata da un bucket Amazon S3. `MinConfidence` è l'affidabilità minima che Immagini Amazon Rekognition deve avere nella precisione dell'etichetta rilevata per ottenerne la restituzione nella risposta.
```
{
"Image": {
"S3Object": {
"Bucket": "amzn-s3-demo-bucket",
"Name": "input.jpg"
}
},
"MinConfidence": 60
}
```
## DetectModerationLabels risposta operativa
`DetectModerationLabels` è in grado di recuperare le immagini di input da un bucket S3; in alternativa, è possibile fornirle come byte di immagine. Di seguito è riportato un esempio di risposta generata dalla chiamata all'operazione `DetectModerationLabels`.
Nel seguente esempio di risposta JSON, notare quanto segue:
+ **Informazioni sul rilevamento di immagini inappropriate**: l'esempio mostra un elenco di etichette per i contenuti inappropriati o offensivi presenti nell'immagine. L'elenco include l'etichetta di primo livello e ogni etichetta di secondo livello rilevate nell'immagine.
**Etichetta** – Ogni etichetta presenta un nome, una stima del livello di affidabilità di Amazon Rekognition circa la precisione dell'etichetta e il nome della relativa etichetta padre. Il nome dell'elemento padre per un'etichetta di primo livello è `""`.
**Affidabilità etichetta** – Ogni etichetta presenta un valore di affidabilità compreso tra 0 e 100 che indica la percentuale di affidabilità di Amazon Rekognition circa la correttezza dell'etichetta. È necessario specificare il livello di affidabilità necessario affinché un'etichetta sia restituita nella risposta nella richiesta di operazione API.
```
{
"ModerationLabels": [
{
"Confidence": 99.44782257080078,
"Name": "Smoking",
"ParentName": "Drugs & Tobacco Paraphernalia & Use",
"TaxonomyLevel": 3
},
{
"Confidence": 99.44782257080078,
"Name": "Drugs & Tobacco Paraphernalia & Use",
"ParentName": "Drugs & Tobacco",
"TaxonomyLevel": 2
},
{
"Confidence": 99.44782257080078,
"Name": "Drugs & Tobacco",
"ParentName": "",
"TaxonomyLevel": 1
}
],
"ModerationModelVersion": "7.0",
"ContentTypes": [
{
"Confidence": 99.9999008178711,
"Name": "Illustrated"
}
]
}
```