feat: GPU/TensorCore integration — TensorFlow backend, GPU-accelerated reasoning, training, and memory

- New fusionagi/gpu/ module with TensorBackend protocol abstraction
  - TensorFlowBackend: GPU-accelerated ops with TensorCore mixed-precision
  - NumPyBackend: CPU fallback (always available, no extra deps)
  - Auto-selects best available backend at runtime

- GPU-accelerated operations:
  - Cosine similarity matrix (batched, XLA-compiled)
  - Multi-head attention for consensus scoring
  - Batch hypothesis scoring on GPU
  - Semantic similarity search (pairwise, nearest-neighbor, deduplication)

- New TensorFlowAdapter (fusionagi/adapters/):
  - LLMAdapter for local TF/Keras model inference
  - TensorCore mixed-precision support
  - GPU-accelerated embedding synthesis fallback

- Reasoning pipeline integration:
  - gpu_scoring.py: drop-in GPU replacement for multi_path scoring
  - Super Big Brain: use_gpu config flag, GPU scoring when available

- Memory integration:
  - gpu_search.py: GPU-accelerated semantic search for SemanticGraphMemory

- Self-improvement integration:
  - gpu_training.py: gradient-based heuristic weight optimization
  - Reflective memory training loop with loss tracking

- Dependencies: gpu extra (tensorflow>=2.16, numpy>=1.26)
- 64 new tests (276 total), all passing
- Architecture spec: docs/gpu_tensorcore_integration.md

Co-Authored-By: Nakamoto, S <defi@defi-oracle.io>

tests/test_gpu_attention.py

@@ -0,0 +1,89 @@
+"""Tests for fusionagi.gpu.tensor_attention."""
+
+import pytest
+
+from fusionagi.gpu.backend import reset_backend, get_backend
+from fusionagi.gpu.tensor_attention import (
+    attention_consensus,
+    cross_claim_attention,
+)
+
+
+@pytest.fixture(autouse=True)
+def _use_numpy():
+    reset_backend()
+    get_backend(force="numpy")
+    yield
+    reset_backend()
+
+
+class TestAttentionConsensus:
+    def test_empty(self):
+        result = attention_consensus([], "query")
+        assert result["head_scores"] == []
+        assert result["consensus_score"] == 0.0
+
+    def test_single_head(self):
+        result = attention_consensus(
+            [["the sky is blue"]],
+            "what color is the sky",
+        )
+        assert len(result["head_scores"]) == 1
+        assert isinstance(result["consensus_score"], float)
+
+    def test_multiple_heads(self):
+        result = attention_consensus(
+            [
+                ["the sky is blue", "water is wet"],
+                ["security is important"],
+                ["cost should be minimized"],
+            ],
+            "what should we do about the project",
+        )
+        assert len(result["head_scores"]) == 3
+        assert 0.0 <= result["consensus_score"] <= 1.0
+
+    def test_with_weights(self):
+        result = attention_consensus(
+            [["claim a"], ["claim b"]],
+            "query",
+            head_weights=[2.0, 0.5],
+        )
+        assert len(result["head_scores"]) == 2
+
+    def test_empty_claims(self):
+        result = attention_consensus(
+            [[], []],
+            "query",
+        )
+        assert len(result["head_scores"]) == 2
+        assert result["head_scores"] == [0.0, 0.0]
+
+
+class TestCrossClaimAttention:
+    def test_empty(self):
+        result = cross_claim_attention([])
+        assert result["similarity_matrix"] == []
+        assert result["conflict_pairs"] == []
+
+    def test_single(self):
+        result = cross_claim_attention(["only one claim"])
+        assert result["similarity_matrix"] == []
+
+    def test_two_claims(self):
+        result = cross_claim_attention(["claim one", "claim two"])
+        assert len(result["similarity_matrix"]) == 2
+        assert len(result["similarity_matrix"][0]) == 2
+
+    def test_self_similarity_high(self):
+        result = cross_claim_attention(["same text", "same text"])
+        sim = result["similarity_matrix"]
+        assert sim[0][0] > 0.9
+        assert sim[1][1] > 0.9
+
+    def test_conflict_detection(self):
+        result = cross_claim_attention([
+            "the project is very safe and reliable",
+            "completely unrelated topic about food and cooking",
+        ])
+        assert isinstance(result["conflict_pairs"], list)

