Co

app.py

@@ -9,31 +9,35 @@ import PIL
 import matplotlib.pyplot as plt
 from PIL import Image
 import pennylane as qml
+import base64
+
+from numpy import pi
+import numpy as np
+from qutip import *
+from qutip.qip.operations import *
+from qutip.qip.circuit import QubitCircuit, Gate
 
 # Define a device
 dev = qml.device('default.qubit', wires=10)
 
-# Hugging Face and DuckDB function placeholders
-from datasets import load_dataset, Dataset
+def plot_qutip_circuit():
+    q = QubitCircuit(2, reverse_states=False)
+    q.add_gate("CNOT", controls=[0], targets=[1])
+    
+    # Display the circuit as an image
+    q.png  # Generates and renders the circuit diagram
+
+    return q
 
+
+# Hugging Face and DuckDB function placeholders
 def store_in_hf_dataset(data):
-    # Convert data to Hugging Face Dataset format
-    dataset = Dataset.from_dict({
-        'id': [item[0] for item in data],
-        'hamiltonian': [item[2] for item in data],
-        'qasm_code': [item[3] for item in data],
-        'trotter_code': [item[4] for item in data],
-        'num_qubits': [item[5] for item in data],
-        'trotter_order': [item[6] for item in data],
-        'timestamp': [str(item[7]) for item in data],
-    })
-    # Push to Hugging Face dataset hub (replace with your dataset path)
-    dataset.push_to_hub("your-username/BoltzmannEntropy-QuantumLLMInstruct")
+    # Implement storing data in the Hugging Face dataset
+    pass
 
 def load_from_hf_dataset():
-    # Load from Hugging Face dataset
-    dataset = load_dataset("your-username/BoltzmannEntropy-QuantumLLMInstruct")
-    return dataset
+    # Implement loading data from the Hugging Face dataset
+    return []
 
 # Function to buffer the plot and return as PIL image
 def buffer_plot_and_get(fig):
