# AI pogonjen rješavač sukoba usklađenosti u stvarnom vremenu s kontrafaktičkim objašnjenjima

## Uvod

Poduzeća koja djeluju u više jurisdikcija suočavaju se s neprekidnim protokom regulatornih ažuriranja. Kada novo pravilo o privatnosti podataka u EU dođe u sukob s postojećim sigurnosnim standardom u Sjedinjenim Državama, timovi za usklađenost moraju brzo uskladiti sukob prije nego što izdavanje proizvoda ili ugovori s dobavljačima budu ugroženi. Tradicionalni ručni pregledi spori su, skloni greškama i često nedostaju transparentnosti – dionici dobivaju „fiksiranu“ politiku bez razumijevanja kompromise koji su doveli do odluke.

**AI pogonjen rješavač sukoba usklađenosti u stvarnom vremenu (CRR)** premošćuje taj jaz. Kontinuirano prikuplja dokumente politika, specifikacije proizvoda i ugovore s dobavljačima, gradi jedinstveni graf znanja o usklađenosti i pokreće motor za rješavanje ograničenja kako bi otkrio kontradikcije. Kada se otkrije sukob, sustav generira **kontrafaktička objašnjenja** – jasne, narativne „što‑ako“ scenarije koji ilustriraju kako bi alternativni izbori utjecali na usklađenost. Ova kombinacija automatizacije i objašnjivosti pretvara usklađenost iz reaktivnog uskog grla u proaktivnu sposobnost podrške odlučivanju.

U ovom članku ćemo:

1. Objasniti arhitektonske komponente CRR‑a.  
2. Detaljno opisati pipeline za otkrivanje sukoba i ulogu graf‑neuronskih mreža (GNN‑a).  
3. Pokazati kako se kontrafaktička objašnjenja generiraju pomoću retrieval‑augmented generation (RAG) i uzročnog zaključivanja.  
4. Pružiti praktični vodič implementacije s isječcima koda i Mermaid dijagramom.  
5. Raspraviti operativne aspekte, sigurnost i buduće proširenja.

## 1. Arhitektonski pregled

CRR je izgrađen kao skup labavo povezanih mikro‑servisa koji komuniciraju putem event‑driven message bus‑a (npr. Kafka). Slika 1 prikazuje visokorazinski protok podataka.

```mermaid
flowchart TD
    A["Usluga za unos politika"] --> B["Usklađeni spremnik grafova znanja"]
    C["Usluga za plan proizvoda"] --> B
    D["Usluga za ugovore s dobavljačima"] --> B
    B --> E["Motor za otkrivanje sukoba"]
    E --> F["Optimizator rješenja"]
    F --> G["Generator kontrafaktičkih objašnjenja"]
    G --> H["Nadzorna ploča usklađenosti"]
    E --> I["Usluga za upozorenja i ticketiranje"]
```

* **Usluga za unos politika** parsira regulatorne tekstove (PDF, HTML, XML) pomoću Document AI, izvlači klauzule i normalizira ih u kanoničku ontologiju.  
* **Usklađeni spremnik grafova znanja** (Neo4j ili JanusGraph) pohranjuje entitete poput *Regulacija*, *Kontrola*, *ZnačajkaProizvoda*, *KlauzulaDobavljača* i odnose *zahtijeva*, *uSukobuSa*, *primjenjujeSeNa*.  
* **Motor za otkrivanje sukoba** pokreće SAT/SMT rješavač (npr. Z3) nad graf‑kodiranim ograničenjima kako bi izložio kontradikcije.  
* **Optimizator rješenja** procjenjuje izvedive akcije otklanjanja koristeći višekriterijski model troškova (rizik, vrijeme, financijski učinak).  
* **Generator kontrafaktičkih objašnjenja** koristi fino podešeni LLM (npr. Llama‑2‑70B) u kombinaciji s uzročnim grafom za proizvodnju ljudski čitljivih „što‑ako“ narativa.  
* **Nadzorna ploča usklađenosti** vizualizira sukobe, predložena rješenja i pripadajuća objašnjenja u stvarnom vremenu.

## 2. Otkrivanje sukoba pomoću graf‑neuronskih mreža

Čist SAT rješavač može identificirati logičke neskladnosti, ali se mu teško nosi s dvosmislenim klauzulama na prirodnom jeziku. Kako bismo poboljšali odziv, svako čvorište i brid enkodiramo pomoću **graf‑neuronske mreže** trenirane na označenom skupu podataka poznatih sukoba. GNN daje vjerojatnosni skor sukoba za svaki par bridova.

### 2.1 Cjevovod za enkodiranje čvorišta

```python
import torch
from torch_geometric.nn import GraphSAGE
from transformers import AutoTokenizer, AutoModel

tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
text_encoder = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")

def encode_clause(text):
    inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=128)
    with torch.no_grad():
        embedding = text_encoder(**inputs).last_hidden_state.mean(dim=1)
    return embedding.squeeze()

# Primjer: enkodiranje klauzule regulacije
reg_clause = "Osobni podaci moraju biti izbrisani u roku od 30 dana od zahtjeva."
reg_vec = encode_clause(reg_clause)
```

