fixed part 3 backend

app.py

@@ -1,25 +1,24 @@
+from gradual.models import GradualInput, GradualOutput
+# from gradual.computations import compute_gradual_semantics
+from gradual.computations import compute_gradual_space
+from aba.aba_builder import prepare_aba_plus_framework, build_aba_framework_from_text
+from relations.predict_bert import predict_relation
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from fastapi.responses import FileResponse, StreamingResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+import torch
+import pandas as pd
+from pathlib import Path
+import asyncio
+import json
+import io
 import os
 
 cache_dir = "/tmp/hf_cache"
 os.environ["TRANSFORMERS_CACHE"] = cache_dir
 os.makedirs(cache_dir, exist_ok=True)
 
-import io
-import json
-import asyncio
-from pathlib import Path
-
-import pandas as pd
-import torch
-from fastapi import FastAPI, UploadFile, File, Form, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-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 -------------------- #
 
@@ -46,6 +45,8 @@ app.add_middleware(
 )
 
 # -------------------- Endpoints -------------------- #
+
+
 @app.get("/")
 def root():
     return {"message": "Argument Mining API is running..."}
@@ -73,7 +74,8 @@ async def predict_csv_stream(file: UploadFile):
         completed = 0
         for _, row in df.iterrows():
             try:
-                result = predict_relation(row["parent"], row["child"], model, tokenizer, device)
+                result = predict_relation(
+                    row["parent"], row["child"], model, tokenizer, device)
                 completed += 1
                 payload = {
                     "parent": row["parent"],
@@ -88,7 +90,6 @@ async def predict_csv_stream(file: UploadFile):
                 yield f"data: {json.dumps({'error': str(e), 'parent': row.get('parent'), 'child': row.get('child')})}\n\n"
                 await asyncio.sleep(0)
 
-
     return StreamingResponse(event_generator(), media_type="text/event-stream")
 
 
@@ -159,14 +160,37 @@ def get_aba_example(filename: str):
 
 # --- 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.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,
+    """
+    API endpoint to compute Weighted h-Categorizer samples
+    and their convex hull (acceptability degree space).
+    """
+    num_args, hull_volume, hull_area, hull_points, samples, axes = compute_gradual_space(
+        num_args=input_data.num_args,
         R=input_data.R,
         n_samples=input_data.n_samples,
-        max_iter=input_data.max_iter
+        axes=input_data.axes,
+        controlled_args=input_data.controlled_args,
+    )
+
+    return GradualOutput(
+        num_args=num_args,
+        hull_volume=hull_volume,
+        hull_area=hull_area,
+        hull_points=hull_points,
+        samples=samples,
+        axes=axes,
     )
 
 
@@ -176,8 +200,10 @@ 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"]]
+        # "args": ["A", "B", "C"],
+        # "relations": [["A", "B"], ["B", "C"]]
+        "num_args": 3,
+        "R": [["A", "B"], ["B", "C"], ["C", "A"]],
     }
     """
     if not GRADUAL_EXAMPLES_DIR.exists():
@@ -196,7 +222,7 @@ def list_gradual_examples():
 @app.get("/gradual-examples/{example_name}")
 def get_gradual_example(example_name: str):
     """
-    Return the content of a specific gradual example.
+    Return the content of a specific gradual example file.
     Example: GET /gradual-examples/simple.json
     """
     file_path = GRADUAL_EXAMPLES_DIR / example_name
@@ -208,4 +234,5 @@ def get_gradual_example(example_name: str):
             content = json.load(f)
         return JSONResponse(content=content)
     except json.JSONDecodeError:
-        raise HTTPException(status_code=400, detail="Invalid JSON format in example file")
+        raise HTTPException(
+            status_code=400, detail="Invalid JSON format in example file")

gradual/computations.py

@@ -1,21 +1,142 @@
-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()
+from scipy.spatial import ConvexHull, QhullError
+from .h_categorizer import h_categorizer
+
+
+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,
+    controlled_args=None
+):
+    """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))))
+
+        # Override controlled arguments if specified
+        if controlled_args:
+            for arg, value in controlled_args.items():
+                w[arg] = value
+
+        HC = h_categorizer(A, R, w, max_iter, epsilon)
+        X[i, :] = dict_to_vector(A, HC)
+
+    return X
+
+
+def _safe_hull(points, qhull_opts="QJ", jitter=1e-8):
+    """
+    Try to compute a convex hull robustly.
+    Uses 'QJ' (joggle) and adds slight random jitter if needed.
+    Returns None if still degenerate.
+    """
+    try:
+        return ConvexHull(points, qhull_options=qhull_opts)
+    except QhullError:
+        try:
+            pts = points + jitter * np.random.randn(*points.shape)
+            return ConvexHull(pts, qhull_options=qhull_opts)
+        except QhullError:
+            return None
+
+
+# def compute_gradual_semantics(
+#     A,
+#     R,
+#     n_samples=1000,
+#     val_axes=None,
+#     controlled_args=None,
+#     epsilon=1e-4,
+#     max_iter=1000
+# ):
+#     """Compute samples and convex hull information for the given argumentation framework."""
+#     X_res = sample_and_compute_X(
+#         A, R, epsilon, max_iter, n_samples, controlled_args=controlled_args
+#     )
+
+#     # Case 1D
+#     if len(A) == 1:
+#         axes = [A[0]]
+#         hull = _safe_hull(X_res)
+#         dim = 1
+#         return dim, axes, X_res, hull
+
+#     # Case 2D
+#     if len(A) == 2:
+#         axes = A[:2]
+#         hull = _safe_hull(X_res)
+#         dim = 2
+#         return dim, axes, X_res, hull
+
+#     # Case ≥ 3D → project on chosen axes
+#     axes = val_axes if val_axes else A[:3]
+#     idx = [A.index(ax) for ax in axes]
+#     Xp = X_res[:, idx]
+#     hull = _safe_hull(Xp)
+#     dim = 3
+#     return dim, axes, Xp, hull
+
+
+def compute_gradual_space(num_args, R, n_samples, axes=None, controlled_args=None, epsilon=1e-4, max_iter=1000):
+    """
+    Compute the convex hull (acceptability degree space) for the weighted h-categorizer.
+    Returns (num_args, hull_volume, hull_area, hull_points, samples, axes)
+    """
+    # Generate argument labels A, B, C, ...
+    A = [chr(ord("A") + i) for i in range(num_args)]
+
+    # 1. Sample and compute semantics
+    X_res = sample_and_compute_X(
+        A, R, epsilon, max_iter, n_samples, controlled_args=controlled_args
+    )
+
+    # 2. Handle projections depending on argument count
+    if num_args == 1:
+        dim = 1
+        axes_used = [A[0]]
+        hull_points = np.array([[np.min(X_res)], [np.max(X_res)]])
+        hull_volume = float(np.max(X_res) - np.min(X_res))
+        hull_area = None
+        return num_args, hull_volume, hull_area, hull_points.tolist(), X_res.tolist(), axes_used
+
+    if num_args == 2:
+        dim = 2
+        axes_used = A[:2]
+        hull = _safe_hull(X_res)
+        if hull is None:
+            hull_volume = 0.0
+            hull_area = 0.0
+            hull_points = []
+        else:
+            hull_volume = float(hull.volume)
+            hull_area = float(hull.area)
+            hull_points = hull.points[hull.vertices].tolist()
+        return num_args, hull_volume, hull_area, hull_points, X_res.tolist(), axes_used
+
+    # num_args >= 3
+    axes_used = axes if axes else A[:3]
+    idx = [A.index(ax) for ax in axes_used]
+    Xp = X_res[:, idx]
+
+    hull = _safe_hull(Xp)
+    if hull is None:
+        hull_volume = 0.0
+        hull_area = 0.0
+        hull_points = []
     else:
