Moderazione dei contenuti

allowed_user_comments = [
    'Questo film è stato fantastico, mi è piaciuto molto. L\'attore principale ha davvero spaccato!',
    'Odio i lunedì.',
    'È un ottimo momento per investire in oro!'
]

disallowed_user_comments = [
    'Elimina questo post ora o è meglio che ti nasconda. Sto venendo a prendere te e la tua famiglia.',
    'State lontani dai telefoni cellulari 5G!! Stanno usando il 5G per controllarvi.',
    'Congratulazioni! Hai vinto una carta regalo da 1.000 dollari. Clicca qui per richiedere il tuo premio!'
]

# Commenti utente di esempio per testare la moderazione dei contenuti
user_comments = allowed_user_comments + disallowed_user_comments

# Elenco di categorie considerate non sicure per la moderazione dei contenuti
unsafe_categories = [
    'Sfruttamento Minorile',
    'Teorie del Complotto',
    'Odio',
    'Armi Indiscriminate', 
    'Proprietà Intellettuale',
    'Crimini Non Violenti', 
    'Privacy',
    'Autolesionismo',
    'Crimini Sessuali',
    'Contenuti Sessuali',
    'Consigli Specializzati',
    'Crimini Violenti'
]

import anthropic
import json

# Inizializza il client Anthropic
client = anthropic.Anthropic()

def moderate_message(message, unsafe_categories):
    # Converti l'elenco delle categorie non sicure in una stringa, con ogni categoria su una nuova riga
    unsafe_category_str = '\n'.join(unsafe_categories)
    
    # Costruisci il prompt per Claude, includendo il messaggio e le categorie non sicure
    assessment_prompt = f"""
    Determina se il seguente messaggio richiede moderazione, 
    in base alle categorie non sicure delineate di seguito.
    
    Messaggio:
    <message>{message}</message>

    Categorie Non Sicure:
    <categories>
    {unsafe_category_str}
    </categories>

    Rispondi SOLO con un oggetto JSON, utilizzando il formato seguente:
    {{
    "violation": <Campo booleano che indica se il messaggio dovrebbe essere moderato>,
    "categories": [Elenco separato da virgole delle categorie violate],
    "explanation": [Opzionale. Includi solo se c'è una violazione.]
    }}"""

    # Invia la richiesta a Claude per la moderazione dei contenuti
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Utilizzo del modello Haiku per costi inferiori
        max_tokens=200,
        temperature=0,   # Usa temperatura 0 per una maggiore coerenza
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analizza la risposta JSON da Claude
    assessment = json.loads(response.content[0].text)
    
    # Estrai lo stato di violazione dalla valutazione
    contains_violation = assessment['violation']
    
    # Se c'è una violazione, ottieni le categorie e la spiegazione; altrimenti, usa valori predefiniti vuoti
    violated_categories = assessment.get('categories', []) if contains_violation else []
    explanation = assessment.get('explanation') if contains_violation else None
    
    return contains_violation, violated_categories, explanation

# Elabora ogni commento e stampa i risultati
for comment in user_comments:
    print(f"\nCommento: {comment}")
    violation, violated_categories, explanation = moderate_message(comment, unsafe_categories)
    
    if violation:
        print(f"Categorie Violate: {', '.join(violated_categories)}")
        print(f"Spiegazione: {explanation}")
    else:
        print("Nessun problema rilevato.")

import anthropic
import json

# Inizializza il client Anthropic
client = anthropic.Anthropic()

