Upload qads/quantum/kernels.py

qads/quantum/kernels.py

@@ -0,0 +1,92 @@
+"""Quantum Kernel Attention for similarity measurement."""
+import numpy as np
+from typing import Any
+
+try:
+    import pennylane as qml
+    from pennylane import numpy as pnp
+    HAS_PENNYLANE = True
+except ImportError:
+    HAS_PENNYLANE = False
+
+
+class QuantumKernelAttention:
+    """
+    Quantum kernel-based attention mechanism.
+    Computes K(x, x') = |<φ(x)|φ(x')>|² using quantum circuits.
+    """
+    
+    def __init__(self, config: Any):
+        self.config = config
+        self.n_qubits = config.n_qubits
+        self.n_layers = config.n_layers
+        self.device = None
+        
+        if HAS_PENNYLANE:
+            self.device = qml.device("default.qubit", wires=self.n_qubits, shots=1000)
+            self.params = pnp.random.uniform(0, 2*np.pi, (self.n_layers, self.n_qubits, 3))
+    
+    def compute(self, query: np.ndarray, keys: np.ndarray) -> np.ndarray:
+        """Compute quantum kernel attention scores."""
+        if HAS_PENNYLANE and self.device is not None:
+            try:
+                return self._quantum_kernel(query, keys)
+            except Exception:
+                pass
+        return self._classical_attention(query, keys)
+    
+    def _quantum_kernel(self, query: np.ndarray, keys: np.ndarray) -> np.ndarray:
+        """Compute quantum kernel K(x, x') = |<φ(x)|φ(x')>|²."""
+        @qml.qnode(self.device)
+        def kernel_circuit(x1, x2, params):
+            # Encode first state
+            for i in range(min(self.n_qubits, len(x1))):
+                qml.RY(np.arcsin(np.clip(x1[i], -0.999, 0.999)), wires=i)
+                qml.RZ(x1[i] * np.pi, wires=i)
+            
+            # Variational layers
+            for layer in range(self.n_layers):
+                for i in range(self.n_qubits):
+                    qml.RX(params[layer, i, 0], wires=i)
+                    qml.RY(params[layer, i, 1], wires=i)
+                    qml.RZ(params[layer, i, 2], wires=i)
+                for i in range(self.n_qubits - 1):
+                    qml.CNOT(wires=[i, i+1])
+            
+            # Inverse encoding of second state (swap test)
+            for i in range(min(self.n_qubits, len(x2))):
+                qml.RZ(-x2[i] * np.pi, wires=i)
+                qml.RY(-np.arcsin(np.clip(x2[i], -0.999, 0.999)), wires=i)
+            
+            # SWAP test measurement
+            return qml.expval(qml.PauliZ(0))
+        
+        scores = []
+        q_padded = np.zeros(self.n_qubits)
+        q_padded[:min(len(query), self.n_qubits)] = query[:self.n_qubits]
+        q_padded = q_padded / (np.max(np.abs(q_padded)) + 1e-10) if np.max(np.abs(q_padded)) > 0 else q_padded
+        
+        for key in keys:
+            k_padded = np.zeros(self.n_qubits)
+            k_padded[:min(len(key), self.n_qubits)] = key[:self.n_qubits]
+            k_padded = k_padded / (np.max(np.abs(k_padded)) + 1e-10) if np.max(np.abs(k_padded)) > 0 else k_padded
+            
+            overlap = kernel_circuit(q_padded, k_padded, self.params)
+            # Probability is (1 + overlap)/2
+            scores.append((1.0 + float(overlap)) / 2.0)
+        
+        scores = np.array(scores)
+        # Normalize
+        if scores.sum() > 0:
+            scores = scores / scores.sum()
+        return scores
+    
+    def _classical_attention(self, query: np.ndarray, keys: np.ndarray) -> np.ndarray:
+        """Standard scaled dot-product attention fallback."""
+        q = query / (np.linalg.norm(query) + 1e-10)
+        k = keys / (np.linalg.norm(keys, axis=1, keepdims=True) + 1e-10)
+        scores = np.dot(k, q)
+        scores = scores / np.sqrt(len(query))
+        exp_scores = np.exp(scores - np.max(scores))
+        attention = exp_scores / (exp_scores.sum() + 1e-10)
+        return attention