@@ -116,12 +120,58 @@ def store_in_duckdb(data, db_file='quantum_hamiltonians.duckdb'):
                         VALUES (?, ?, ?, ?, ?, ?, ?, ?)""", data)
     conn.close()
 
-# Load results from DuckDB
+# Load results from DuckDB and encode images to base64
+def encode_image_from_blob(blob):
+    img_buffer = io.BytesIO(blob)
+    image = Image.open(img_buffer)
+    img_str = base64.b64encode(img_buffer.getvalue()).decode("utf-8")
+    return f'<img src="data:image/png;base64,{img_str}" style="max-width:500px;"/>'
+
 def load_from_duckdb(db_file='quantum_hamiltonians.duckdb'):
     conn = duckdb.connect(database=db_file)
     df = conn.execute("SELECT * FROM hamiltonians").df()
     conn.close()
-    return df
+
+    # Convert results to HTML with images
+    html_content = []
+    for index, row in df.iterrows():
+        plot_blob = row['plot']
+        encoded_img = encode_image_from_blob(plot_blob)
+
+        html_content.append(f"""
+            <table style='width: 100%; border-collapse: collapse; margin: 10px;'>
+                <tr>
+                    <td style='width: 30%; text-align: center;'>
+                        <h3>Circuit {index + 1}</h3>
+                        {encoded_img}  <!-- Display the image -->
+                    </td>        
+                    <td style='padding: 10px;'>
+                        <table style='width: 100%; border-collapse: collapse;'>
+                            <tr>
+                                <td><strong>Hamiltonian:</strong></td><td>{row['hamiltonian']}</td>
+                            </tr>
+                            <tr>
+                                <td><strong>QASM Representation:</strong></td><td>{row['qasm_code']}</td>
+                            </tr>
+                            <tr>
+                                <td><strong>Trotter Decomposition:</strong></td><td>{row['trotter_code']}</td>
+                            </tr>
+                            <tr>
+                                <td><strong>Number of Qubits:</strong></td><td>{row['num_qubits']}</td>
+                            </tr>
+                            <tr>
+                                <td><strong>Trotter Order:</strong></td><td>{row['trotter_order']}</td>
+                            </tr>
+                            <tr>
+                                <td><strong>Timestamp:</strong></td><td>{row['timestamp']}</td>
+                            </tr>
+                        </table>
+                    </td>
+                </tr>
+            </table>
+        """)
+
+    return "".join(html_content)
 
 # Function to generate Hamiltonians
 def generate_hamiltonians(num_hamiltonians, selected_qubits, selected_order, write_to_hf, write_to_duckdb):
@@ -153,11 +203,11 @@ def generate_hamiltonians(num_hamiltonians, selected_qubits, selected_order, wri
         store_in_duckdb(results_table)
 
 # Function to load results from either DuckDB or Hugging Face dataset
-def load_results(load_from_hf_checkbox, load_from_duckdb_checkbox):
-    if load_from_hf_checkbox:
-        return load_from_hf_dataset()  # Load from HF dataset
-    if load_from_duckdb_checkbox:
-        return load_from_duckdb()  # Load from DuckDB
+def load_results(load_from_hf, load_from_duckdb1):
+    if load_from_hf:
+        return load_from_hf_dataset()
+    if load_from_duckdb1:
+        return load_from_duckdb()
 
 # Gradio app
 with gr.Blocks() as app:
@@ -170,39 +220,26 @@ with gr.Blocks() as app:
         order_choices = [1, 2, 3, 4, 5]
         selected_order = gr.Dropdown(label="Select Trotter order", choices=order_choices, value=1)
 
-        # Radio buttons for selecting either Hugging Face dataset or DuckDB
-        write_option = gr.Radio(label="Where do you want to store the data?", 
-                                choices=["Write to Hugging Face dataset", "Write to DuckDB"], 
-                                value="Write to Hugging Face dataset")
+        # Checkboxes for writing to HF dataset and DuckDB
+        write_to_hf = gr.Checkbox(label="Write to Hugging Face dataset", value=False)
+        write_to_duckdb = gr.Checkbox(label="Write to DuckDB", value=True)
 
         generate_button = gr.Button("Generate Hamiltonians")
         status = gr.Markdown("Click 'Generate Hamiltonians' to start the process.")
 
-        def update_status(num, qubits, order, write_option):
-            if write_option == "Write to Hugging Face dataset":
-                # Call function to write to Hugging Face dataset
-                generate_hamiltonians(num, qubits, order, write_to_hf=True, write_to_duckdb=False)
-            else:
-                # Call function to write to DuckDB
-                generate_hamiltonians(num, qubits, order, write_to_hf=False, write_to_duckdb=True)
+        def update_status(num, qubits, order, write_hf, write_duckdb):
+            generate_hamiltonians(num, qubits, order, write_hf, write_duckdb)
             return "Data stored as per selection."
 
-        generate_button.click(update_status, inputs=[num_hamiltonians, selected_qubits, selected_order, write_option], outputs=status)
+        generate_button.click(update_status, inputs=[num_hamiltonians, selected_qubits, selected_order, write_to_hf, write_to_duckdb], outputs=status)
 
     with gr.Tab("View Results"):
-        load_option = gr.Radio(label="Where do you want to load the data from?", 
-                               choices=["Load from Hugging Face dataset", "Load from DuckDB"], 
-                               value="Load from DuckDB")
+        load_from_hf = gr.Checkbox(label="Load from Hugging Face dataset", value=False)
+        load_from_duckdb1 = gr.Checkbox(label="Load from DuckDB", value=True)
 
         load_button = gr.Button("Load Results")
         output_display = gr.HTML()
 
-        def load_results(load_option):
-            if load_option == "Load from Hugging Face dataset":
-                return load_from_hf_dataset()
-            else:
-                return load_from_duckdb()
-
-        load_button.click(load_results, inputs=[load_option], outputs=output_display)
+        load_button.click(load_results, inputs=[load_from_hf, load_from_duckdb1], outputs=output_display)
 
-app.launch(share=True)
+app.launch()