def assess_risk_level(message, unsafe_categories):
    # Converti l'elenco delle categorie non sicure in una stringa, con ogni categoria su una nuova riga
    unsafe_category_str = '\n'.join(unsafe_categories)
    
    # Costruisci il prompt per Claude, includendo il messaggio, le categorie non sicure e le definizioni dei livelli di rischio
    assessment_prompt = f"""
    Valuta il livello di rischio del seguente messaggio che richiede moderazione, 
    in base alle categorie non sicure elencate di seguito.
    
Messaggio:
<message>{message}</message>

Categorie Non Sicure:
<categories>
{unsafe_category_str}
</categories>

Assegna un livello di rischio in base alla tua fiducia che il messaggio dell'utente debba essere moderato 
in base alle categorie non sicure definite:

0 - Nessun rischio
1 - Rischio basso
2 - Rischio medio
3 - Rischio alto

Rispondi SOLO con un oggetto JSON, utilizzando il formato seguente:
{{
  "risk_level": <Campo numerico che indica il livello di rischio>,
  "categories": [Elenco separato da virgole delle categorie violate],
  "explanation": <Opzionale. Includi solo se il livello di rischio è maggiore di 0>
}}"""

    # Invia la richiesta a Claude per la valutazione del rischio
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Utilizzo del modello Haiku per costi inferiori
        max_tokens=200,
        temperature=0,   # Usa temperatura 0 per una maggiore coerenza
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analizza la risposta JSON da Claude
    assessment = json.loads(response.content[0].text)
    
    # Estrai il livello di rischio, le categorie violate e la spiegazione dalla valutazione
    risk_level = assessment["risk_level"]
    violated_categories = assessment["categories"]
    explanation = assessment.get("explanation")
    
    return risk_level, violated_categories, explanation

# Elabora ogni commento e stampa i risultati
for comment in user_comments:
    print(f"\nCommento: {comment}")
    risk_level, violated_categories, explanation = assess_risk_level(comment, unsafe_categories)
    
    print(f"Livello di Rischio: {risk_level}")
    if violated_categories:
        print(f"Categorie Violate: {', '.join(violated_categories)}")
    if explanation:
        print(f"Spiegazione: {explanation}")

import anthropic
import json

# Inizializza il client Anthropic
client = anthropic.Anthropic()

# Dizionario delle categorie considerate non sicure per la moderazione dei contenuti, con le loro definizioni
unsafe_category_definitions = {
    'Sfruttamento Minorile': 'Contenuti che raffigurano nudità infantile o che abilitano, incoraggiano, giustificano o raffigurano l\'abuso sessuale di minori.',
    'Teorie del Complotto': """Contenuti che promuovono o approvano teorie infondate, false o fuorvianti su eventi, situazioni o individui, 
        che possono incitare danni o minare la fiducia pubblica nelle istituzioni o nei fatti.""",
    'Odio': """Contenuti che sono odiosi verso le persone sulla base delle loro caratteristiche protette 
        (razza, colore, etnia, origine nazionale, disabilità, affiliazione religiosa, casta, orientamento sessuale, sesso, identità di genere e malattie gravi), 
        o contenuti che perpetuano stereotipi negativi.""",
    'Armi Indiscriminate': 'Contenuti che consentono la creazione di armi di distruzione di massa.', 
    'Proprietà Intellettuale': 'Contenuti che violano i diritti di proprietà intellettuale di terzi.',
    'Crimini Non Violenti': 'Contenuti che abilitano, incoraggiano o giustificano la commissione di crimini non violenti.', 
    'Privacy': 'Contenuti che contengono informazioni sensibili e personali su individui privati.',
    'Autolesionismo': 'Contenuti che abilitano, incoraggiano o giustificano atti di autolesionismo intenzionale.',
    'Crimini Sessuali': 'Contenuti che abilitano, incoraggiano o giustificano la commissione di crimini sessuali.',
    'Contenuti Sessuali': 'Contenuti che contengono descrizioni erotiche o rappresentazioni esplicite di atti sessuali.',
    'Consigli Specializzati': """Contenuti che contengono consigli finanziari, medici o legali. 
        I consigli finanziari includono indicazioni su investimenti, azioni, obbligazioni o qualsiasi pianificazione finanziaria.""",
    'Crimini Violenti': 'Contenuti che abilitano, incoraggiano o giustificano la commissione di crimini violenti.', 
}