tests/test_gpu_backend.py

@@ -0,0 +1,129 @@
+"""Tests for fusionagi.gpu backend, similarity, attention, scoring, and training."""
+
+import pytest
+import numpy as np
+
+from fusionagi.gpu.backend import (
+    DeviceType,
+    NumPyBackend,
+    TensorBackend,
+    get_backend,
+    reset_backend,
+)
+
+
+@pytest.fixture(autouse=True)
+def _reset():
+    """Reset backend singleton between tests."""
+    reset_backend()
+    yield
+    reset_backend()
+
+
+class TestNumPyBackend:
+    """Tests for NumPyBackend (CPU fallback)."""
+
+    def test_name(self):
+        be = NumPyBackend()
+        assert be.name == "numpy"
+
+    def test_device(self):
+        be = NumPyBackend()
+        assert be.device == DeviceType.CPU
+
+    def test_gpu_available(self):
+        be = NumPyBackend()
+        assert be.gpu_available() is False
+
+    def test_embed_texts_shape(self):
+        be = NumPyBackend()
+        emb = be.embed_texts(["hello world", "foo bar baz"])
+        assert emb.shape == (2, 256)
+
+    def test_embed_texts_normalized(self):
+        be = NumPyBackend()
+        emb = be.embed_texts(["some text here"])
+        norm = np.linalg.norm(emb[0])
+        assert abs(norm - 1.0) < 1e-5
+
+    def test_embed_texts_deterministic(self):
+        be = NumPyBackend()
+        emb1 = be.embed_texts(["hello world"])
+        emb2 = be.embed_texts(["hello world"])
+        np.testing.assert_array_almost_equal(emb1, emb2)
+
+    def test_cosine_similarity_matrix_shape(self):
+        be = NumPyBackend()
+        a = be.embed_texts(["hello", "world"])
+        b = be.embed_texts(["foo", "bar", "baz"])
+        sim = be.cosine_similarity_matrix(a, b)
+        assert sim.shape == (2, 3)
+
+    def test_cosine_similarity_self(self):
+        be = NumPyBackend()
+        emb = be.embed_texts(["test sentence"])
+        sim = be.cosine_similarity_matrix(emb, emb)
+        assert abs(sim[0, 0] - 1.0) < 1e-5
+
+    def test_batch_score_shape(self):
+        be = NumPyBackend()
+        hyp = be.embed_texts(["h1", "h2", "h3"])
+        ref = be.embed_texts(["reference"])[0]
+        scores = be.batch_score(hyp, ref)
+        assert scores.shape == (3,)
+
+    def test_batch_score_with_weights(self):
+        be = NumPyBackend()
+        hyp = be.embed_texts(["h1", "h2"])
+        ref = be.embed_texts(["reference"])[0]
+        weights = np.ones(256, dtype=np.float32)
+        scores = be.batch_score(hyp, ref, weights)
+        assert scores.shape == (2,)
+
+    def test_multi_head_attention_shape(self):
+        be = NumPyBackend()
+        q = be.embed_texts(["query1", "query2"])
+        k = be.embed_texts(["key1", "key2", "key3"])
+        v = be.embed_texts(["val1", "val2", "val3"])
+        out = be.multi_head_attention(q, k, v, num_heads=4)
+        assert out.shape[0] == 2
+
+    def test_to_numpy_roundtrip(self):
+        be = NumPyBackend()
+        arr = np.array([1.0, 2.0, 3.0])
+        tensor = be.from_numpy(arr)
+        result = be.to_numpy(tensor)
+        np.testing.assert_array_equal(arr, result)
+
+    def test_device_summary(self):
+        be = NumPyBackend()
+        summary = be.device_summary()
+        assert summary["backend"] == "numpy"
+        assert summary["device"] == "cpu"
+
+    def test_enable_mixed_precision_noop(self):
+        be = NumPyBackend()
+        be.enable_mixed_precision()
+
+
+class TestGetBackend:
+    """Tests for backend auto-selection."""
+
+    def test_force_numpy(self):
+        be = get_backend(force="numpy")
+        assert be.name == "numpy"
+
+    def test_default_returns_backend(self):
+        be = get_backend()
+        assert isinstance(be, TensorBackend)
+
+    def test_cached_singleton(self):
+        be1 = get_backend(force="numpy")
+        be2 = get_backend()
+        assert be1 is be2
+
+    def test_reset_clears_cache(self):
+        be1 = get_backend(force="numpy")
+        reset_backend()
+        be2 = get_backend(force="numpy")
+        assert be1 is not be2

