working gradual semantics !

aba/test.py

@@ -0,0 +1,78 @@
+"""
+Main entry point for generating and analyzing an ABA+ framework.
+
+This script:
+  1. Builds an ABA framework from a text specification.
+  2. Prints the original (classical) ABA framework.
+  3. Prepares the framework for ABA+ (atomic transformation + argument/attack generation).
+  4. Generates ABA+ components (assumption combinations, normal/reverse attacks).
+  5. Prints the resulting ABA+ framework components.
+  6. Plots the ABA+ attack graph between sets of assumptions.
+"""
+
+from copy import deepcopy
+from aba.aba_builder import build_aba_framework, prepare_aba_plus_framework
+from aba.aba_utils import print_aba_plus_results
+from aba.aba_framework import ABAFramework
+
+
+def testABA(aba_framework: ABAFramework):
+
+    copy_framework = deepcopy(aba_framework)
+
+    transformed_framework: ABAFramework = copy_framework.transform_aba()
+    print("\n ------- Transformed ABA framework -------\n ")
+    print(transformed_framework)
+
+    # Generate arguments
+    transformed_framework.generate_arguments()
+    gen_args = transformed_framework.arguments
+    print("\n ------- Generated arguments -------\n ")
+    print(gen_args)
+
+    # Generate attacks
+    transformed_framework.generate_attacks()
+    attacks = transformed_framework.attacks
+    print("\n ------- Generated attacks -------\n ")
+    print(attacks, "\n")
+
+
+def testABAPlus(aba_framework: ABAFramework):
+
+    # === Step 2: Prepare the framework for ABA+ ===
+
+    aba_framework: ABAFramework = prepare_aba_plus_framework(aba_framework)
+
+    # === Step 3: Generate ABA+ components ===
+    print("\n" + "=" * 50)
+    print("Generating ABA+ Components")
+    print("=" * 50)
+    aba_framework.make_aba_plus()
+
+    # === Step 4: Print ABA+ results ===
+    print_aba_plus_results(aba_framework)
+    return aba_framework
+
+
+def main():
+    """
+    Main function to generate and analyze an ABA+ framework.
+    """
+    # === Step 1: Build the ABA framework from input file ===
+    print("\n" + "=" * 50)
+    print("Building ABA+ Framework")
+    print("=" * 50)
+
+    # Build framework from the given input specification file
+    aba_framework = build_aba_framework("aba\exemples\exemple.txt")
+    print(f"\n ------- Original ABA framework -------\n{aba_framework}")
+
+    base_framework = deepcopy(aba_framework)
+    testABA(base_framework)
+
+    aba_for_plus = deepcopy(aba_framework)
+    testABAPlus(aba_for_plus)
+
+
+if __name__ == "__main__":
+    main()

app.py

@@ -11,18 +11,21 @@ from pathlib import Path
 
 import pandas as pd
 import torch
-from fastapi import FastAPI, UploadFile, File, Form
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse, StreamingResponse
+from fastapi.responses import FileResponse, StreamingResponse, JSONResponse
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 
 from relations.predict_bert import predict_relation
 from aba.aba_builder import prepare_aba_plus_framework, build_aba_framework_from_text
+from gradual.computations import compute_gradual_semantics
+from gradual.models import GradualInput, GradualOutput
 
 # -------------------- Config -------------------- #
 
-EXAMPLES_DIR = Path("./aba/exemples")
-SAMPLES_DIR = Path("./relations/exemples/samples")
+ABA_EXAMPLES_DIR = Path("./aba/examples")
+SAMPLES_DIR = Path("./relations/examples/samples")
+GRADUAL_EXAMPLES_DIR = Path("./gradual/examples")
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 model_name = "edgar-demeude/bert-argument"
@@ -48,6 +51,8 @@ def root():
     return {"message": "Argument Mining API is running..."}
 
 
+# --- Predictions --- #
+
 @app.post("/predict-text")
 def predict_text(arg1: str = Form(...), arg2: str = Form(...)):
     """Predict relation between two text arguments using BERT."""
