Bună, Anastasia!

În primul rând, felicitări pentru alegerea temei – este cu adevărat una dintre cele mai „în vogă” și, în același timp, provocatoare din jurnalismul de astăzi. Îți voi prezenta câteva opţiuni care cred eu că s‑ar potrivi bine cu un studiu de caz practic și îţi voi lăsa și nişte surse de unde poţi porni.

1️⃣ Analiza narativă a rețelelor sociale – Narrative Network Analysis (NNA)

Ce e?
Este o metodă hibridă care combină analiza narativă clasică (identificarea personajelor, conflictelor, temelor) cu analiza rețelelor (legăturile dintre utilizatori, distribuirea mesajelor). Practic, construieşti un graf în care nodurile sunt „unităţi narative” (ex. subiecte, actori, evenimente) și le conectezi prin relaţiile de co‑apariție în postări/tweeturi.

De ce ar fi utilă?

• Poţi să urmăreşti cum evoluează un „naraţiune” în timp și cum se răspândeşte prin rețele diferite.
• Îţi permite să aduci în discuţie atât conţinutul (narativul) cât și structura de difuzare (rețeaua).

Tool‑uri practice:

• Gephi sau Cytoscape pentru vizualizarea graficelor.
• Python: networkx + pandas pentru pre‑procesare, spaCy pentru extragerea entităţilor și a relaţiilor.
• NVivo/Atlas.ti pentru codarea narativă (poţi importa datele din reţelele sociale).

Articole de referinţă:

• Bruns, A. & Burgess, J. (2022). Narrative Network Analysis of Twitter Discourse during the 2020 US Elections. Digital Journalism.
• R. L. Hargreaves (2023). From Stories to Graphs: A Methodological Guide to Narrative Network Analysis. Journalism Studies.

Ce e?
Este un set de standarde (schema ClaimReview) dezvoltat de Google pentru a structura metadatele verificărilor de fapt. În combinație cu un pipeline automat (scraping, NLP, cross‑checking), poţi să construieşti un studiu de caz în care analizezi cum sunt verificate (sau nu) anumite afirmaţii în media socială.

De ce ar fi utilă?

Tool‑uri practice:

• Google Fact‑Check Tools API (pentru a extrage date din platforme care adoptă schema ClaimReview).
• Python: requests + beautifulsoup4 pentru scraping, transformers (de ex. BERT‑based models) pentru detectarea afirmaţiilor.
• OpenRefine pentru curăţarea dataset‑urilor.

Articole de referinţă:

• Graves, L. (2021). Fact‑Checking in the Age of Social Media: A Comparative Study of ClaimReview Adoption. Journalism & Mass Communication Quarterly.
• M. Tandoc & J. Maitra (2023). The Effectiveness of Automated Fact‑Checking Pipelines. Computational Journalism.

Exemplu de studiu de caz:

• „Dezinformarea despre vaccinuri în România (2022‑2023)” – codifică mesajele (naraţiuni de „siguranță”, „libertate”, „conspirație”), construieşte grafurile de difuzare pe Facebook și Twitter, apoi verifică cu baza de date a Agenţiei Naţionale a Medicamentului dacă afirmaţiile au fost corectate și cum a afectat asta răspândirea.

1. Defineşte clar obiectivul – vrei să studiezi cum se formează o naraţiune, cum se răspândeşte, sau cum este corectată?
2. Alege un studiu de caz – un eveniment recent (ex. alegerile locale din 2024, protestele din ianuarie 2024, campania anti‑COVID) îţi va oferi date proaspete și relevanţă.
3. Stabileşte metoda principală – dacă ești mai confortabilă cu analiza de conţinut, începe cu NNA; dacă vrei să aduci un aport tehnic, mergi pe pipeline‑ul de fact‑checking.

• „Narrative Network Analysis: A Primer” – PDF disponibil pe ResearchGate (caută autorii Bruns & Burgess).
• „Fact‑Checking in the Digital Age” – capitol în The Routledge Handbook of Journalism and Media Studies (2022).
• Tutoriale Python** – căută pe YouTube „Twitter network analysis with NetworkX” și „ClaimReview API tutorial”.

Sper că aceste sugestii îţi vor fi de ajutor și că vei găsi combinaţia potrivită pentru lucrarea ta. Dacă vrei să discutăm mai în detaliu despre un anumit tool sau să-ţi arăt un mic exemplu de cod, spune-mi cu ce platformă vrei să începi și îţi trimit și un snippet rapid.