tests/test_gpu_scoring.py

@@ -0,0 +1,97 @@
+"""Tests for fusionagi.gpu.tensor_scoring and reasoning.gpu_scoring."""
+
+import pytest
+
+from fusionagi.gpu.backend import reset_backend, get_backend
+from fusionagi.gpu.tensor_scoring import (
+    gpu_score_hypotheses,
+    gpu_score_claims_against_reference,
+)
+from fusionagi.reasoning.gpu_scoring import (
+    generate_and_score_gpu,
+    score_claims_gpu,
+    deduplicate_claims_gpu,
+)
+from fusionagi.schemas.atomic import AtomicSemanticUnit, AtomicUnitType
+
+
+@pytest.fixture(autouse=True)
+def _use_numpy():
+    reset_backend()
+    get_backend(force="numpy")
+    yield
+    reset_backend()
+
+
+def _make_unit(content: str) -> AtomicSemanticUnit:
+    return AtomicSemanticUnit(
+        unit_id=f"u_{hash(content) % 10000}",
+        content=content,
+        type=AtomicUnitType.FACT,
+        confidence=1.0,
+    )
+
+
+class TestGPUScoreHypotheses:
+    def test_empty(self):
+        assert gpu_score_hypotheses([], []) == []
+
+    def test_basic(self):
+        units = [_make_unit("the sky is blue"), _make_unit("water is wet")]
+        results = gpu_score_hypotheses(["the sky is blue"], units)
+        assert len(results) == 1
+        node, score = results[0]
+        assert node.thought == "the sky is blue"
+        assert 0.0 <= score <= 1.0
+
+    def test_multiple_hypotheses(self):
+        units = [_make_unit("python is great")]
+        results = gpu_score_hypotheses(
+            ["python is great", "java is better", "rust is fast"],
+            units,
+        )
+        assert len(results) == 3
+        # Should be sorted by score descending
+        scores = [s for _, s in results]
+        assert scores == sorted(scores, reverse=True)
+
+    def test_no_units(self):
+        results = gpu_score_hypotheses(["test hypothesis"], [])
+        assert len(results) == 1
+        assert results[0][1] == 0.5
+
+    def test_gpu_metadata(self):
+        units = [_make_unit("test content")]
+        results = gpu_score_hypotheses(["test content"], units)
+        node, _ = results[0]
+        assert node.metadata.get("gpu_scored") is True
+
+
+class TestGPUScoreClaimsAgainstReference:
+    def test_empty(self):
+        assert gpu_score_claims_against_reference([], "ref") == []
+
+    def test_basic(self):
+        scores = gpu_score_claims_against_reference(
+            ["claim one", "claim two"],
+            "claim one reference",
+        )
+        assert len(scores) == 2
+        assert all(isinstance(s, float) for s in scores)
+
+
+class TestReasoningGPUScoring:
+    def test_generate_and_score_gpu(self):
+        units = [_make_unit("hello world"), _make_unit("testing gpu")]
+        results = generate_and_score_gpu(["hello world", "testing gpu"], units)
+        assert len(results) == 2
+
+    def test_score_claims_gpu(self):
+        scores = score_claims_gpu(["test claim"], "reference text")
+        assert len(scores) == 1
+        assert isinstance(scores[0], float)
+
+    def test_deduplicate_claims_gpu(self):
+        groups = deduplicate_claims_gpu(["a", "b", "c"])
+        all_indices = sorted(idx for group in groups for idx in group)
+        assert all_indices == [0, 1, 2]

tests/test_gpu_similarity.py

@@ -0,0 +1,95 @@
+"""Tests for fusionagi.gpu.tensor_similarity."""
+
+import pytest
+
+from fusionagi.gpu.backend import reset_backend, get_backend
+from fusionagi.gpu.tensor_similarity import (
+    pairwise_text_similarity,
+    deduplicate_claims,
+    nearest_neighbors,
+)
+
+
+@pytest.fixture(autouse=True)
+def _use_numpy():
+    reset_backend()
+    get_backend(force="numpy")
+    yield
+    reset_backend()
+
+
+class TestPairwiseTextSimilarity:
+    def test_basic(self):
+        sim = pairwise_text_similarity(["hello world"], ["hello world"])
+        assert sim.shape == (1, 1)
+        assert sim[0, 0] > 0.9
+
+    def test_different_texts(self):
+        sim = pairwise_text_similarity(["hello world"], ["completely different text"])
+        assert sim.shape == (1, 1)
+        assert sim[0, 0] < 1.0
+
+    def test_multi(self):
+        sim = pairwise_text_similarity(
+            ["cat", "dog"],
+            ["car", "bike", "train"],
+        )
+        assert sim.shape == (2, 3)
+
+
+class TestDeduplicateClaims:
+    def test_empty(self):
+        assert deduplicate_claims([]) == []
+
+    def test_single(self):
+        groups = deduplicate_claims(["one claim"])
+        assert groups == [[0]]
+
+    def test_identical(self):
+        groups = deduplicate_claims(
+            ["the sky is blue", "the sky is blue"],
+            threshold=0.9,
+        )
+        assert len(groups) == 1
+        assert sorted(groups[0]) == [0, 1]
+
+    def test_different(self):
+        groups = deduplicate_claims(
+            ["the sky is blue", "python is a programming language"],
+            threshold=0.99,
+        )
+        assert len(groups) == 2
+
+    def test_all_indices_covered(self):
+        claims = ["a", "b", "c", "d"]
+        groups = deduplicate_claims(claims, threshold=0.99)
+        all_indices = sorted(idx for group in groups for idx in group)
+        assert all_indices == [0, 1, 2, 3]
+
+
+class TestNearestNeighbors:
+    def test_empty_query(self):
+        result = nearest_neighbors([], ["corpus text"])
+        assert result == []
+
+    def test_empty_corpus(self):
+        result = nearest_neighbors(["query"], [])
+        assert result == [[]]
+
+    def test_basic(self):
+        result = nearest_neighbors(
+            ["hello world"],
+            ["hello world", "goodbye moon", "hello planet"],
+            top_k=2,
+        )
+        assert len(result) == 1
+        assert len(result[0]) == 2
+        # Each result is (index, score)
+        assert isinstance(result[0][0], tuple)
+        assert isinstance(result[0][0][0], int)
+        assert isinstance(result[0][0][1], float)
+
+    def test_top_k_limit(self):
+        corpus = [f"text {i}" for i in range(20)]
+        result = nearest_neighbors(["text 5"], corpus, top_k=3)
+        assert len(result[0]) == 3

tests/test_gpu_training.py

