3D Container Loading via Quantum-Classical Reinforcement Learning

3D bin packing optimization for container loading using
classical RL (PPO, A3C) and quantum-classical hybrid RL (Quantum PPO, Quantum A3C)
with VQE-inspired actor circuits and QAOA-inspired critic circuits

Overview

This project implements and compares four reinforcement learning agents for the 3D Container Loading Problem (a variant of the 3D Bin Packing Problem):

Agent	Type	Policy	Value
PPO	Classical RL	Neural network actor	Neural network critic
A3C	Classical RL	Neural network actor	Neural network critic
Quantum PPO	Quantum-Classical Hybrid	VQE variational circuit	QAOA variational circuit
Quantum A3C	Quantum-Classical Hybrid	VQE variational circuit	QAOA variational circuit

All four agents operate on the same HybridPackingEnv environment, which models a 3D container as a continuous space and uses the extreme-point method for feasible placement generation. This unified environment design enables a direct, controlled comparison between classical and quantum-enhanced decision-making.

The quantum contribution is the primary novel element of this work: replacing classical neural network policy and value heads with VQE-inspired and QAOA-inspired variational quantum circuits, implemented via PennyLane, to investigate whether quantum feature encoding offers advantages in combinatorial packing tasks.

Problem Statement

The 3D Container Loading Problem asks: given a set of boxes with known dimensions, how should they be arranged inside a fixed-volume container to maximize space utilization while satisfying physical placement constraints?

This is an NP-hard combinatorial optimization problem. Exact methods are computationally intractable for large instance sizes. Heuristic and metaheuristic approaches exist but do not learn from experience. Reinforcement learning offers a framework where an agent learns, through repeated interaction with a simulated environment, which placement decisions lead to higher fill rates.

This project extends the standard RL formulation by asking a further question:

Can variational quantum circuits, used as policy and value function approximators, offer competitive or superior performance compared to classical neural networks for this combinatorial optimization task?

Key Contributions

A unified 3D packing environment (HybridPackingEnv) with extreme-point placement, two-orientation support, and sparse reward shaping — shared identically across all four agents for fair comparison
Classical baselines — fully implemented PPO and A3C agents with multi-seed reproducibility and standardized training metrics
Quantum-classical hybrid agents — PPO and A3C variants where the actor is replaced by a VQE-inspired variational quantum circuit and the critic by a QAOA-inspired variational quantum circuit, implemented using PennyLane with GPU acceleration via lightning.gpu
A configurable quantum circuit architecture: qubit count (5, 10, 15, 20) and circuit depth (layers 1–4) are parameterized for ablation studies
Standardized evaluation protocol: convergence episode, learning curve variance, and sample efficiency (AUC) across 5 seeds

Algorithms

PPO — Proximal Policy Optimization

PPO is an on-policy actor-critic algorithm that uses a clipped surrogate objective to constrain policy updates, improving training stability. At each step, the agent selects among up to 10 candidate placement positions generated by the environment.

Network: 2-layer MLP (16 → 128 → 128) shared backbone, separate actor and critic heads
Clipping parameter: ε = 0.2
Discount factor: γ = 0.995
Value loss coefficient: 0.5
Update epochs per episode: 3

A3C — Asynchronous Advantage Actor-Critic

A3C extends the actor-critic framework with asynchronous parallel workers that independently interact with environment copies and push gradient updates to a shared global model. Both single-process (synchronous) and multi-process variants are implemented.

Network: identical architecture to PPO
Gradient clipping: max norm = 40
Entropy bonus coefficient: 0.01 (for exploration)
t-max (truncated backprop horizon): 20 steps
Supports use_multiprocess=True for full asynchronous training

Quantum PPO

Extends PPO by replacing the classical actor and critic networks with variational quantum circuits:

Actor — VQE-inspired circuit: Classical encoder (16 → n_qubits) feeds into an angle-embedded variational circuit with RY/RZ rotations and CNOT entangling layers. Output: Pauli-Z expectation values → softmax policy
Critic — QAOA-inspired circuit: IsingZZ problem Hamiltonian layer + RX mixer layer per QAOA round. Output: single scalar value estimate
Quantum device: pennylane.lightning.gpu (falls back to default.qubit if GPU unavailable)
Gradient method: adjoint differentiation
Configurable: N_QUBITS ∈ {5, 10, 15, 20}, N_LAYERS ∈ {1, 2, 3, 4}

Quantum A3C

Applies the same quantum circuit architecture (VQE actor + QAOA critic) within the A3C training framework. Combines the asynchronous advantage estimation of A3C with quantum policy representation.

Quantum-Classical Hybrid Architecture

Classical State (16-dim)
        │
        ▼
┌─────────────────────────────────────────────────────┐
│              CLASSICAL ENCODER                      │
│         Linear(16 → 32) → Tanh → Linear(32 → n_q)  │
└──────────────────────┬──────────────────────────────┘
                       │
          ┌────────────┴────────────┐
          ▼                         ▼
┌──────────────────┐      ┌──────────────────────┐
│   VQE ACTOR      │      │   QAOA CRITIC        │
│                  │      │                      │
│ RY angle embed   │      │ RY angle embed       │
│ RY + RZ per qubit│      │ IsingZZ (problem)    │
│ CNOT ring        │      │ RX mixer             │
│ × n_layers       │      │ × n_layers           │
│                  │      │                      │
│ <Z_i> → n_qubits │      │ <Z_0> → scalar       │
└────────┬─────────┘      └──────────┬───────────┘
         ▼                            ▼
┌──────────────────┐      ┌──────────────────────┐
│ actor_head       │      │ critic_head          │
│ Linear(n_q→10)   │      │ Linear(1→1)          │
│ → softmax policy │      │ → value estimate     │
└──────────────────┘      └──────────────────────┘

Repository Structure

3d-packing-quantum-classical-rl/
│
├── agents/                        # RL agent implementations
│   ├── ppo_agent.py               # Classical PPO
│   ├── a3c_agent.py               # Classical A3C (single + multi-process)
│   ├── quantum_ppo_agent.py       # Quantum-Classical PPO (VQE + QAOA)
│   └── quantum_a3c_agent.py       # Quantum-Classical A3C (VQE + QAOA)
│
├── data/                          # Input CSV datasets (not tracked by Git)
│   └── .gitkeep
│
├── outputs/                       # Training outputs: PNG visualizations, logs
│   └── .gitkeep
│
├── docs/                          # Extended documentation
│   ├── methodology.md             # Environment and algorithm design
│   ├── quantum_architecture.md    # Quantum circuit details
│   ├── limitations.md             # Known limitations
│   ├── future_work.md             # Planned extensions
│   ├── research_potential.md      # Academic framing
│   └── experimental_design.md    # Evaluation protocol
│
├── requirements.txt               # Python dependencies
├── LICENSE                        # MIT License
├── CITATION.cff                   # Machine-readable citation
├── CONTRIBUTING.md
├── CODE_OF_CONDUCT.md
├── CHANGELOG.md
└── README.md

Installation

# 1. Clone the repository
git clone https://github.com/MuratKarslioglu/3d-packing-quantum-classical-rl.git
cd 3d-packing-quantum-classical-rl

# 2. Create virtual environment
python -m venv venv

# Windows
venv\Scripts\activate
# macOS / Linux
source venv/bin/activate

# 3. Install dependencies
pip install -r requirements.txt

Dependencies:

Package	Purpose
`torch`	Neural networks, PPO/A3C training
`numpy`, `pandas`	Numerical computing, CSV loading
`matplotlib`	3D packing visualization
`pennylane`	Quantum circuit simulation
`pennylane-lightning`	GPU-accelerated quantum simulation

GPU Note: Quantum agents use pennylane-lightning[gpu] for lightning.gpu device. If a CUDA-capable GPU is unavailable, change qml.device("lightning.gpu", ...) to qml.device("default.qubit", ...) in the quantum agent files.

Usage

Prepare your data

Place your packing dataset CSV in the data/ folder and update the CSV_PATH variable at the top of each agent file:

CSV_PATH = "data/packing_dataset_1000boxes.csv"

Run Classical Agents

# PPO
python agents/ppo_agent.py

# A3C (single-process)
python agents/a3c_agent.py

Both scripts run a 5-seed experiment by default (seeds = [0, 1, 2, 3, 4], 100 episodes each) and print aggregated metrics at the end.

Run Quantum Agents

# Quantum PPO
python agents/quantum_ppo_agent.py

# Quantum A3C
python agents/quantum_a3c_agent.py

Quantum agents iterate over dataset sizes (400, 600, 800, 1000 boxes) and qubit counts (5, 10, 15, 20) automatically.

Configure Quantum Architecture

At the top of each quantum agent file:

N_QUBITS = 5      # Number of qubits (5, 10, 15, 20)
N_LAYERS = 2      # Circuit depth (1, 2, 3, 4)

Input Data Format

Each CSV file must contain the following columns:

Column	Type	Description
`Length (mm)`	float	Box length in millimeters
`Width (mm)`	float	Box width in millimeters
`Height (mm)`	float	Box height in millimeters
`Container L`	float	Container internal length (same for all rows)
`Container W`	float	Container internal width
`Container H`	float	Container internal height

Boxes are sorted by volume (descending) before training. Each dataset variant (400, 600, 800, 1000 boxes) should be a separate CSV file.

Output

Each training run produces:

Console logs per episode:

[EP 042] Fill %87.34 | Success %91.20 | Placed 912 | Unplaced 88 | Skip %8.80

Training metrics at end of run:

Convergence episode (≥99%): 67
Learning curve variance (last 50): 0.000423
Sample efficiency (AUC): 8821.43

3D visualization PNG — best episode result rendered with box size color coding (S/M/L), saved to the working directory

Environment Design

The HybridPackingEnv class implements a 3D continuous container space with the following design choices:

State vector (16 dimensions):

Index	Feature	Description
0	`vol_ratio`	Current box volume / container volume
1	`l_ratio`	Current box length / container length
2	`w_ratio`	Current box width / container width
3	`h_ratio`	Current box height / container height
4	`fill_ratio`	Used volume / container volume
5	`height_ratio`	Max stack height / container height
6	`ep_density`	Number of extreme points / 50
7–15	—	Reserved (zero-padded)

Placement strategy — Extreme Point Method: At each step, the environment generates up to 10 candidate positions from the current set of extreme points. Two orientations are considered per position (l×w×h and w×l×h). The agent selects among these candidates via its policy.

Sorting: Boxes are pre-sorted by volume (largest first) to improve packing density and reduce wasted space from early fragmentation.

Reward Function

r(t) = ΔV / Vc  −  0.02 × max(0, Δheight) / H

Where:

ΔV — volume of the placed box
Vc — total container volume
Δheight — increase in maximum stack height
H — container height

A terminal bonus of +100 is added when all boxes have been processed. A penalty of −0.1 is applied when a box cannot be placed at any candidate position (skip event).

Evaluation Metrics

All experiments use a 5-seed protocol (seeds 0–4) and report mean ± std:

Metric	Definition
Convergence Episode	First episode where fill rate ≥ 99% (or ≥ 99.9% of best observed)
Learning Curve Variance	`np.var(fill_history[-50:])` — stability of late-training performance
Sample Efficiency (AUC)	`np.trapz(fill_history)` — area under the learning curve

Limitations

The environment uses item selection ordering (volume-sorted), not arbitrary arrival order — real loading operations may not permit pre-sorting
Physical constraints (center of gravity, axle load, fragility stacking) are not enforced
Quantum simulation runs on classical hardware via PennyLane — results do not reflect true quantum hardware performance or noise characteristics
lightning.gpu requires a CUDA GPU; CPU-only execution with default.qubit is significantly slower for large qubit counts
The state vector uses only 7 of 16 dimensions; the remaining indices are zero-padded, leaving representational capacity unused
Multi-process A3C (use_multiprocess=True) may have platform-specific behavior on Windows