Dobiveni vektor `reg_vec` postaje početna značajka čvorišta za GNN. Nakon nekoliko slojeva poruke‑prosljeđivanja, model uči kontekstualne reprezentacije koje hvataju semantičko preklapanje između klauzula.

### 2.2 Ocjenjivanje sukoba

```python
class ConflictScorer(torch.nn.Module):
    def __init__(self, hidden_dim=128):
        super().__init__()
        self.sage = GraphSAGE(in_channels=768, hidden_channels=hidden_dim, num_layers=2)
        self.classifier = torch.nn.Linear(hidden_dim, 1)

    def forward(self, x, edge_index):
        h = self.sage(x, edge_index)
        # Parni dot‑product za kandidatske bridove
        scores = torch.sigmoid(self.classifier(h))
        return scores
```

Tijekom inferencije, bridovi s ocjenom > 0.85 označavaju se za dublju SAT analizu. Ovaj hibridni pristup smanjuje lažne pozitivne rezultate uz očuvanje pokrivenosti.

## 3. Generiranje kontrafaktičkih objašnjenja

Nakon što je sukob potvrđen, sustav mora odgovoriti na dva pitanja:

1. **Koji je korijenski uzrok?** – Identificirati minimalni skup klauzula koji zajedno uzrokuju nesklad.  
2. **Što bi se dogodilo da promijenimo X?** – Pružiti narativ koji opisuje učinak alternativnih akcija otklanjanja.

### 3.1 Izgradnja uzročnog grafa

Kreiramo **uzročni graf** gdje su čvorovi klauzule politika, a bridovi predstavljaju logičke ovisnosti (npr. *zahtijeva*, *isključuje*). Korištenjem Pearl‑ove do‑kalkulacije možemo simulirati intervencije.

```mermaid
graph LR
    A["\"EU GDPR (Članak 17)\""] -->|zahtijeva| B["\"Brisanje podataka ≤ 30 dana\""]
    C["\"US CCPA\""] -->|isključuje| B
    D["\"Predložena politika zadržavanja\""] -->|uSukobuSa| C
```

U ovom primjeru, uklanjanjem zahtjeva *Brisanje podataka ≤ 30 dana* (do‑operacija) sukob s CCPA‑om nestaje.

### 3.2 Retrieval‑Augmented Generation (RAG)

Vraćamo relevantne odlomke politika iz graf‑znanja i prosljeđujemo ih fino podešenom LLM‑u koji je treniran na predlošcima objašnjenja usklađenosti.

```python
from langchain.chains import RetrievalQA
from langchain.vectorstores import FAISS
from langchain.llms import LlamaCpp

vector_store = FAISS.from_documents(policy_documents, embedding_function=encode_clause)
retriever = vector_store.as_retriever(search_kwargs={"k": 5})

llm = LlamaCpp(model_path="llama-2-70b.ggmlv3.q4_0.bin", temperature=0.2)
qa_chain = RetrievalQA.from_chain_type(llm=llm, retriever=retriever)

question = "Objasni zašto GDPR‑ova odredba o brisanju podataka u roku od 30 dana sukobljava se s predloženom politikom zadržavanja od 45 dana i predloži usklađenu alternativu."
explanation = qa_chain.run(question)
print(explanation)
```

Izlaz je koncizan, točkasti narativ:

```
- GDPR (Članak 17) zahtijeva brisanje podataka u roku od 30 dana.
- Predložena politika produžuje rok na 45 dana, čime se krši Članak 17.
- Kontrafaktički scenarij: Ako se rok zadržavanja smanji na 30 dana, sukob nestaje.
- Preporučeno otklanjanje: Uvesti dvo‑razinski model zadržavanja – osjetljivi osobni podaci podliježu 30‑dnevnom pravilu, dok se ne‑osobni zapisi mogu zadržavati 45 dana pod odvojenom klasifikacijom.
```

### 3.3 Modeliranje višekriterijskih troškova

Optimizator procjenjuje svaku akciju otklanjanja prema vektoru troškova **C = (rizik, napor, financije, vrijeme‑do‑tržišta)**. Prikazujemo Pareto‑frontenu timovima za usklađenost, koji mogu odabrati najprikladniji kompromis.

```python
import numpy as np

actions = ["SmanjiRokZadržavanja", "DodajAnonimizacijuPodataka", "KreirajOdvojeniSkupPodataka"]
costs = np.array([
    [0.2, 0.1, 0.05, 0.1],   # SmanjiRokZadržavanja
    [0.1, 0.3, 0.2, 0.2],    # DodajAnonimizacijuPodataka
    [0.15, 0.2, 0.1, 0.05]   # KreirajOdvojeniSkupPodataka
])

# Jednostavni ponderirani zbroj (ponderi se mogu prilagoditi po organizaciji)
weights = np.array([0.4, 0.3, 0.2, 0.1])
scores = costs @ weights
best_action = actions[np.argmin(scores)]
print(f"Najbolje otklanjanje: {best_action}")
```

Odabrana akcija se potom prosljeđuje generatoru kontrafaktičkih objašnjenja kako bi se proizveo konačni, akcijski izvještaj.