@@ -0,0 +1,132 @@
+"""Tests for fusionagi.gpu.training and self_improvement.gpu_training."""
+
+import pytest
+
+from fusionagi.gpu.backend import reset_backend, get_backend
+from fusionagi.gpu.training import (
+    TrainingConfig,
+    TrainingResult,
+    prepare_training_pairs,
+    optimize_heuristic_weights,
+    run_gpu_training,
+)
+from fusionagi.self_improvement.gpu_training import (
+    run_gpu_enhanced_training,
+    can_gpu_train,
+)
+
+
+@pytest.fixture(autouse=True)
+def _use_numpy():
+    reset_backend()
+    get_backend(force="numpy")
+    yield
+    reset_backend()
+
+
+class FakeReflectiveMemory:
+    """Fake reflective memory for testing."""
+
+    def __init__(self, lessons: list | None = None):
+        self._lessons = lessons or []
+        self._heuristics: dict = {}
+
+    def get_lessons(self, limit: int = 50) -> list:
+        return self._lessons[:limit]
+
+    def get_all_heuristics(self) -> dict:
+        return dict(self._heuristics)
+
+    def set_heuristic(self, key: str, value) -> None:
+        self._heuristics[key] = value
+
+
+class TestPrepareTrainingPairs:
+    def test_empty(self):
+        be = get_backend()
+        inputs, targets = prepare_training_pairs([], backend=be)
+        assert be.to_numpy(inputs).shape[0] == 0
+
+    def test_basic(self):
+        be = get_backend()
+        lessons = [
+            {"task_id": "t1", "outcome": "success", "evaluation": {"score": 0.9}},
+            {"task_id": "t2", "outcome": "failed", "evaluation": {"score": 0.2}},
+        ]
+        inputs, targets = prepare_training_pairs(lessons, backend=be)
+        inputs_np = be.to_numpy(inputs)
+        targets_np = be.to_numpy(targets)
+        assert inputs_np.shape[0] == 2
+        assert targets_np.shape == (2,)
+        assert abs(targets_np[0] - 0.9) < 1e-5
+        assert abs(targets_np[1] - 0.2) < 1e-5
+
+
+class TestOptimizeHeuristicWeights:
+    def test_empty_data(self):
+        be = get_backend()
+        import numpy as np
+        inputs = be.from_numpy(np.zeros((0, 256), dtype=np.float32))
+        targets = be.from_numpy(np.zeros(0, dtype=np.float32))
+        result = optimize_heuristic_weights(inputs, targets, backend=be)
+        assert result.metadata.get("reason") == "no training data"
+
+    def test_basic_training(self):
+        be = get_backend()
+        import numpy as np
+        np.random.seed(42)
+        inputs = be.from_numpy(np.random.randn(10, 256).astype(np.float32))
+        targets = be.from_numpy(np.random.rand(10).astype(np.float32))
+        config = TrainingConfig(epochs=5, learning_rate=0.001)
+        result = optimize_heuristic_weights(inputs, targets, config=config, backend=be)
+        assert result.epochs_run == 5
+        assert result.weights_updated == 256
+        assert result.metadata["backend"] == "numpy"
+
+    def test_loss_decreases(self):
+        be = get_backend()
+        import numpy as np
+        np.random.seed(42)
+        inputs = be.from_numpy(np.random.randn(50, 256).astype(np.float32))
+        targets = be.from_numpy(np.random.rand(50).astype(np.float32))
+        config = TrainingConfig(epochs=20, learning_rate=0.01)
+        result = optimize_heuristic_weights(inputs, targets, config=config, backend=be)
+        # Loss should generally decrease with training
+        assert result.final_loss <= result.initial_loss + 0.5
+
+
+class TestRunGPUTraining:
+    def test_no_lessons(self):
+        mem = FakeReflectiveMemory(lessons=[])
+        result = run_gpu_training(mem)
+        assert result.metadata.get("reason") == "no lessons available"
+
+    def test_with_lessons(self):
+        lessons = [
+            {"task_id": f"t{i}", "outcome": "ok", "evaluation": {"score": 0.5 + i * 0.1}}
+            for i in range(5)
+        ]
+        mem = FakeReflectiveMemory(lessons=lessons)
+        config = TrainingConfig(epochs=3)
+        result = run_gpu_training(mem, config=config)
+        assert result.epochs_run == 3
+
+
+class TestSelfImprovementGPUTraining:
+    def test_can_gpu_train(self):
+        assert can_gpu_train() is True
+
+    def test_run_enhanced_training_empty(self):
+        mem = FakeReflectiveMemory(lessons=[])
+        result = run_gpu_enhanced_training(mem, epochs=3)
+        assert result.get("gpu_accelerated") is True or "reason" in result
+
+    def test_run_enhanced_training_with_data(self):
+        lessons = [
+            {"task_id": "t1", "outcome": "ok", "evaluation": {"score": 0.8}},
+            {"task_id": "t2", "outcome": "fail", "evaluation": {"score": 0.3}},
+        ]
+        mem = FakeReflectiveMemory(lessons=lessons)
+        result = run_gpu_enhanced_training(mem, epochs=3)
+        assert result.get("gpu_accelerated") is True
+        assert "gpu_training_last_loss" in mem.get_all_heuristics()