Mult succes și aștept cu nerăbdare să văd cum evoluează proiectul tău! 🚀

Cosmina

1️⃣ Analiza Narativă a Rețelelor (Narrative Network Analysis – NNA)

Exemplu rapid (Python)

import tweepy, pandas as pd, spacy, networkx as nx
from collections import Counter

# 1️⃣  Colectare tweet‑uri
client = tweepy.Client(bearer_token="YOUR_TOKEN")
tweets = client.search_recent_tweets(query="#elections2024", max_results=500).data
df = pd.DataFrame([t.text for t in tweets], columns=["text"])

# 2️⃣  NER cu spaCy
nlp = spacy.load("en_core_web_sm")
def extract_entities(txt):
    doc = nlp(txt)
    return [ent.text for ent in doc.ents if ent.label_ in {"PERSON","ORG","EVENT"}]

df["entities"] = df["text"].apply(extract_entities)

# 3️⃣  Construiește graful de co‑apariție
G = nx.Graph()
for ents in df["entities"]:
    for i, a in enumerate(ents):
        for b in ents[i+1:]:
            if G.has_edge(a,b):
                G[a][b]["weight"] += 1
            else:
                G.add_edge(a,b, weight=1)

# 4️⃣  Analiză simplă - top 10 noduri după grad
top_nodes = sorted(G.degree, key=lambda x: x[1], reverse=True)[:10]
print(top_nodes)

Acest script scurt îţi dă un punct de plecare: colectezi tweet‑uri, extragi entităţi, creezi un graf de co‑apariție și identifici actorii cei mai conectaţi.

2️⃣ Framework‑ul de verificare a faptelor – ClaimReview + Fact‑Checking Pipeline

Exemplu rapid (pipeline simplificat)

import requests, json, spacy, pandas as pd
from transformers import pipeline

# 1️⃣  Scrape un articol (exemplu simplu)
url = " https://example.com/news/article" 
html = requests.get(url).text
# (foloseşti BeautifulSoup pentru a extrage textul)
from bs4 import BeautifulSoup
text = BeautifulSoup(html, "html.parser").get_text(separator=" ")

# 2️⃣  Detectare claim‑uri cu un model BERT finetuned
claim_extractor = pipeline("text-classification",
                           model="microsoft/claimbuster-roberta-base",
                           return_all_scores=False)

sentences = [s.strip() for s in text.split('.') if s]
claims = [s for s in sentences if claim_extractor(s)[0]["label"] == "CLAIM"]

# 3️⃣  Verificare simplă în Wikidata (exemplu de query)
def wikidata_check(claim):
    query = f'''
    SELECT ?item ?itemLabel WHERE {{
      ?item ?p "{claim}"@en .
      SERVICE wikibase:label {{ bd:serviceParam wikibase:language "en". }}
    }} LIMIT 1
    '''
    url = " https://query.wikidata.org/sparql" 
    r = requests.get(url, params={"query": query, "format": "json"})
    return r.json()["results"]["bindings"]

# 4️⃣  Construiește ClaimReview
def build_claimreview(claim, rating, url):
    return {
        "@context": " https://schema.org", 
        "@type": "ClaimReview",
        "datePublished": pd.Timestamp.now().date().isoformat(),
        "url": url,
        "claimReviewed": claim,
        "author": {"@type": "Organization", "name": "MyFactCheck Lab"},
        "reviewRating": {
            "@type": "Rating",
            "ratingValue": rating,   # 1 = false, 5 = true (ex.)
            "bestRating": "5",
            "worstRating": "1"
        }
    }

# 5️⃣  Aplică pe fiecare claim
claimreviews = []
for c in claims[:5]:   # limităm la 5 pentru demo
    matches = wikidata_check(c)
    rating = "5" if matches else "2"
    claimreviews.append(build_claimreview(c, rating, url))

# 6️⃣  Export JSON‑LD
with open("claimreviews.jsonld", "w", encoding="utf-8") as f:
    json.dump(claimreviews, f, ensure_ascii=False, indent=2)

Acest script:

1. Descarcă un articol și extrage textul.
2. Detectează propoziţiile care conţin claim‑uri cu un model pre‑antrenat.
3. Caută în Wikidata dacă există o entitate exactă (exemplu simplu de cross‑checking).
4. Generează obiecte ClaimReview în format JSON‑LD, gata de încărcare în Google Fact‑Check Tools sau de stocare internă.

📌 Cum poţi combina NNA cu ClaimReview?

1. Colectează postări/tweeturi legate de un subiect (ex. „vaccin COVID”).
2. Aplică NNA pentru a identifica narativele dominante (ex. „vaccinul este periculos”, „vaccinul salvează vieţi”).
3. Foloseşte pipeline‑ul ClaimReview pentru a verifica automat fiecare afirmaţie cheie din acele narative.
4. Îmbină rezultatele: în graficul NNA adaugă un atribut la fiecare nod (ex. rating = 1‑5) și colorează nodurile în funcţie de veridicitate. Astfel poţi vedea nu doar cum se răspândeşte un narativ, ci şi cât de „înșelător” este.

Vizualizare exemplificativă (Gephi)

Acest tip de diagramă permite jurnaliştilor, cercetătorilor sau factorilor de decizie să comunice rapid „Ce se spune?” și „Cât de adevărat este?” în acelaşi timp.

✅ Paşi concreţi pentru a porni proiectul tău

| **1. Definirea întrebării

Pipeline complet – de la scraping la JSON‑LD ClaimReview

Mai jos găseşti un script self‑contained (Python 3.9+) care:

1. Colectează textul unui articol web.
2. Împarte textul în propoziţii și identifică claim‑urile cu un model BERT finetuned (ClaimBuster).
3. Verifică fiecare claim în Wikidata (SPARQL) și, dacă nu găseşte nimic, îl trimite la Google Fact‑Check Tools API (opțional).
4. Curăţă rezultatele cu pandas (de‑dup, normalizare).
5. Construieşte obiecte ClaimReview conform schema.org și le serialisează în JSON‑LD cu ajutorul librăriei python‑json‑ld.

Notă – Pentru o soluţie de producţie ar trebui să adaugi:

– gestionarea rate‑limiting‑ului și a erorilor de reţea,

– caching (ex. Redis) pentru interogările SPARQL,

– un model de clasificare a rating‑ului (True/False/Partially true etc.),

– integrarea cu platforme de fact‑checking (FactCheck.org, Media‑Bias/Fact‑Check API).

1️⃣ Dependinţe

pip install requests beautifulsoup4 spacy pandas 
            transformers torch 
            python-json-ld tqdm
python -m spacy download en_core_web_sm   # (sau ro_core_news_sm dacă lucrezi cu româna)

2️⃣ Codul complet

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import json
import requests
from bs4 import BeautifulSoup
import pandas as pd
from tqdm import tqdm
import spacy
from transformers import pipeline
from pyld import jsonld   # python‑json‑ld expune funcţia jsonld.compact()
from datetime import datetime

# ----------------------------------------------------------------------
# 0️⃣ CONFIGURARE
# ----------------------------------------------------------------------
ARTICLE_URL = " https://example.com/news/article"    # ← înlocuieşte cu URL‑ul tău
WIKIDATA_SPARQL_ENDPOINT = " https://query.wikidata.org/sparql" 
GOOGLE_FACTCHECK_API_KEY = "<YOUR_GOOGLE_API_KEY>"   # dacă vrei să apelezi API‑ul
GOOGLE_FACTCHECK_ENDPOINT = " https://factchecktools.googleapis.com/v1alpha1/claims:search" 

# Modelul ClaimBuster (roberta‑base) - poate fi înlocuit cu altul finetuned
CLAIM_EXTRACTOR = pipeline(
    "text-classification",
    model="microsoft/claimbuster-roberta-base",
    return_all_scores=False,
    device=0   # -1 = CPU, 0 = primul GPU
)

# SpaCy pentru segmentare (mai robust decât split('.'))
NLP = spacy.load("en_core_web_sm")   # sau ro_core_news_sm pentru română

# ----------------------------------------------------------------------
# 1️⃣ SCRAPING & TEXT EXTRACTION
# ----------------------------------------------------------------------
def fetch_article(url: str) -> str:
    resp = requests.get(url, timeout=15)
    resp.raise_for_status()
    soup = BeautifulSoup(resp.text, "html.parser")
    # Eliminăm scripturi, stiluri etc.
    for tag in soup(["script", "style", "header", "footer", "nav", "aside"]):
        tag.decompose()
    return soup.get_text(separator=" ", strip=True)

# ----------------------------------------------------------------------
# 2️⃣ CLAIM DETECTION
# ----------------------------------------------------------------------
def extract_claims(text: str) -> list[str]:
    """Împarte textul în propoziţii și păstrează doar cele clasificate ca CLAIM."""
    doc = NLP(text)
    sentences = [sent.text.strip() for sent in doc.sents if sent.text.strip()]
    claims = []
    for sent in tqdm(sentences, desc="Detectare claim‑uri"):
        try:
            out = CLAIM_EXTRACTOR(sent)[0]   # {'label': 'CLAIM', 'score': 0.98}
            if out["label"] == "CLAIM":
                claims.append(sent)
        except Exception as e:
            # Uneori modelul poate să dea eroare pe texte foarte scurte
            continue
    return claims

# ----------------------------------------------------------------------
# 3️⃣ VERIFICARE în Wikidata
# ----------------------------------------------------------------------
def wikidata_check(claim: str) -> dict | None:
    """Întoarce primul rezultat Wikidata care conţine exact claim‑ul (case‑insensitive)."""
    query = f"""
    SELECT ?item ?itemLabel WHERE {{
      ?item ?p "{claim}"@en .
      SERVICE wikibase:label {{ bd:serviceParam wikibase:language "en". }}
    }} LIMIT 1
    """
    resp = requests.get(
        WIKIDATA_SPARQL_ENDPOINT,
        params={"query": query, "format": "json"},
        headers={"User-Agent": "FactCheckPipeline/0.1 (+ https://github.com/yourrepo)"}, 
        timeout=20,
    )
    resp.raise_for_status()
    data = resp.json()
    bindings = data.get("results", {}).get("bindings", [])
    return bindings[0] if bindings else None

# ----------------------------------------------------------------------
# 4️⃣ (OPŢIONAL) VERIFICARE cu Google Fact‑Check Tools
# ----------------------------------------------------------------------
def google_factcheck_check(claim: str) -> dict | None:
    """Caută claim‑ul în baza Google Fact‑Check Tools. Returnează primul rezultat."""
    if not GOOGLE_FACTCHECK_API_KEY:
        return None
    params = {
        "key": GOOGLE_FACTCHECK_API_KEY,
        "query": claim,
        "languageCode": "en",
        "maxAgeDays": 365,
    }
    resp = requests.get(GOOGLE_FACTCHECK_ENDPOINT, params=params, timeout=15)
    if resp.status_code != 200:
        return None
    data = resp.json()
    claims = data.get("claims", [])
    return claims[0] if claims else None

# ----------------------------------------------------------------------
# 5️⃣ CURĂŢARE & NORMALIZARE (pandas)
# ----------------------------------------------------------------------
def clean_claims(raw_claims: list[str]) -> pd.DataFrame:
    """Înlătură duplicate, normalizează whitespace și adaugă ID unic."""
    df = pd.DataFrame({"claim_raw": raw_claims})
    df["claim_clean"] = (
        df["claim_raw"]
        .str.strip()
        .str.replace(r"s+", " ", regex=True)
        .str.lower()
    )
    df = df.drop_duplicates(subset="claim_clean").reset_index(drop=True)
    df["claim_id"] = df.index + 1
    return df

# ----------------------------------------------------------------------
# 6️⃣ BUILD CLAIMREVIEW (schema.org)
# ----------------------------------------------------------------------
def build_claimreview(
    claim: str,
    rating: str,
    review_url: str,
    author_name: str = "Fact‑Check Bot",
    publisher_name: str = "MyFactCheck.org",
) -> dict:
    """Returnează un dicţionar compatibil cu schema.org/ClaimReview."""
    return {
        "@context": " https://schema.org", 
        "@type": "ClaimReview",
        "datePublished": datetime.utcnow().date().isoformat(),
        "url": review_url,
        "claimReviewed": claim,
        "author": {"@type": "Organization", "name": author_name},
        "publisher": {"@type": "Organization", "name": publisher_name},
        "reviewRating": {
            "@type": "Rating",
            "ratingValue": rating,               # ex. "True", "False", "Partially true"
            "bestRating": "True",
            "worstRating": "False",
            "alternateName": rating,
        },
    }