See docs/limitations.md for full discussion.

Future Work

Integration of physical constraints: fragility, weight limits, center of gravity
True quantum hardware execution via IBM Quantum or Amazon Braket
Rotation augmentation: 6 orientations per box instead of 2
Attention-based policy architectures for better spatial reasoning
Comparison with classical metaheuristics (GA, PSO, simulated annealing)
Real-world dataset validation against operational loading manifests

See docs/future_work.md for details.

Academic Extension Potential

This project sits at the intersection of three active research areas:

Combinatorial Optimization — 3D bin packing, container loading
Deep Reinforcement Learning — policy gradient methods, actor-critic architectures
Quantum Machine Learning — variational quantum circuits, quantum advantage in optimization

The core research question — whether VQE/QAOA-based policy and value approximators can compete with classical neural networks on a structured combinatorial task — is timely and largely unanswered in the literature. The controlled experimental design (identical environment, identical training protocol, four agents) makes this directly publishable with the addition of comparative results.

Potential target venues: Quantum Machine Intelligence (Springer), IEEE Transactions on Neural Networks and Learning Systems, Expert Systems with Applications, Computers & Operations Research.

See docs/research_potential.md for structured academic framing.

How to Cite

@software{karslioglu2026quantum_rl_packing,
  author    = {Karslioglu, Murat},
  title     = {3D Container Loading via Quantum-Classical Reinforcement Learning},
  year      = {2026},
  publisher = {GitHub},
  url       = {https://github.com/MuratKarslioglu/3d-packing-quantum-classical-rl}
}

A formal academic citation will be added upon publication.

License

This project is licensed under the MIT License. See LICENSE for full terms.

Kuantum-Klasik Pekiştirmeli Öğrenme ile 3D Konteyner Yükleme

PPO, A3C ve kuantum-klasik hibrit RL ajanları (Quantum PPO, Quantum A3C) kullanılarak
VQE ilhamlı aktör devreleri ve QAOA ilhamlı kritik devreleriyle 3D kutu paketleme optimizasyonu

İçindekiler

Genel Bakış
Problem Tanımı
Temel Katkılar
Algoritmalar
Kuantum-Klasik Hibrit Mimari
Depo Yapısı
Kurulum
Kullanım
Girdi Veri Formatı
Çıktılar
Ortam Tasarımı
Ödül Fonksiyonu
Değerlendirme Metrikleri
Sınırlılıklar
Gelecek Çalışmalar
Akademik Uzantı Potansiyeli
Atıf
Lisans

Genel Bakış

Bu proje, 3D Konteyner Yükleme Problemi için dört pekiştirmeli öğrenme ajanını uygular ve karşılaştırır:

Ajan	Tip	Politika	Değer
PPO	Klasik RL	Sinir ağı aktörü	Sinir ağı kritiği
A3C	Klasik RL	Sinir ağı aktörü	Sinir ağı kritiği
Quantum PPO	Kuantum-Klasik Hibrit	VQE varyasyonel devresi	QAOA varyasyonel devresi
Quantum A3C	Kuantum-Klasik Hibrit	VQE varyasyonel devresi	QAOA varyasyonel devresi

Dört ajan da aynı HybridPackingEnv ortamında çalışır. Bu tasarım, klasik ve kuantum geliştirilmiş karar verme arasında doğrudan ve kontrollü bir karşılaştırmaya olanak tanır.

Bu çalışmanın temel özgün katkısı: Klasik sinir ağı politika ve değer fonksiyonlarının, PennyLane ile uygulanan VQE ilhamlı ve QAOA ilhamlı varyasyonel kuantum devreleriyle değiştirilerek kombinatoryal paketleme görevlerinde kuantum özellik kodlamasının avantaj sunup sunmadığının araştırılmasıdır.

Problem Tanımı

3D Konteyner Yükleme Problemi şu soruyu sorar: Boyutları bilinen bir dizi kutu, fiziksel yerleştirme kısıtlarını karşılarken alan kullanımını maksimize edecek şekilde sabit hacimli bir konteynere nasıl yerleştirilmelidir?

Bu, büyük örnek boyutları için kesin yöntemlerin hesaplama açısından pratik olmadığı NP-zor bir kombinatoryal optimizasyon problemidir. Pekiştirmeli öğrenme, bir ajanın simüle edilmiş ortamla tekrarlanan etkileşimler yoluyla hangi yerleştirme kararlarının daha yüksek dolum oranlarına yol açtığını öğrendiği bir çerçeve sunar.

Bu proje şu soruyu ekleyerek standart RL formülasyonunu genişletir:

Politika ve değer fonksiyonu yaklaştırıcıları olarak kullanılan varyasyonel kuantum devreler, bu kombinatoryal optimizasyon görevi için klasik sinir ağlarıyla rekabet edebilir veya onlardan üstün performans gösterebilir mi?

Temel Katkılar

Tüm dört ajan genelinde özdeş olarak paylaşılan, aşırı nokta yerleşimi, iki yönlü destek ve seyrek ödül şekillendirmeli birleşik 3D paketleme ortamı (HybridPackingEnv)
Çok tohumlu tekrarlanabilirlik ve standartlaştırılmış eğitim metrikleriyle tam uygulanmış klasik referans noktaları — PPO ve A3C
PennyLane kullanılarak, GPU hızlandırmalı lightning.gpu ile uygulanan; aktörün VQE ilhamlı varyasyonel kuantum devresiyle, kritiğin QAOA ilhamlı varyasyonel kuantum devresiyle değiştirildiği kuantum-klasik hibrit ajanlar
Ablasyon çalışmaları için parametreleştirilmiş yapılandırılabilir kuantum devre mimarisi: kubit sayısı (5, 10, 15, 20) ve devre derinliği (1–4 katman)
5 tohum genelinde yakınsama bölümü, öğrenme eğrisi varyansı ve örnek verimliliği (AUC) ile standartlaştırılmış değerlendirme protokolü

Algoritmalar

PPO — Proximal Policy Optimization

PPO, eğitim kararlılığını artırmak için politika güncellemelerini kısıtlayan kırpılmış bir vekil hedef kullanan, ilke tabanlı bir aktör-kritik algoritmadır.

Ağ: 2 katmanlı MLP (16 → 128 → 128) paylaşımlı omurga, ayrı aktör ve kritik başlıkları
Kırpma parametresi: ε = 0.2 | İndirim faktörü: γ = 0.995

A3C — Asynchronous Advantage Actor-Critic

A3C, ortam kopyalarıyla bağımsız olarak etkileşime giren ve gradyan güncellemelerini paylaşılan bir global modele ileten eşzamansız paralel işçilerle aktör-kritik çerçevesini genişletir. Hem tek süreçli hem çok süreçli varyantlar uygulanmıştır.

Gradyan kırpma: maks. norm = 40 | Entropi bonusu: 0.01 | t-max: 20 adım

Quantum PPO

Klasik aktör ve kritik ağlarını varyasyonel kuantum devrelerle değiştirerek PPO'yu genişletir:

Aktör — VQE ilhamlı devre: Klasik kodlayıcı (16 → n_qubit) → açı gömülü varyasyonel devre (RY/RZ rotasyonları + CNOT dolaşma katmanları) → Pauli-Z beklenti değerleri → softmax politikası
Kritik — QAOA ilhamlı devre: IsingZZ problem Hamiltonyeni katmanı + RX karıştırıcı katmanı → skaler değer tahmini
Gradyan yöntemi: eşlenik türevleme | Yapılandırılabilir: N_QUBITS ∈ {5,10,15,20}, N_LAYERS ∈ {1,2,3,4}

Quantum A3C

Aynı kuantum devre mimarisini (VQE aktör + QAOA kritik) A3C eğitim çerçevesinde uygular.

Kuantum-Klasik Hibrit Mimari

Klasik Durum (16 boyut)
        │
        ▼
┌────────────────────────────────────────────────────┐
│              KLASİK KODLAYICI                      │
│     Linear(16→32) → Tanh → Linear(32→n_qubit)      │
└──────────────────────┬─────────────────────────────┘
                       │
          ┌────────────┴────────────┐
          ▼                         ▼
┌──────────────────┐      ┌──────────────────────┐
│   VQE AKTÖR      │      │   QAOA KRİTİK        │
│                  │      │                      │
│ RY açı gömme     │      │ RY açı gömme         │
│ RY + RZ / kubit  │      │ IsingZZ (problem)    │
│ CNOT halkası     │      │ RX karıştırıcı       │
│ × n_katman       │      │ × n_katman           │
│                  │      │                      │
│ <Z_i>→n_qubit    │      │ <Z_0> → skaler       │
└────────┬─────────┘      └──────────┬───────────┘
         ▼                            ▼
┌──────────────────┐      ┌──────────────────────┐
│ aktör başlığı    │      │ kritik başlığı       │
│ Linear(n_q→10)   │      │ Linear(1→1)          │
│ → softmax poli.  │      │ → değer tahmini      │
└──────────────────┘      └──────────────────────┘

Depo Yapısı

3d-packing-quantum-classical-rl/
│
├── agents/                        # RL ajan uygulamaları
│   ├── ppo_agent.py               # Klasik PPO
│   ├── a3c_agent.py               # Klasik A3C
│   ├── quantum_ppo_agent.py       # Kuantum-Klasik PPO (VQE + QAOA)
│   └── quantum_a3c_agent.py       # Kuantum-Klasik A3C (VQE + QAOA)
│
├── data/                          # Girdi CSV veri setleri (Git izlemez)
├── outputs/                       # Eğitim çıktıları: PNG görseller
├── docs/                          # Genişletilmiş belgeler
├── requirements.txt
├── LICENSE
└── README.md

Kurulum

git clone https://github.com/MuratKarslioglu/3d-packing-quantum-classical-rl.git
cd 3d-packing-quantum-classical-rl
python -m venv venv
venv\Scripts\activate        # Windows
pip install -r requirements.txt

GPU Notu: Kuantum ajanlar lightning.gpu kullanır. CUDA GPU yoksa ajan dosyalarındaki qml.device("lightning.gpu", ...) satırını qml.device("default.qubit", ...) olarak değiştirin.

Kullanım

# Klasik ajanlar
python agents/ppo_agent.py
python agents/a3c_agent.py

# Kuantum ajanlar
python agents/quantum_ppo_agent.py
python agents/quantum_a3c_agent.py

Tüm scriptler varsayılan olarak 5 tohumlu deney çalıştırır (seed 0–4, 100 bölüm).

Girdi Veri Formatı

CSV dosyası şu sütunları içermelidir:

Sütun	Açıklama
`Length (mm)`	Kutu uzunluğu (mm)
`Width (mm)`	Kutu genişliği (mm)
`Height (mm)`	Kutu yüksekliği (mm)
`Container L`	Konteyner iç uzunluğu
`Container W`	Konteyner iç genişliği
`Container H`	Konteyner iç yüksekliği

Ortam Tasarımı

Durum vektörü (16 boyut): Mevcut kutu boyut oranları (0–3), dolum oranı (4), yükseklik oranı (5), aşırı nokta yoğunluğu (6), geri kalanlar sıfır dolgulu.

Yerleştirme stratejisi — Aşırı Nokta Yöntemi: Her adımda ortam, mevcut aşırı noktalardan en fazla 10 aday konum üretir. Her konum için 2 yönlendirme (l×g×y ve g×l×y) denenir. Ajan politikası aracılığıyla adaylar arasından seçim yapar.

Ödül Fonksiyonu

r(t) = ΔV / Vc  −  0.02 × max(0, Δyükseklik) / H

Tüm kutular işlendiğinde +100 terminal bonusu eklenir. Kutu hiçbir konuma yerleştirilemediğinde −0.1 cezası uygulanır.

Değerlendirme Metrikleri

5 tohumlu protokol (seed 0–4), ortalama ± std olarak raporlanır:

Metrik	Tanım
Yakınsama Bölümü	Dolum oranının ≥%99'a ulaştığı ilk bölüm
Öğrenme Eğrisi Varyansı	Son 50 bölümün varyansı — geç eğitim kararlılığı
Örnek Verimliliği (AUC)	Öğrenme eğrisinin altındaki alan

Sınırlılıklar

Ortam hacim sıralamalı sıra kullanır; gerçek operasyonlarda ön sıralama mümkün olmayabilir
Fiziksel kısıtlar (ağırlık merkezi, aks yükü, kırılganlık) uygulanmamaktadır
Kuantum simülasyonu klasik donanımda çalışır; sonuçlar gerçek kuantum donanım performansını yansıtmaz
Durum vektörünün 9 boyutu kullanılmamaktadır

Gelecek Çalışmalar

Fiziksel kısıtların entegrasyonu
IBM Quantum veya Amazon Braket üzerinde gerçek kuantum donanım yürütmesi
2 yerine 6 yönlendirme desteği
Dikkat tabanlı politika mimarileri
Klasik metasezgisellerle (GA, PSO) karşılaştırma
Gerçek dünya yükleme manifestolarıyla doğrulama

Akademik Uzantı Potansiyeli

Bu proje üç aktif araştırma alanının kesişiminde yer almaktadır: Kombinatoryal Optimizasyon, Derin Pekiştirmeli Öğrenme ve Kuantum Makine Öğrenmesi.

VQE/QAOA tabanlı politika ve değer yaklaştırıcılarının yapılandırılmış kombinatoryal bir görevde klasik sinir ağlarıyla rekabet edip edemeyeceği sorusu büyük ölçüde yanıtsız kalmaktadır. Kontrollü deney tasarımı karşılaştırmalı sonuçların eklenmesiyle doğrudan yayınlanabilir niteliktedir.

Hedef dergiler: Quantum Machine Intelligence (Springer), IEEE TNNLS, Expert Systems with Applications, Computers & Operations Research.

Atıf

@software{karslioglu2026quantum_rl_packing,
  author    = {Karslioglu, Murat},
  title     = {3D Container Loading via Quantum-Classical Reinforcement Learning},
  year      = {2026},
  publisher = {GitHub},
  url       = {https://github.com/MuratKarslioglu/3d-packing-quantum-classical-rl}
}

Lisans

MIT Lisansı — Tam koşullar için LICENSE dosyasına bakınız.

Name		Name	Last commit message	Last commit date
Latest commit History 1 Commit
.github		.github
agents		agents
data		data
docs		docs
outputs		outputs
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
CITATION.cff		CITATION.cff
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
requirements.txt		requirements.txt

Folders and files

Latest commit

History

Repository files navigation

3D Container Loading via Quantum-Classical Reinforcement Learning

Table of Contents

Overview

Problem Statement

Key Contributions

Algorithms

PPO — Proximal Policy Optimization

A3C — Asynchronous Advantage Actor-Critic

Quantum PPO

Quantum A3C

Quantum-Classical Hybrid Architecture

Repository Structure

Installation

Usage

Prepare your data

Run Classical Agents

Run Quantum Agents

Configure Quantum Architecture

Input Data Format

Output

Environment Design

Reward Function

Evaluation Metrics

Limitations

Future Work

Academic Extension Potential

How to Cite

License

Kuantum-Klasik Pekiştirmeli Öğrenme ile 3D Konteyner Yükleme

İçindekiler

Genel Bakış

Problem Tanımı

Temel Katkılar

Algoritmalar

PPO — Proximal Policy Optimization

A3C — Asynchronous Advantage Actor-Critic

Quantum PPO

Quantum A3C

Kuantum-Klasik Hibrit Mimari

Depo Yapısı

Kurulum

Kullanım

Girdi Veri Formatı

Ortam Tasarımı

Ödül Fonksiyonu

Değerlendirme Metrikleri

Sınırlılıklar

Gelecek Çalışmalar

Akademik Uzantı Potansiyeli

Atıf

Lisans

About

Topics

Resources

Code of conduct

Contributing

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages