
# Motor de Decizie AI pentru Prioritizarea în Timp Real a Chestionarelor de Furnizor și Scorarea Riscului

Chestionarele de securitate, auditurile de conformitate și evaluările furnizorilor sunt gardieni esențiali pentru fiecare tranzacție B2B SaaS. Însă trierea manuală a cererilor primite creează adesea un cost ascuns: întârzieri în încheierea contractelor, lipsă de perspectivă asupra riscurilor și echipe de conformitate suprasolicitate. **Procurize** oferă deja un hub unificat pentru organizarea chestionarelor, dar pasul următor evolutiv este un *strat de luare a deciziilor* care știe **care** chestionar să fie abordat **când**, și **cât** de riscant este fiecare furnizor în realitate.

Acest articol te conduce prin designul, implementarea și impactul de business al unui **Motor de Decizie AI** care:

1. **Preia** semnalele furnizorilor în timp real ([rapoarte SOC 2](https://secureframe.com/hub/soc-2/what-is-soc-2), certificate [ISO 27001](https://www.iso.org/standard/27001), atestații DPO GDPR])([GDPR](https://gdpr.eu/)).  
2. **Atribuie** un scor de risc utilizând un model hibrid Graph Neural Network (GNN) + Bayesian.  
3. **Prioritizează** atribuirea chestionarelor printr-un programator bazat pe învățare prin recompensă (reinforcement‑learning).  
4. **Alimentază** deciziile înapoi în spațiul colaborativ al Procurize pentru o execuție fără cusur.

Până la final, vei înțelege cum să transformi un ocean de cereri într-un flux de lucru orientat pe date, optimizat continuu, care scurtează ciclurile de răspuns cu până la **70 %** și crește acuratețea răspunsurilor.

---

## De Ce Contează Prioritizarea în Timp Real

| Punct de Durere | Abordare Convențională | Transformare cu AI |
|-----------------|------------------------|--------------------|
| **Vârfuri de volum** în perioade de rundă de finanțare sau lansări de produse | Coada „primul venit, primul servit” | Programare dinamică, conștientă de încărcare |
| **Zone oarbe de risc** – echipele tratează toți furnizorii la fel | Evaluare manuală a riscului (adesea depășită) | Scorare continuă a riscului cu date live |
| **Răspunsuri ineficiente** – analiști juniori răspund la chestionare cu impact scăzut | Atribuire bazată pe reguli | Alocare de sarcini potrivită pentru competențe |
| **Fricțiune în încheierea contractelor** – răspunsuri lente cauzează oportunități pierdute | Urmărire reactivă | Alerte proactive pentru furnizorii de mare valoare |

Un motor de decizie elimină mentalitatea „un singur șablon pentru toți” prin reevaluarea constantă a **riscului furnizorului** și a **capacității echipei**. Rezultatul este o *listă de priorități vie* care evoluează pe măsură ce apar noi dovezi – exact ce au nevoie organizațiile moderne axate pe securitate.

---

## Prezentare Generală a Arhitecturii

Mai jos este o diagramă Mermaid de nivel înalt care ilustrează componentele de bază și fluxurile de date ale Motorului de Decizie AI, integrate strâns cu platforma existentă Procurize.

```mermaid
graph LR
    subgraph Data Ingestion
        A[""Semnale în Timp Real ale Furnizorului""]
        B[""Repozitar de Politici""]
        C[""Flux de Inteligență a Amenințărilor""]
        A --> D[""Flux de Evenimente (Kafka)""]
        B --> D
        C --> D
    end

    subgraph Risk Scoring
        D --> E[""Magazin de Caracteristici (Delta Lake)""]
        E --> F[""Model Hibrid GNN + Bayesian""]
        F --> G[""Scor de Risc (0‑100)""]
    end

    subgraph Prioritization Scheduler
        G --> H[""Agent de Învățare prin Recompensă""]
        H --> I[""Coada Prioritară""]
        I --> J[""Dispecer de Sarcini (Procurize)""]
    end

    subgraph Feedback Loop
        J --> K[""Acțiune și Feedback Utilizator""]
        K --> L[""Semnal de Recompensă (RL)""]
        L --> H
    end
```

*Toate etichetele nodurilor sunt în ghilimele duble, conform cerințelor sintaxei Mermaid.*

### Elemente Cheie

1. **Fluxul de Evenimente** – Apache Kafka (sau Pulsar) captează fiecare schimbare: noi rapoarte de audit, alerte de vulnerabilitate, actualizări de contract.  
2. **Magazinul de Caracteristici** – Delta Lake centralizat stochează caracteristicile prelucrate (ex.: vechimea furnizorului, gradul de maturitate al controalelor, nivelul de expunere).  
3. **Model Hibrid GNN + Bayesian** – GNN propagă riscul printr-un graf de cunoștințe al controalelor interconectate, în timp ce componenta Bayesiană introduce cunoștințe normative predefinite.  
4. **Programator RL** – Algoritmul multi‑armed bandit învață ce ajustări de priorități duc la cea mai rapidă *încheiere a contractului* sau *reducere a riscului*, utilizând recompense din viața reală din bucla de feedback.  
5. **Dispecer de Sarcini** – Folosind API‑ul Procurize, motorul trimite tickete de chestionare cu prioritate înaltă direct pe tabloul de bord al stakeholderului potrivit.

---

## Preluarea Datelor în Timp Real

### 1. Semnale Furnizor

- **Artefacte de conformitate**: rapoarte [SOC 2](https://secureframe.com/hub/soc-2/what-is-soc-2) Type II, certificate [ISO 27001](https://www.iso.org/standard/27001), atestații DPO GDPR.  
- **Telemetrie operațională**: jurnale CloudTrail, alerte SIEM, inventare de active.  
- **Inteligență externă**: feed‑uri CVE, monitorizare a breșelor pe dark‑web, scoruri de risc ale terțelor.

Toate semnalele sunt normalizate într-o **schemă JSON canonică** și publicate pe topic‑urile Kafka numite `vendor.signals`, `policy.updates` și `threat.intel`.

### 2. Ingineria Caracteristicilor

Un job Spark Structured Streaming îmbogățește continuu evenimentele brute:

```python
from pyspark.sql import functions as F

# Exemplu: calcularea zilelor de la ultimul audit
df = spark.readStream.format("kafka").option("subscribe", "vendor.signals").load()
parsed = df.selectExpr("CAST(value AS STRING) as json").select(F.from_json("json", schema).alias("data"))
features = parsed.withColumn(
    "days_since_audit",
    F.datediff(F.current_date(), F.col("data.last_audit_date"))
)
features.writeStream.format("delta").option("checkpointLocation", "/tmp/checkpoints").start("/mnt/feature-store")
```

**Tabelul Delta Lake** rezultat devine sursa pentru modelul de risc.

---

## Motorul de Scorare a Riscului AI

### Graph Neural Network Hibrid

Graful de cunoștințe furnizor‑control leagă entitățile:

- **Furnizor → Controale** (ex.: „Furnizorul X implementează criptare‑în‑repous”).  
- **Control → Reglementare** (ex.: „Criptarea‑în‑repous satisface GDPR Art. 32”).  
- **Control → Dovezi** (ex.: „Dovada #1234”).

Folosind **PyG** (PyTorch Geometric), un GCN cu două straturi propagatează scorurile de risc:

```python
import torch
from torch_geometric.nn import GCNConv

class RiskGNN(torch.nn.Module):
    def __init__(self, in_dim, hidden_dim, out_dim):
        super().__init__()
        self.conv1 = GCNConv(in_dim, hidden_dim)
        self.conv2 = GCNConv(hidden_dim, out_dim)

    def forward(self, x, edge_index):
        x = torch.relu(self.conv1(x, edge_index))
        x = torch.sigmoid(self.conv2(x, edge_index))
        return x
```

Vectorul `x` rezultat reprezintă **riscul normalizat** pentru fiecare nod furnizor.

### Strat Bayesian de Priori

Experții normativi furnizează **priori** (ex.: „Toți furnizorii care gestionează PHI încep cu un risc de bază de 0,65”). O actualizare Bayesiană combină acești priori cu posteriorul GNN:

\[
P(Risk \mid Data) = \frac{P(Data \mid Risk) \cdot P(Risk)}{P(Data)}
\]

Implementarea utilizează `pymc3` pentru eșantionarea distribuțiilor posterioare, oferind **interval de încredere** alături de estimarea punctuală.

---

## Programatorul de Prioritizare cu Învățare prin Recompensă

### Formulare Multi‑Armed Bandit

Fiecare **braț** corespunde unui nivel de prioritate (ex.: **Urgent**, **Înalt**, **Mediu**, **Scăzut**). Agentul selectează un nivel pentru un anumit chestionar, observă o **recompensă** (contract închis, risc redus, satisfacție analist) și își actualizează politica.

```python
import numpy as np

class BanditAgent:
    def __init__(self, n_arms=4):
        self.n = n_arms
        self.counts = np.zeros(n_arms)
        self.values = np.zeros(n_arms)

    def select_arm(self):
        epsilon = 0.1
        if np.random.rand() > epsilon:
            return np.argmax(self.values)
        else:
            return np.random.randint(0, self.n)

    def update(self, chosen_arm, reward):
        self.counts[chosen_arm] += 1
        n = self.counts[chosen_arm]
        value = self.values[chosen_arm]
        self.values[chosen_arm] = ((n - 1) / n) * value + (1 / n) * reward
```

Semnalul de **recompensă** agregă mai mulți KPI:

- **Reducerea timpului de răspuns (TTA)**.  
- **Alinierea scorului de risc** (cât de bine răspunsul atenuează riscul calculat).  
- **Scor de Feedback al Utilizatorului** (evaluarea de către analist a relevanței sarcinii).

### Învățare Continuă

La fiecare 5 minute agentul RL se reînstruiește folosind ultimul batch de recompense stocat într-un **tabel Delta Lake de recompense**. Politica actualizată este apoi trimisă la serviciul **Coada Prioritară**, influențând instantaneu următorul set de atribuiri.

---

## Integrarea cu Procurize

Procurize expune deja:

- **`/api/v1/questionnaires`** – listare, creare, actualizare chestionare.  
- **`/api/v1/tasks/assign`** – atribuirea unui chestionar unui utilizator/echipă.  
- Webhooks pentru evenimente de finalizare a sarcinilor.

Motorul de decizie consumă aceste API‑uri printr-un wrapper **FastAPI** ușor:

```python
import httpx

async def dispatch_task(vendor_id, priority):
    payload = {
        "vendor_id": vendor_id,
        "priority": priority,
        "due_date": (datetime.utcnow() + timedelta(days=2)).isoformat()
    }
    async with httpx.AsyncClient() as client:
        await client.post("https://api.procurize.com/v1/tasks/assign", json=payload, headers=auth_header)
```

Când un chestionar este marcat ca **finalizat**, webhook‑ul Procurize declanșează o actualizare a tabelului de recompense, închizând bucla de feedback.

---

## Beneficiile de Business

| Indicator | Înainte de Motor | După Motor (30 zile) |
|-----------|------------------|----------------------|
| Timp mediu de răspuns per chestionar | 4,3 zile | **1,2 zile** |
| % furnizori cu risc înalt abordați în 48 h | 22 % | **68 %** |
| Satisfacție analist (1‑5) | 3,1 | **4,6** |
| Creștere a vitezei de încheiere a contractelor (rata de câștig) | 31 % | **45 %** |

**Efectul compus** al unor răspunsuri mai rapide, al unei aliniamente mai bune a riscului și al unor analiști fericiți se traduce în creștere vizibilă a veniturilor și reducerea responsabilității de conformitate.

---

## Planul de Implementare (Sprint de 12 Săptămâni)

| Săptămână | Etapă |
|-----------|-------|
| 1‑2 | Configurarea topic‑urilor Kafka, definirea schemei semnalelor furnizorului |
| 3‑4 | Construirea magazinului de caracteristici Delta Lake, scrierea job‑urilor de streaming |
| 5‑6 | Dezvoltarea modelului GNN, antrenarea pe date istorice de chestionare |
| 7 | Adăugarea stratului Bayesian, calibrul pragurilor de încredere |
| 8‑9 | Implementarea programatorului bandit, colectarea recompenselor |
| 10 | Conectarea la API‑urile Procurize, testarea fluxului de atribuire end‑to‑end |
| 11 | Pilot A/B cu un subset de analiști de conformitate |
| 12 | Lansare globală, stabilirea dashboard‑urilor de monitorizare și alertare |

Criteriile de succes includ **latența modelului < 500 ms**, **convergența programatorului în 200 de interacțiuni**, și **≥ 80 % calitate a datelor** în magazinul de caracteristici.

---

## Perspective de Viitor

1. **Extensie de Învațare Federată** – Permite partenerilor SaaS să îmbunătățească în mod colaborativ modelul de risc fără a împărtăși date brute.  
2. **Strat de AI Explicabil** – Generează raționamente în limbaj natural (ex.: „Furnizorul X a obținut un scor ridicat deoarece a fost afectat recent de CVE‑2024‑1234”).  
3. **Integrare Zero‑Trust** – Împerechează motorul de decizie cu o rețea Zero‑Trust pentru a provisiona automat accesul cu privilegiu minim la dovezile necesare.  
4. **Dublu Digital al Reglementărilor** – Simulează scenarii de reglementări viitoare și re‑prioritizează proactiv chestionarele.

Motorul de decizie devine **creierul** unui ecosistem de conformitate proactiv – mutându‑se de la răspunsuri reactive la gestionarea anticipativă a riscurilor.

---

## Concluzie

Automatizarea răspunsurilor la chestionare reprezintă doar jumătate din problemă. Adevăratul avantaj competitiv constă în **știind ce chestionar să răspunzi prima dată și de ce**. Prin combinarea prelucrării datelor în timp real, a scorării de risc bazate pe grafuri și a prioritizării ghidate de învățare prin recompensă, Motorul de Decizie AI transformă funcția de conformitate dintr-un blocaj într-un accelerator strategic.

Implementarea acestui motor pe platforma colaborativă Procurize permite echipelor de securitate, juridice și vânzări să lucreze în armonie, să încheie contracte mai repede și să rămână în avans față de cerințele de reglementare în continuă schimbare. Într-o lume în care secundele contează, o coadă de priorități AI‑driven, conștientă de risc, este următorul strat esențial al automatizării moderne de conformitate.

---

## Vezi și

- [NIST SP 800‑53 Rev 5 – Cadru de Management al Riscului](https://csrc.nist.gov/publications/detail/sp/800-53/rev-5/final)  
- [ISO/IEC 27001:2022 – Managementul Securității Informației](https://www.iso.org/standard/73906.html)  
- [Blogul Google Cloud: Construirea de Pipeline‑uri ML în Timp Real cu Kafka și Vertex AI](https://cloud.google.com/blog/topics/inside-google-cloud/building-real-time-ml-pipelines)