quantum-learn 0.0.1__tar.gz

quantum_learn-0.0.1/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.2
+Name: quantum-learn
+Version: 0.0.1
+Summary: quantum-learn: quantum machine learning in Python
+Author-email: OsamaMIT <author@example.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: pennylane
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+
+# Quantum-Learn
+
+[![PyPI Version](https://img.shields.io/pypi/v/quantum-learn.svg)](https://pypi.org/project/quantum-learn/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/OsamaMIT/quantum-learn/blob/main/LICENSE)
+[![Python Versions](https://img.shields.io/pypi/pyversions/quantum-learn.svg)](https://pypi.org/project/quantum-learn/)
+
+**Quantum-Learn** is an open-source Python library that simplifies **Quantum Machine Learning (QML)** using **PennyLane**. Inspired by **scikit-learn**, it provides a high-level interface for creating, training, and evaluating **Variational Quantum Circuits (VQCs)** with ease.
+
+## Features
+
+- **Simple API** for training quantum models  
+- Supports **Variational Quantum Circuits (VQC)**  
+- Works with **PennyLane**, **scikit-learn**, and standard ML tools  
+- Customizable **Ansätze** (quantum circuit templates)  
+- Compatible with both **classical simulators** and **real quantum devices**
+
+## Installation
+
+Quantum-Learn requires **Python 3.6+**. Install it via pip:
+
+```bash
+pip install quantum-learn
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/OsamaMIT/quantum-learn.git
+cd quantum-learn
+pip install .
+```
+
+## Quick Start
+### Train a Quantum Model
+```python
+Copy
+Edit
+import pennylane as qml
+import pandas as pd
+from quantum_learn import VariationalQuantumCircuit
+
+# Create a sample dataset
+features = pd.DataFrame({
+    "feature1": [0, 1],
+    "feature2": [1, 0]
+})
+labels = pd.DataFrame({
+    "label": [
+        [1, 0, 0, 0],  # Encoded quantum state for class 0
+        [0, 0, 0, 1]   # Encoded quantum state for class 1
+    ]
+})
+
+# Initialize and train the model
+vqc = VariationalQuantumCircuit()
+vqc.train(features, labels, epochs=5)
+
+# Make predictions
+predictions = vqc.predict(features)
+print(predictions)
+```
+
+## Documentation
+For detailed usage and examples, check out the Quantum-Learn Documentation.
+
+## Roadmap
+- Implement quantum kernel methods
+- Add pre-built ansätze for VQCs
+- Support more backends (IBM Q, Braket)
+- Improve compatibility with scikit-learn
+
+## Contributing
+Contributions are welcome! To contribute:
+
+Fork the repository
+Create a new branch (feature-branch)
+Commit your changes and open a pull request
+License
+This project is licensed under the MIT License. See the LICENSE file for details.

quantum_learn-0.0.1/README.md

@@ -0,0 +1,79 @@
+# Quantum-Learn
+
+[![PyPI Version](https://img.shields.io/pypi/v/quantum-learn.svg)](https://pypi.org/project/quantum-learn/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/OsamaMIT/quantum-learn/blob/main/LICENSE)
+[![Python Versions](https://img.shields.io/pypi/pyversions/quantum-learn.svg)](https://pypi.org/project/quantum-learn/)
+
+**Quantum-Learn** is an open-source Python library that simplifies **Quantum Machine Learning (QML)** using **PennyLane**. Inspired by **scikit-learn**, it provides a high-level interface for creating, training, and evaluating **Variational Quantum Circuits (VQCs)** with ease.
+
+## Features
+
+- **Simple API** for training quantum models  
+- Supports **Variational Quantum Circuits (VQC)**  
+- Works with **PennyLane**, **scikit-learn**, and standard ML tools  
+- Customizable **Ansätze** (quantum circuit templates)  
+- Compatible with both **classical simulators** and **real quantum devices**
+
+## Installation
+
+Quantum-Learn requires **Python 3.6+**. Install it via pip:
+
+```bash
+pip install quantum-learn
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/OsamaMIT/quantum-learn.git
+cd quantum-learn
+pip install .
+```
+
+## Quick Start
+### Train a Quantum Model
+```python
+Copy
+Edit
+import pennylane as qml
+import pandas as pd
+from quantum_learn import VariationalQuantumCircuit
+
+# Create a sample dataset
+features = pd.DataFrame({
+    "feature1": [0, 1],
+    "feature2": [1, 0]
+})
+labels = pd.DataFrame({
+    "label": [
+        [1, 0, 0, 0],  # Encoded quantum state for class 0
+        [0, 0, 0, 1]   # Encoded quantum state for class 1
+    ]
+})
+
+# Initialize and train the model
+vqc = VariationalQuantumCircuit()
+vqc.train(features, labels, epochs=5)
+
+# Make predictions
+predictions = vqc.predict(features)
+print(predictions)
+```
+
+## Documentation
+For detailed usage and examples, check out the Quantum-Learn Documentation.
+
+## Roadmap
+- Implement quantum kernel methods
+- Add pre-built ansätze for VQCs
+- Support more backends (IBM Q, Braket)
+- Improve compatibility with scikit-learn
+
+## Contributing
+Contributions are welcome! To contribute:
+
+Fork the repository
+Create a new branch (feature-branch)
+Commit your changes and open a pull request
+License
+This project is licensed under the MIT License. See the LICENSE file for details.

quantum_learn-0.0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quantum-learn"
+version = "0.0.1"
+description = "quantum-learn: quantum machine learning in Python"
+readme = "README.md"
+authors = [{ name = "OsamaMIT", email = "author@example.com" }]
+license = { text = "MIT" }
+requires-python = ">=3.6"
+dependencies = [
+    "pennylane",
+    "pandas",
+    "matplotlib",
+    "scikit-learn"
+]
+
+# Fix: Make classifiers an array of strings
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Development Status :: 3 - Alpha",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence"
+]

quantum_learn-0.0.1/qmlearn/__init__.py

@@ -0,0 +1,3 @@
+from .vqc import VariationalQuantumCircuit
+
+__all__ = ["VariationalQuantumCircuit"]

quantum_learn-0.0.1/qmlearn/vqc.py

@@ -0,0 +1,88 @@
+import pennylane as qml
+from pennylane import numpy as np
+import pandas as pd
+
+class VariationalQuantumCircuit:
+    def __init__(self):
+        self.params = None
+        self.ansatz = None
+
+    def generator(self, features, params, n_qubits, device, ansatz=None):
+        @qml.qnode(device, diff_method="backprop")
+        def circuit(features, params):
+            if ansatz is not None:
+                return ansatz(features, params, n_qubits)
+            else:
+                # Default ansatz
+                for i in range(n_qubits):
+                    qml.Rot(features[i] * params[i][0],
+                            features[i] * params[i][1],
+                            features[i] * params[i][2],
+                            wires=i)
+                    if i < n_qubits - 1:
+                        qml.CNOT(wires=[i, i + 1])
+                return qml.state()
+        return circuit(features, params)
+
+    def train(self, features, labels, params=None, batch_size=32, epochs=1, n_qubits=None, device=None, ansatz=None,
+              optimizer=qml.AdamOptimizer(stepsize=0.05)):
+        
+        if features is None or labels is None:
+            raise ValueError("Features and labels cannot be None.")
+
+        if n_qubits is None:
+            n_qubits = len(features.columns)
+
+        if device is None:
+            device = qml.device("default.qubit", wires=n_qubits)
+
+        if params is None:
+            params = np.random.randn(n_qubits, 3)
+
+        self.ansatz = ansatz
+        data = pd.concat([features, labels], axis=1)
+
+        def fidelity_loss(output, target):
+            state0 = qml.math.dm_from_state_vector(output)
+            state1 = qml.math.dm_from_state_vector(target)
+            error = 1 - qml.math.fidelity(state0, state1)
+            return error
+
+        def learn():
+            params = np.random.randn(n_qubits, 3)
+            print(params)
+            for epoch in range(epochs):
+                costs = []
+                for start_idx in range(0, len(data), batch_size):
+                    end_idx = min(start_idx + batch_size, len(data))
+                    batch_data = data.iloc[start_idx:end_idx]
+
+                    def cost_function(params):
+                        total_loss = 0
+                        for _, row in batch_data.iterrows():
+                            total_loss += fidelity_loss(
+                                self.generator([row[feature] for feature in features.columns], params, n_qubits, device, ansatz),
+                                [row[label] for label in labels.columns]
+                            )
+                        return qml.math.mean(total_loss / len(batch_data))
+
+                    params, cost = optimizer.step_and_cost(cost_function, params)
+                    costs.append(cost)
+
+                print(f'Epoch {epoch+1}, mean cost: {np.mean(costs)}')
+                print(f'Params: {params}')
+            return params
+
+        self.params = learn()
+
+    def predict(self, features, n_qubits=None, device=None, diff_method="backprop"):
+        if n_qubits is None:
+            n_qubits = len(features.columns)
+        if device is None:
+            device = qml.device("default.qubit", wires=n_qubits)
+        predictions = []
+        for _, row in features.iterrows():
+            feat = [row[feature] for feature in features.columns]
+            output = self.generator(feat, self.params, n_qubits, device, self.ansatz)
+            predictions.append(output)
+        return predictions

quantum_learn-0.0.1/quantum_learn.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.2
+Name: quantum-learn
+Version: 0.0.1
+Summary: quantum-learn: quantum machine learning in Python
+Author-email: OsamaMIT <author@example.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: pennylane
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+
+# Quantum-Learn
+
+[![PyPI Version](https://img.shields.io/pypi/v/quantum-learn.svg)](https://pypi.org/project/quantum-learn/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/OsamaMIT/quantum-learn/blob/main/LICENSE)
+[![Python Versions](https://img.shields.io/pypi/pyversions/quantum-learn.svg)](https://pypi.org/project/quantum-learn/)
+
+**Quantum-Learn** is an open-source Python library that simplifies **Quantum Machine Learning (QML)** using **PennyLane**. Inspired by **scikit-learn**, it provides a high-level interface for creating, training, and evaluating **Variational Quantum Circuits (VQCs)** with ease.
+
+## Features
+
+- **Simple API** for training quantum models  
+- Supports **Variational Quantum Circuits (VQC)**  
+- Works with **PennyLane**, **scikit-learn**, and standard ML tools  
+- Customizable **Ansätze** (quantum circuit templates)  
+- Compatible with both **classical simulators** and **real quantum devices**
+
+## Installation
+
+Quantum-Learn requires **Python 3.6+**. Install it via pip:
+
+```bash
+pip install quantum-learn
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/OsamaMIT/quantum-learn.git
+cd quantum-learn
+pip install .
+```
+
+## Quick Start
+### Train a Quantum Model
+```python
+Copy
+Edit
+import pennylane as qml
+import pandas as pd
+from quantum_learn import VariationalQuantumCircuit
+
+# Create a sample dataset
+features = pd.DataFrame({
+    "feature1": [0, 1],
+    "feature2": [1, 0]
+})
+labels = pd.DataFrame({
+    "label": [
+        [1, 0, 0, 0],  # Encoded quantum state for class 0
+        [0, 0, 0, 1]   # Encoded quantum state for class 1
+    ]
+})
+
+# Initialize and train the model
+vqc = VariationalQuantumCircuit()
+vqc.train(features, labels, epochs=5)
+
+# Make predictions
+predictions = vqc.predict(features)
+print(predictions)
+```
+
+## Documentation
+For detailed usage and examples, check out the Quantum-Learn Documentation.
+
+## Roadmap
+- Implement quantum kernel methods
+- Add pre-built ansätze for VQCs
+- Support more backends (IBM Q, Braket)
+- Improve compatibility with scikit-learn
+
+## Contributing
+Contributions are welcome! To contribute:
+
+Fork the repository
+Create a new branch (feature-branch)
+Commit your changes and open a pull request
+License
+This project is licensed under the MIT License. See the LICENSE file for details.

quantum_learn-0.0.1/quantum_learn.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+qmlearn/__init__.py
+qmlearn/vqc.py
+quantum_learn.egg-info/PKG-INFO
+quantum_learn.egg-info/SOURCES.txt
+quantum_learn.egg-info/dependency_links.txt
+quantum_learn.egg-info/requires.txt
+quantum_learn.egg-info/top_level.txt
+tests/test_vqc.py

quantum_learn-0.0.1/quantum_learn.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

quantum_learn-0.0.1/quantum_learn.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pennylane
+pandas
+matplotlib
+scikit-learn

quantum_learn-0.0.1/quantum_learn.egg-info/top_level.txt

@@ -0,0 +1 @@
+qmlearn

quantum_learn-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

quantum_learn-0.0.1/tests/test_vqc.py

@@ -0,0 +1,51 @@
+import unittest
+import numpy as np
+import pandas as pd
+from qmlearn import VariationalQuantumCircuit
+
+def simple_quantum_dataset():
+    # For a 2-qubit system, a valid state vector has 4 elements.
+    # Here we encode:
+    # 0 -> |00 = [1, 0, 0, 0]
+    # 1 -> |11 = [0, 0, 0, 1]
+    def encode(label):
+        return np.array([1, 0, 0, 0]) if label == 0 else np.array([0, 0, 0, 1])
+    
+    data = pd.DataFrame({
+        "feature1": [0, 1, 0, 1],
+        "feature2": [0, 0, 1, 1],
+        "label": [encode(l) for l in [0, 1, 1, 0]]
+    })
+    return data
+
+
+class TestVariationalQuantumCircuit(unittest.TestCase):
+
+    def setUp(self):
+        # Setup simple quantum dataset
+        data = simple_quantum_dataset()
+        self.features = data[["feature1", "feature2"]]
+        self.labels = data[["label"]]
+        self.vqc = VariationalQuantumCircuit()
+
+    def test_train(self):
+        # Test if training works
+        self.vqc.train(self.features, self.labels, epochs=2)
+        self.assertIsNotNone(self.vqc.params)
+
+    def test_predict(self):
+        # Test if prediction works
+        self.vqc.train(self.features, self.labels, epochs=2)
+        predictions = self.vqc.predict(self.features)
+        self.assertEqual(len(predictions), len(self.features))
+
+    def test_invalid_features(self):
+        # Test invalid input handling
+        with self.assertRaises(ValueError):
+            self.vqc.train(None, self.labels, epochs=2)
+
+
+if __name__ == "__main__":
+    unittest.main()
+
+#python -m unittest discover -s tests