-        result["hull_volume"] = None
-        result["hull_area"] = None
-        result["hull_points"] = X_res.tolist()
+        hull_volume = float(hull.volume)
+        hull_area = float(hull.area)
+        hull_points = hull.points[hull.vertices].tolist()
 
-    result["samples"] = X_res.tolist()
-    return result
+    return num_args, hull_volume, hull_area, hull_points, Xp.tolist(), axes_used

gradual/examples/complex.json

@@ -1,4 +1,44 @@
 {
-  "args": ["A", "B", "C", "D", "E"],
-  "relations": [["A", "B"], ["B", "C"], ["C", "D"], ["D", "E"], ["E", "A"]]
-}
+  "num_args": 6,
+  "R": [
+    [
+      "A",
+      "B"
+    ],
+    [
+      "B",
+      "A"
+    ],
+    [
+      "A",
+      "C"
+    ],
+    [
+      "C",
+      "D"
+    ],
+    [
+      "D",
+      "B"
+    ],
+    [
+      "E",
+      "A"
+    ],
+    [
+      "F",
+      "E"
+    ]
+  ],
+  "n_samples": 12000,
+  "axes": [
+    "A",
+    "B",
+    "C"
+  ],
+  "controlled_args": {
+    "D": 0.42,
+    "E": 0.67,
+    "F": 0.35
+  }
+}

gradual/examples/simple.json

@@ -1,4 +1,18 @@
 {
-  "args": ["A", "B", "C"],
-  "relations": [["A", "B"], ["B", "C"]]
-}
+  "num_args": 3,
+  "R": [
+    [
+      "A",
+      "B"
+    ],
+    [
+      "B",
+      "C"
+    ]
+  ],
+  "n_samples": 800,
+  "axes": [
+    "A",
+    "B"
+  ]
+}

gradual/h_categorizer.py

@@ -1,5 +1,6 @@
 import numpy as np
 
+
 def build_att(A, R):
     """Builds a dictionary listing attackers for each argument."""
     att_list = {a: [] for a in A}
@@ -27,21 +28,3 @@ def h_categorizer(A, R, w, max_iter, epsi=1e-4):
             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

@@ -1,5 +1,6 @@
-from pydantic import BaseModel
-from typing import List, Tuple, Optional
+from pydantic import BaseModel, Field
+from typing import List, Tuple, Dict, Optional
+
 
 class GradualInput(BaseModel):
     """
@@ -26,10 +27,21 @@ class GradualInput(BaseModel):
           "max_iter": 1000
         }
     """
-    A: List[str]
-    R: List[Tuple[str, str]]
-    n_samples: int = 1000
-    max_iter: int = 1000
+    num_args: int = Field(..., ge=1, le=10,
+                          description="Number of arguments (|A|)")
+
+    R: List[Tuple[str, str]
+            ] = Field(..., description="Attack relations (A->B format)")
+
+    n_samples: int = Field(
+        1000, ge=10, description="Number of samples for convex hull computation")
+
+    axes: Optional[List[str]] = Field(
+        None, description="Chosen arguments for 3D plot axes (X,Y,Z)")
+
+    controlled_args: Optional[Dict[str, float]] = Field(
+        None, description="Values for non-axis arguments")
+
 
 class GradualOutput(BaseModel):
     """
@@ -72,3 +84,4 @@ class GradualOutput(BaseModel):
     hull_area: Optional[float]
     hull_points: List[List[float]]
     samples: List[List[float]]
+    axes: Optional[List[str]] = None