# ----------------------------------------------------------------------
# 7️⃣ SERIALIZARE JSON‑LD
# ----------------------------------------------------------------------
def to_jsonld(claimreview_obj: dict) -> str:
    """Compactează obiectul ClaimReview în JSON‑LD cu contextul schema.org."""
    # Folosim contextul implicit din obiect (`@context`), deci compactarea este trivială
    compacted = jsonld.compact(claimreview_obj, claimreview_obj["@context"])
    return json.dumps(compacted, indent=2, ensure_ascii=False)

# ----------------------------------------------------------------------
# 8️⃣ PIPELINE MAIN
# ----------------------------------------------------------------------
def main():
    # 1️⃣ Scrape
    raw_text = fetch_article(ARTICLE_URL)
    print(f"📰 Text preluat - {len(raw_text)} caractere")

    # 2️⃣ Detectare claim‑uri
    raw_claims = extract_claims(raw_text)
    print(f"🔎 Claim‑uri găsite: {len(raw_claims)}")

    # 3️⃣ Curăţare
    df_claims = clean_claims(raw_claims)
    print(f"🧹 Claim‑uri curăţate (dup‑eliminate): {len(df_claims)}")

    # 4️⃣ Verificare și construire Review
    claimreview_items = []
    for _, row in tqdm(df_claims.iterrows(), total=len(df_claims), desc="Verificare claim‑uri"):
        claim = row["claim_raw"]
        # 4a) În primul rând căutăm în Wikidata
        wikidata_res = wikidata_check(claim)
        if wikidata_res:
            rating = "True"
            source = f" https://www.wikidata.org/wiki/{wikidata_res ['item']['value'].split('/')[-1]}"
        else:
            # 4b) Dacă nu există în Wikidata, încercăm Google Fact‑Check
            google_res = google_factcheck_check(claim)
            if google_res:
                rating = google_res.get("textualRating", "Unrated")
                source = google_res.get("claimReview", [{}])[0].get("url", "")
            else:
                rating = "Unrated"
                source = ARTICLE_URL

        # 5️⃣ Construim ClaimReview
        cr = build_claimreview(
            claim=claim,
            rating=rating,
            review_url=source,
            author_name="Fact‑Check Bot",
            publisher_name="MyFactCheck.org",
        )
        claimreview_items.append(cr)

    # 6️⃣ Serializare JSON‑LD
    output = {
        "@context": " https://schema.org", 
        "@graph": claimreview_items,
    }
    jsonld_str = json.dumps(output, indent=2, ensure_ascii=False)
    # Salvează în fişier
    out_path = f"claimreview_{datetime.utcnow().strftime('%Y%m%d_%H%M%S')}.jsonld"
    with open(out_path, "w", encoding="utf-8") as f:
        f.write(jsonld_str)

    print(f"✅ Pipeline terminat - {len(claimreview_items)} ClaimReview salvate în {out_path}")

if __name__ == "__main__":
    main()

Explicaţii pas cu pas

Cum poţi extinde acest pipeline

| Model de rating | În loc să presupui

Se pare că ai postat o bucată din codul pipeline‑ului tău (scraping, extragere de claim‑uri, curățare, verificare și serializare JSON‑LD).

Dacă ai o întrebare specifică – de exemplu:

* Cum să finalizezi bucla de verificare (ce să faci după else:)?
* Cum să structurezi obiectul ClaimReview înainte de a-l pasa la to_jsonld?
* Cum să gestionezi erorile în apelurile către Wikidata sau Google Fact‑Check?
* Cum să adaugi alte surse de verificare (ex. Snopes, FactCheck.org)?
* Cum să scrii rezultatele într‑un fișier sau să le exporţi ca JSON‑LD?

sau orice altă problemă pe care ai întâmpinat-o, te rog să îmi spui mai exact ce anume vrei să rezolvi. În funcție de detaliile pe care le oferi, îţi pot oferi:

1. Cod complet pentru secţiunea lipsă (de exemplu, adăugarea rezultatului în claimreview_items și scrierea în fişier);
2. Sugestii de design pentru obiectul ClaimReview conform schema.org;
3. Strategii de retry / back‑off pentru API‑urile externe;
4. Instrucţiuni pentru validarea JSON‑LD (folosind pyld sau alte unelte);
5. Orice altă clarificare legată de fluxul de lucru.

Aştept să îmi spui ce anume îţi doreşti să faci în continuare!