tests/test_tensorflow_adapter.py

@@ -0,0 +1,77 @@
+"""Tests for fusionagi.adapters.tensorflow_adapter (uses NumPy backend, no TF required)."""
+
+import pytest
+
+from fusionagi.gpu.backend import reset_backend, get_backend
+
+
+@pytest.fixture(autouse=True)
+def _use_numpy():
+    reset_backend()
+    get_backend(force="numpy")
+    yield
+    reset_backend()
+
+
+class TestTensorFlowAdapterImport:
+    """Test that TensorFlowAdapter is importable (may be None without TF)."""
+
+    def test_import(self):
+        from fusionagi.adapters import TensorFlowAdapter
+        # TensorFlowAdapter is None when tensorflow is not installed
+        # This is by design — GPU is an optional dependency
+
+
+class TestGPUMemorySearch:
+    """Test GPU-accelerated memory search."""
+
+    def test_semantic_search(self):
+        from fusionagi.memory.gpu_search import semantic_search
+        from fusionagi.schemas.atomic import AtomicSemanticUnit, AtomicUnitType
+
+        units = [
+            AtomicSemanticUnit(
+                unit_id="u1",
+                content="the sky is blue",
+                type=AtomicUnitType.FACT,
+                confidence=1.0,
+            ),
+            AtomicSemanticUnit(
+                unit_id="u2",
+                content="water is wet",
+                type=AtomicUnitType.FACT,
+                confidence=1.0,
+            ),
+            AtomicSemanticUnit(
+                unit_id="u3",
+                content="python programming language",
+                type=AtomicUnitType.FACT,
+                confidence=1.0,
+            ),
+        ]
+        results = semantic_search("sky color", units, top_k=2)
+        assert len(results) <= 2
+        assert all(isinstance(r, tuple) for r in results)
+        assert all(isinstance(r[0], AtomicSemanticUnit) for r in results)
+        assert all(isinstance(r[1], float) for r in results)
+
+    def test_semantic_search_empty(self):
+        from fusionagi.memory.gpu_search import semantic_search
+
+        results = semantic_search("query", [], top_k=5)
+        assert results == []
+
+    def test_batch_embed_units(self):
+        from fusionagi.memory.gpu_search import batch_embed_units
+        from fusionagi.schemas.atomic import AtomicSemanticUnit, AtomicUnitType
+
+        units = [
+            AtomicSemanticUnit(
+                unit_id="u1",
+                content="test content",
+                type=AtomicUnitType.FACT,
+                confidence=1.0,
+            ),
+        ]
+        result = batch_embed_units(units)
+        assert result is not None