## 4. Vodič implementacije

Dolje je korak‑po‑korak kontrolna lista za izgradnju CRR‑a u cloud‑native okruženju.

| Korak | Opis | Preporučena tehnologija |
|------|------|--------------------------|
| 1 | **Uzimanje dokumenata** – OCR, NLP, ekstrakcija klauzula | Azure Form Recognizer, spaCy |
| 2 | **Definicija ontologije** – Izgradnja sheme usklađenosti | OWL/RDF, Protégé |
| 3 | **Pohrana grafa** – Persistencija entiteta i odnosa | Neo4j Aura, Amazon Neptune |
| 4 | **Generiranje enkodiranja** – Sentence transformers | `sentence-transformers/all-MiniLM-L6-v2` |
| 5 | **Trening GNN‑a** – Model vjerojatnosti sukoba | PyTorch Geometric |
| 6 | **Rješavanje ograničenja** – Otkrivanje logičkih kontradikcija | Z3 SMT Solver |
| 7 | **Uzročni graf & do‑kalkulacija** – Simulacija kontrafaktičkih scenarija | DoWhy, CausalNex |
| 8 | **RAG pipeline** – Retrieval + LLM generiranje | LangChain + Llama‑2 |
| 9 | **Optimizacija troškova** – Višekriterijsko vrednovanje | SciPy, PuLP |
|10| **Nadzorna ploča & upozorenja** – UI u stvarnom vremenu | React + D3, Grafana, Slack webhook |

### Primjer Docker‑Compose konfiguracije

```yaml
version: "3.9"
services:
  neo4j:
    image: neo4j:5
    environment:
      - NEO4J_AUTH=neo4j/password
    ports: ["7474:7474", "7687:7687"]
  z3:
    image: z3prover/z3
    command: ["--solver"]
  rag:
    build: ./rag-service
    ports: ["8000:8000"]
  dashboard:
    build: ./dashboard
    ports: ["3000:3000"]
```

Pokrenite s `docker compose up -d`. Svaka usluga zapisuje logove u centralizirani ELK stack radi nadzora.

## 5. Operativni aspekti

### 5.1 Privatnost podataka

Svi dokumenti politika tretiraju se kao **povjerljivi**. Sustav šifrira podatke u mirovanju (AES‑256) i u prijenosu (TLS 1.3). Vektorska pohrana enkodiranja čuva se u **privatnom vektorskom spremniku** koji podržava ubacivanje diferencijalne privatnosti.

### 5.2 Auditi objašnjivosti

Regulatorna tijela sve više zahtijevaju **objašnjivu AI**. CRR zapisuje svaki korak zaključivanja, uključujući:

* ID‑ove sirovih klauzula.  
* Dokazni trag SAT rješavača.  
* Detalje kontrafaktičkih intervencija.  
* Parove prompt‑odgovor LLM‑a.

Ti zapisi mogu se izvesti kao nepromjenjivi JSON zapisi na revizijski ledger (npr. Hyperledger Fabric).

### 5.3 Kontinuirano učenje

GNN i LLM periodično se retreniraju na **ljudski validiranim rješenjima sukoba**. Povratna sprega prikuplja signale prihvaćanja/odbijanja od timova za usklađenost i vraća ih u pipeline putem **reinforcement learning from human feedback (RLHF)** petlje.

## 6. Buduća proširenja

1. **Multimodalni dokazi** – Uključiti snimke zaslona, arhitekturalne dijagrame i isječke koda kao dodatne čvorove dokaza.  
2. **Edge AI** – Implementirati lagani detektor sukoba na edge uređajima za provjere usklađenosti u podatkovnim centrima.  
3. **Prognoza regulatornih promjena** – Kombinirati rješavač sukoba s Monte‑Carlo modelom utjecaja regulatora kako bi se predvidjeli budući kontradikti prije nego što se pojave.  
4. **Međusektorsko dijeljenje znanja** – Omogućiti federirano učenje među partnerima uz očuvanje suvereniteta podataka.

## Zaključak

AI pogonjen rješavač sukoba usklađenosti u stvarnom vremenu pretvara tradicionalni reaktivni, ručni proces u automatizirani, transparentni sustav podrške odlučivanju. Kombinacijom rješavanja ograničenja, graf‑neuronskih mreža i kontrafaktičkih objašnjenja, motor ne samo da trenutno identificira neskladnosti, već i osnažuje dionike jasnim, akcijskim narativima. Organizacije koje usvoje ovu tehnologiju mogu smanjiti latenciju usklađenosti, smanjiti rizik od revizija i zadržati konkurentsku prednost na tržištima s visokim regulatornim zahtjevima.

---

## Vidi također

- [Z3 Theorem Prover: Efficient Constraint Solving for Policy Conflicts](https://github.com/Z3Prover/z3) – **Z3 teorem prover**  
- [DoWhy – Causal Inference for Counterfactual Explanations](https://github.com/microsoft/dowhy) – **DoWhy – uzročna inferencija**  
- [LangChain Retrieval‑Augmented Generation Documentation](https://python.langchain.com/docs/use_cases/question_answering/) – **LangChain RAG dokumentacija**