@@ -101,6 +106,8 @@ def get_sample(filename: str):
     return FileResponse(file_path, media_type="text/csv")
 
 
+# --- ABA --- #
+
 @app.post("/aba-upload")
 async def aba_upload(file: UploadFile = File(...)):
     content = await file.read()
@@ -138,13 +145,67 @@ async def aba_upload(file: UploadFile = File(...)):
 
 @app.get("/aba-examples")
 def list_aba_examples():
-    examples = [f.name for f in EXAMPLES_DIR.glob("*.txt")]
+    examples = [f.name for f in ABA_EXAMPLES_DIR.glob("*.txt")]
     return {"examples": examples}
 
 
 @app.get("/aba-examples/{filename}")
 def get_aba_example(filename: str):
-    file_path = EXAMPLES_DIR / filename
+    file_path = ABA_EXAMPLES_DIR / filename
     if not file_path.exists() or not file_path.is_file():
         return {"error": "File not found"}
     return FileResponse(file_path, media_type="text/plain", filename=filename)
+
+
+# --- Gradual semantics --- #
+
+@app.post("/gradual", response_model=GradualOutput)
+def compute_gradual(input_data: GradualInput):
+    """API endpoint to compute Weighted h-Categorizer samples and convex hull."""
+    return compute_gradual_semantics(
+        A=input_data.A,
+        R=input_data.R,
+        n_samples=input_data.n_samples,
+        max_iter=input_data.max_iter
+    )
+
+
+@app.get("/gradual-examples")
+def list_gradual_examples():
+    """
+    List all available gradual semantics example files.
+    Each example must be a JSON file with structure:
+    {
+        "args": ["A", "B", "C"],
+        "relations": [["A", "B"], ["B", "C"]]
+    }
+    """
+    if not GRADUAL_EXAMPLES_DIR.exists():
+        return {"examples": []}
+
+    examples = []
+    for file in GRADUAL_EXAMPLES_DIR.glob("*.json"):
+        examples.append({
+            "name": file.stem,
+            "path": file.name,
+            "content": None
+        })
+    return {"examples": examples}
+
+
+@app.get("/gradual-examples/{example_name}")
+def get_gradual_example(example_name: str):
+    """
+    Return the content of a specific gradual example.
+    Example: GET /gradual-examples/simple.json
+    """
+    file_path = GRADUAL_EXAMPLES_DIR / example_name
+    if not file_path.exists():
+        raise HTTPException(status_code=404, detail="Example not found")
+
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = json.load(f)
+        return JSONResponse(content=content)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid JSON format in example file")

gradual/computations.py

@@ -0,0 +1,21 @@
+from scipy.spatial import ConvexHull
+import numpy as np
+from .h_categorizer import sample_and_compute_X
+
+def compute_gradual_semantics(A, R, n_samples=1000, max_iter=1000):
+    """Compute samples and convex hull information for the given argumentation framework."""
+    X_res = sample_and_compute_X(A, R, max_iter=max_iter, n_samples=n_samples)
+    result = {"num_args": len(A)}
+
+    if len(A) > 1:
+        hull = ConvexHull(X_res)
+        result["hull_volume"] = float(hull.volume)
+        result["hull_area"] = float(hull.area)
+        result["hull_points"] = hull.points[hull.vertices].tolist()
+    else:
+        result["hull_volume"] = None
+        result["hull_area"] = None
+        result["hull_points"] = X_res.tolist()
+
+    result["samples"] = X_res.tolist()
+    return result

gradual/examples/complex.json

@@ -0,0 +1,4 @@
+{
+  "args": ["A", "B", "C", "D", "E"],
+  "relations": [["A", "B"], ["B", "C"], ["C", "D"], ["D", "E"], ["E", "A"]]
+}

gradual/examples/simple.json

@@ -0,0 +1,4 @@
+{
+  "args": ["A", "B", "C"],
+  "relations": [["A", "B"], ["B", "C"]]
+}

gradual/h_categorizer.py