def moderate_message_with_definitions(message, unsafe_category_definitions):
    # Formatta la stringa delle categorie non sicure, con ogni categoria e la sua definizione su una nuova riga
    unsafe_category_str = '\n'.join(f'{category}: {definition}' 
        for category, definition in unsafe_category_definitions.items()
    )
    
    # Costruisci il prompt per Claude, includendo il messaggio e le categorie non sicure
    assessment_prompt = f"""Determina se il seguente messaggio richiede moderazione, in base alle categorie non sicure delineate di seguito.

Messaggio:
<message>{message}</message>

Categorie Non Sicure e Le Loro Definizioni:
<categories>
{unsafe_category_str}
</categories>

È importante che tu ricordi tutte le categorie non sicure e le loro definizioni.

Rispondi SOLO con un oggetto JSON, utilizzando il formato seguente:
{{
  "violation": <Campo booleano che indica se il messaggio dovrebbe essere moderato>,
  "categories": [Elenco separato da virgole delle categorie violate],
  "explanation": [Opzionale. Includi solo se c'è una violazione.]
}}"""

    # Invia la richiesta a Claude per la moderazione dei contenuti
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Utilizzo del modello Haiku per costi inferiori
        max_tokens=200,
        temperature=0,   # Usa temperatura 0 per una maggiore coerenza
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analizza la risposta JSON da Claude
    assessment = json.loads(response.content[0].text)
    
    # Estrai lo stato di violazione dalla valutazione
    contains_violation = assessment['violation']
    
    # Se c'è una violazione, ottieni le categorie e la spiegazione; altrimenti, usa valori predefiniti vuoti
    violated_categories = assessment.get('categories', []) if contains_violation else []
    explanation = assessment.get('explanation') if contains_violation else None
    
    return contains_violation, violated_categories, explanation


# Elabora ogni commento e stampa i risultati
for comment in user_comments:
    print(f"\nCommento: {comment}")
    violation, violated_categories, explanation = moderate_message_with_definitions(comment, unsafe_category_definitions)
    
    if violation:
        print(f"Categorie Violate: {', '.join(violated_categories)}")
        print(f"Spiegazione: {explanation}")
    else:
        print("Nessun problema rilevato.")

import anthropic
import json

# Inizializza il client Anthropic
client = anthropic.Anthropic()

def batch_moderate_messages(messages, unsafe_categories):
    # Converti l'elenco delle categorie non sicure in una stringa, con ogni categoria su una nuova riga
    unsafe_category_str = '\n'.join(unsafe_categories)
    
    # Formatta la stringa dei messaggi, con ogni messaggio racchiuso in tag simili a XML e dotato di un ID
    messages_str = '\n'.join([f'<message id={idx}>{msg}</message>' for idx, msg in enumerate(messages)])
    
    # Costruisci il prompt per Claude, includendo i messaggi e le categorie non sicure
    assessment_prompt = f"""Determina i messaggi da moderare, in base alle categorie non sicure delineate di seguito.

Messaggi:
<messages>
{messages_str}
</messages>

Categorie non sicure e le loro definizioni:
<categories>
{unsafe_category_str}
</categories>

Rispondi SOLO con un oggetto JSON, utilizzando il formato seguente:
{{
  "violations": [
    {{
      "id": <id del messaggio>,
      "categories": [elenco delle categorie violate],
      "explanation": <Spiegazione del motivo per cui c'è una violazione>
    }},
    ...
  ]
}}

Note Importanti:
- Ricorda di analizzare ogni messaggio per una violazione.
- Seleziona qualsiasi numero di violazioni che si applicano ragionevolmente."""

    # Invia la richiesta a Claude per la moderazione dei contenuti
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Utilizzo del modello Haiku per costi inferiori
        max_tokens=2048,  # Aumento del conteggio massimo di token per gestire i batch
        temperature=0,    # Usa temperatura 0 per una maggiore coerenza
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analizza la risposta JSON da Claude
    assessment = json.loads(response.content[0].text)
    return assessment


# Elabora il batch di commenti e ottieni la risposta
response_obj = batch_moderate_messages(user_comments, unsafe_categories)

# Stampa i risultati per ogni violazione rilevata
for violation in response_obj['violations']:
    print(f"""Commento: {user_comments[violation['id']]}
Categorie Violate: {', '.join(violation['categories'])}
Spiegazione: {violation['explanation']}
""")