First commit

Dockerfile

@@ -0,0 +1,93 @@
+# Dockerfile customized for deployment on HuggingFace Spaces platform
+
+# -- The Dockerfile has been tailored specifically for use on HuggingFace.
+# -- It implies that certain modifications or optimizations have been made with HuggingFace's environment in mind.
+# -- It uses "HuggingFace Spaces" to be more specific about the target platform.
+
+# FROM pytorch/pytorch:2.2.1-cuda12.1-cudnn8-devel
+FROM pytorch/pytorch:2.4.0-cuda12.1-cudnn9-devel 
+# FOR HF
+
+USER root
+
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && apt-get install -y \
+    git \
+    cmake \
+    python3 \
+    python3-pip \
+    python3-venv \
+    python3-dev \
+    python3-numpy \
+    gcc \
+    build-essential \
+    gfortran \
+    wget \
+    curl \
+    pkg-config \
+    software-properties-common \
+    zip \
+    && apt-get clean && rm -rf /tmp/* /var/tmp/*
+
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive \
+    apt-get install -y python3.10 python3-pip
+
+RUN apt-get install -y libopenblas-base libopenmpi-dev
+
+ENV TZ=Asia/Dubai
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+
+
+RUN useradd -m -u 1000 user
+    
+RUN apt-get update && apt-get install -y sudo && \
+echo 'user ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
+
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+RUN mkdir $HOME/app
+RUN mkdir $HOME/app/test_images
+
+# WORKDIR $HOME/app
+
+RUN chown -R user:user $HOME/app   
+
+USER user
+WORKDIR $HOME/app
+
+RUN python -m  pip install  qwen-vl-utils 
+RUN python -m pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu122 mlc-ai-nightly-cu122
+#python -m pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cpu mlc-ai-nightly-cpu
+
+RUN  python3 -m pip install chromadb db-sqlite3 auto-gptq exllama sqlalchemy  
+WORKDIR $HOME/app
+RUN git clone https://github.com/casper-hansen/AutoAWQ  
+WORKDIR $HOME/app/AutoAWQ/ 
+RUN python3 -m pip  install -e .
+WORKDIR $HOME/app
+# ENV FLASH_ATTENTION_FORCE_BUILD=TRUE
+RUN python -m pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
+RUN python -m pip install  accelerate diffusers datasets timm flash-attn==2.6.1 gradio
+
+RUN  python3 -m pip install --no-deps optimum  
+RUN  python3 -m pip install --no-deps autoawq>=0.1.8 
+
+#This seems to be a must : Intel Extension for PyTorch 2.4 needs to work with PyTorch 2.4.*, but PyTorch 2.2.2 is
+RUN python -m pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
+RUN  python3 -m pip install -U accelerate 
+RUN  python3 -m pip install -U git+https://github.com/huggingface/transformers
+
+WORKDIR $HOME/app
+COPY --chown=user:user app.py .
+COPY --chown=user:user test_images /home/user/app/test_images
+
+ENV PYTHONUNBUFFERED=1 	GRADIO_ALLOW_FLAGGING=never 	GRADIO_NUM_PORTS=1 	GRADIO_SERVER_NAME=0.0.0.0     GRADIO_SERVER_PORT=7860 	SYSTEM=spaces
+RUN python3 -m pip  install pennylane sympy pennylane-qiskit duckdb
+WORKDIR $HOME/app
+
+EXPOSE 8097 7842 8501 8000 6666 7860
+
+CMD ["python", "app.py"]

README.md

@@ -8,4 +8,4 @@ pinned: false
 short_description: 'An open-source dataset designed to assess whether solutions '
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+

app.py

@@ -0,0 +1,131 @@
+import numpy as np
+import random
+import io
+import duckdb
+import gradio as gr
+import math
+from datetime import datetime
+import PIL
+import matplotlib.pyplot as plt
+from PIL import Image
+import pennylane as qml
+
+# Hugging Face and DuckDB function placeholders
+def store_in_hf_dataset(data):
+    # Implement storing data in the Hugging Face dataset
+    pass
+
+def load_from_hf_dataset():
+    # Implement loading data from the Hugging Face dataset
+    return []
+
+# Store image in bytes for DuckDB
+def pil_image_to_bytes(image):
+    img_byte_arr = io.BytesIO()
+    image.save(img_byte_arr, format='PNG')
+    return img_byte_arr.getvalue()
+
+# Function to generate a random Hamiltonian
+def generate_random_hamiltonian(num_qubits):
+    terms = []
+    for _ in range(random.randint(1, 5)):
+        coeff = round(random.uniform(-1, 1), 2)
+        pauli_ops = [random.choice(['I', 'X', 'Y', 'Z']) for _ in range(num_qubits)]
+        term = f"{coeff} * {' '.join(pauli_ops)}"
+        terms.append(term)
+    return " + ".join(terms)
+
+# Store data in DuckDB
+def store_in_duckdb(data, db_file='quantum_hamiltonians.duckdb'):
+    conn = duckdb.connect(database=db_file)
+    conn.execute("""CREATE TABLE IF NOT EXISTS hamiltonians (
+        id INTEGER,
+        plot BLOB,
+        hamiltonian VARCHAR,
+        qasm_code VARCHAR,
+        trotter_code VARCHAR,
+        num_qubits INTEGER,
+        trotter_order INTEGER,
+        timestamp TIMESTAMP
+    )""")
+    conn.executemany("""INSERT INTO hamiltonians (id, plot, hamiltonian, qasm_code, trotter_code, num_qubits, trotter_order, timestamp)
+                        VALUES (?, ?, ?, ?, ?, ?, ?, ?)""", data)
+    conn.close()
+
+# Load results from DuckDB
+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
+
+# Function to generate Hamiltonians
+def generate_hamiltonians(num_hamiltonians, selected_qubits, selected_order, write_to_hf, write_to_duckdb):
+    results_table = []
+    timestamp = datetime.now()
+
+    for i in range(num_hamiltonians):
+        num_qubits = random.choice(selected_qubits)
+        order = selected_order
+        hamiltonian = generate_random_hamiltonian(num_qubits)
+        qasm_code = hamiltonian_to_qasm(hamiltonian, num_qubits)
+        trotter_code = trotter_decomposition(hamiltonian, order)
+
+        # Create a dummy plot (replace with actual plot creation logic)
+        fig, ax = plt.subplots()
+        ax.plot([0, 1], [0, 1])
+        circuit_plot_image = buffer_plot_and_get(fig)
+        circuit_plot_bytes = pil_image_to_bytes(circuit_plot_image)
+
+        # Append data to results table
+        results_table.append((i + 1, circuit_plot_bytes, hamiltonian, qasm_code, trotter_code, num_qubits, order, timestamp))
+
+    # Write data to Hugging Face dataset if selected
+    if write_to_hf:
+        store_in_hf_dataset(results_table)
+    
+    # Write data to DuckDB if selected
+    if write_to_duckdb:
+        store_in_duckdb(results_table)
+
+# Function to load results from either DuckDB or Hugging Face dataset
+def load_results(load_from_hf, load_from_duckdb):
+    if load_from_hf:
+        return load_from_hf_dataset()  # Load from HF dataset
+    if load_from_duckdb:
+        return load_from_duckdb()  # Load from DuckDB
+
+# Gradio app
+with gr.Blocks() as app:
+    gr.Markdown("# Quantum Hamiltonian Generator")
+    
+    with gr.Tab("Generate Hamiltonians"):
+        num_hamiltonians = gr.Dropdown(label="Select number of Hamiltonians to generate", choices=[1, 10, 20, 100], value=20)
+        qubit_choices = [1, 2, 3, 4, 5, 6]
+        selected_qubits = gr.CheckboxGroup(label="Select number of qubits", choices=qubit_choices, value=[1])
+        order_choices = [1, 2, 3, 4, 5]
+        selected_order = gr.Dropdown(label="Select Trotter order", choices=order_choices, value=1)
+
+        # 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_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_to_hf, write_to_duckdb], outputs=status)
+
+    with gr.Tab("View Results"):
+        load_from_hf = gr.Checkbox(label="Load from Hugging Face dataset", value=False)
+        load_from_duckdb = gr.Checkbox(label="Load from DuckDB", value=True)
+
+        load_button = gr.Button("Load Results")
+        output_display = gr.HTML()
+
+        load_button.click(load_results, inputs=[load_from_hf, load_from_duckdb], outputs=output_display)
+
+app.launch()

build.bat

@@ -0,0 +1,2 @@
+docker build -t hf-docker .
+

run-d.bat

@@ -0,0 +1 @@
+docker run --gpus all --rm -it --shm-size=8gb --memory="16g" --env="DISPLAY" -p 8077:7842 -p 7860:7860  -p 8501:8501 -v %cd%:/home/user/app -v %cd%:/home/user/sharedfolder -v %cd%/.cache:/home/user/.cache  hf-docker:latest bash