@@ -0,0 +1,47 @@
+import numpy as np
+
+def build_att(A, R):
+    """Builds a dictionary listing attackers for each argument."""
+    att_list = {a: [] for a in A}
+    for att, target in R:
+        if target in att_list:
+            att_list[target].append(att)
+        else:
+            att_list[target] = [att]
+    return att_list
+
+
+def h_categorizer(A, R, w, max_iter, epsi=1e-4):
+    """Computes the h-Categorizer gradual semantics for a given framework (A, R) and weights."""
+    attackers = build_att(A, R)
+    hc = {a: w[a] for a in A}
+
+    for _ in range(max_iter):
+        new_hc = {}
+        for a in A:
+            sum_attackers = sum(hc[b] for b in attackers[a])
+            new_hc[a] = w[a] / (1 + sum_attackers)
+        diff = max(abs(new_hc[a] - hc[a]) for a in A)
+        hc = new_hc
+        if diff < epsi:
+            break
+
+    return hc
+
+
+def dict_to_vector(A, d):
+    """Converts a dictionary {arg: value} into a numpy vector following the order of A."""
+    return np.array([d[a] for a in A], dtype=float)
+
+
+def sample_and_compute_X(A, R, epsilon=1e-4, max_iter=1000, n_samples=10000, seed=42):
+    """Generates n_samples random weight vectors and computes corresponding h-Categorizer results."""
+    rng = np.random.default_rng(seed)
+    X = np.zeros((n_samples, len(A)), dtype=float)
+
+    for i in range(n_samples):
+        w = dict(zip(A, rng.random(len(A))))
+        HC = h_categorizer(A, R, w, max_iter, epsilon)
+        X[i, :] = dict_to_vector(A, HC)
+
+    return X

gradual/models.py

@@ -0,0 +1,74 @@
+from pydantic import BaseModel
+from typing import List, Tuple, Optional
+
+class GradualInput(BaseModel):
+    """
+    Input model for the Weighted h-Categorizer API.
+
+    Attributes
+    ----------
+    A : List[str]
+        List of argument names.
+    R : List[Tuple[str, str]]
+        List of attack relations between arguments.
+    n_samples : int
+        Number of random weight samples to generate (default: 1000).
+    max_iter : int
+        Maximum number of iterations for convergence (default: 1000).
+
+    Example
+    -------
+        # Example JSON body for POST /gradual/compute
+        {
+          "A": ["A", "B", "C"],
+          "R": [["A", "B"], ["B", "C"]],
+          "n_samples": 500,
+          "max_iter": 1000
+        }
+    """
+    A: List[str]
+    R: List[Tuple[str, str]]
+    n_samples: int = 1000
+    max_iter: int = 1000
+
+class GradualOutput(BaseModel):
+    """
+    Output model for the Weighted h-Categorizer API.
+
+    Attributes
+    ----------
+    num_args : int
+        Number of arguments in the framework.
+    hull_volume : Optional[float]
+        Volume of the Convex Hull (None if |A| <= 1).
+    hull_area : Optional[float]
+        Surface area of the Convex Hull (None if |A| <= 1).
+    hull_points : List[List[float]]
+        Coordinates of the Convex Hull vertices.
+    samples : List[List[float]]
+        Sampled points (h-Categorizer outputs) used to compute the hull.
+
+    Example
+    -------
+        # Example response JSON from POST /gradual/compute
+        {
+          "num_args": 3,
+          "hull_volume": 0.018,
+          "hull_area": 0.143,
+          "hull_points": [
+              [0.83, 0.12, 0.45],
+              [0.10, 0.54, 0.92],
+              [0.44, 0.80, 0.33]
+          ],
+          "samples": [
+              [0.2, 0.3, 0.7],
+              [0.6, 0.4, 0.2],
+              ...
+          ]
+        }
+    """
+    num_args: int
+    hull_volume: Optional[float]
+    hull_area: Optional[float]
+    hull_points: List[List[float]]
+    samples: List[List[float]]