diff --git a/linear_function_10qL.json b/linear_function_10qL.json new file mode 100644 index 0000000000000000000000000000000000000000..bb16c41e5ea632135c70d54362a18dba7b34485a --- /dev/null +++ b/linear_function_10qL.json @@ -0,0 +1,198 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 10, + "difficulty": 1024, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 6, + 7 + ] + ], + [ + "CX", + [ + 7, + 6 + ] + ], + [ + "CX", + [ + 7, + 8 + ] + ], + [ + "CX", + [ + 8, + 7 + ] + ], + [ + "CX", + [ + 8, + 9 + ] + ], + [ + "CX", + [ + 9, + 8 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.1, + "n_layers_cnots": 0.05, + "n_layers": 0.05, + "n_gates": 0.1 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_10qL.pt b/linear_function_10qL.pt new file mode 100644 index 0000000000000000000000000000000000000000..f6db538a4c707bda10b9ff6cf409c566bafad3a7 --- /dev/null +++ b/linear_function_10qL.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:68cce765ca81658eeafdf8391891bfd3f0b9abb9dcc2182033b29125d94712bf +size 755085 diff --git a/linear_function_2qL.json b/linear_function_2qL.json new file mode 100644 index 0000000000000000000000000000000000000000..8980f65df0701390095abf68f19d98e2c7fbf8e7 --- /dev/null +++ b/linear_function_2qL.json @@ -0,0 +1,86 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 2, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ] + ], + "depth_slope": 2, + "max_depth": 128, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 256, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_2qL.pt b/linear_function_2qL.pt new file mode 100644 index 0000000000000000000000000000000000000000..00dd7dcaa0d54e67d35dc137de2562c75654c718 --- /dev/null +++ b/linear_function_2qL.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2a893ff70b2498178d3ecc3aa77e8d8eb38e0298e600d8ccc6cf7c85e3a04a9e +size 542029 diff --git a/linear_function_3qL.json b/linear_function_3qL.json new file mode 100644 index 0000000000000000000000000000000000000000..accbc3e05c65227c1291ed1a3c2b5b61cd04bf37 --- /dev/null +++ b/linear_function_3qL.json @@ -0,0 +1,100 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 3, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 2 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 0 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ] + ], + "depth_slope": 2, + "max_depth": 128, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 256, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_3qL.pt b/linear_function_3qL.pt new file mode 100644 index 0000000000000000000000000000000000000000..0ac441e0f01792e76f65276132398c3dae499683 --- /dev/null +++ b/linear_function_3qL.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d3eb3e90b4d4e185a23cc6b77e091597fcb2e09ff3fc186adef31a5f79109faa +size 554317 diff --git a/linear_function_4qL.json b/linear_function_4qL.json new file mode 100644 index 0000000000000000000000000000000000000000..3d7e86d325b0136ad17fac3b9e75e14f1ac0ab17 --- /dev/null +++ b/linear_function_4qL.json @@ -0,0 +1,114 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 4, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 0, + 3 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 0 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ] + ], + "depth_slope": 2, + "max_depth": 128, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 256, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_4qL.pt b/linear_function_4qL.pt new file mode 100644 index 0000000000000000000000000000000000000000..04dcb4d479f1835f647f4720b0d3bef2e1c80593 --- /dev/null +++ b/linear_function_4qL.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6529325c43fab94ab1356197d2908ca5ed6fa5708e883ae51d3a273f236b962c +size 570701 diff --git a/linear_function_4qY.json b/linear_function_4qY.json new file mode 100644 index 0000000000000000000000000000000000000000..6f746911f491af9bc396a613c4bebe46721a6e32 --- /dev/null +++ b/linear_function_4qY.json @@ -0,0 +1,114 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 4, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 3 + ] + ], + [ + "CX", + [ + 1, + 3 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 0 + ] + ], + [ + "CX", + [ + 3, + 1 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ] + ], + "depth_slope": 2, + "max_depth": 128, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 256, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_4qY.pt b/linear_function_4qY.pt new file mode 100644 index 0000000000000000000000000000000000000000..b0bc71d558ca16989b0bc3488dae81e591dd3da2 --- /dev/null +++ b/linear_function_4qY.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:641fc0aed479190b7e8645a32e4744fa4d215dbad33fd2833358cf2db922c04a +size 570701 diff --git a/linear_function_5qL.json b/linear_function_5qL.json new file mode 100644 index 0000000000000000000000000000000000000000..fb20cbed300638d0ca162a16f20606c8781a2ccf --- /dev/null +++ b/linear_function_5qL.json @@ -0,0 +1,128 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 5, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ] + ], + "depth_slope": 2, + "max_depth": 128, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 256, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_5qL.pt b/linear_function_5qL.pt new file mode 100644 index 0000000000000000000000000000000000000000..a9db3fd0adeb99c0985d19822dca77bcb89fd318 --- /dev/null +++ b/linear_function_5qL.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a15f2ae12ca1ae8e62e23658ae4d3335f3677dffe444805f5453eb05e8bef5f4 +size 591181 diff --git a/linear_function_5qT.json b/linear_function_5qT.json new file mode 100644 index 0000000000000000000000000000000000000000..571cd5c94c6e1a8f028a80f17f67d99641391500 --- /dev/null +++ b/linear_function_5qT.json @@ -0,0 +1,128 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 5, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 2 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 0 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ] + ], + "depth_slope": 2, + "max_depth": 128, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 256, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_5qT.pt b/linear_function_5qT.pt new file mode 100644 index 0000000000000000000000000000000000000000..cac0a945a8976e670fb67e37f090ffee45d55617 --- /dev/null +++ b/linear_function_5qT.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0f5304331fc9635b64ae8b90cbf9ae4c7f21da3d0c6a0c282a045d08808fbfcd +size 591181 diff --git a/linear_function_6qL.json b/linear_function_6qL.json new file mode 100644 index 0000000000000000000000000000000000000000..fbb93133b9f20a6bd416634e37cc53534b3066b2 --- /dev/null +++ b/linear_function_6qL.json @@ -0,0 +1,142 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 6, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ] + ], + "depth_slope": 2, + "max_depth": 256, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 512, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_6qL.pt b/linear_function_6qL.pt new file mode 100644 index 0000000000000000000000000000000000000000..0bf9d05e8065687702eb2c62971c736e85ea5bb0 --- /dev/null +++ b/linear_function_6qL.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c11119a261c003e60298c3102880a9f7f5befd6ad99b3a1ffa0870ca603e3b9 +size 615757 diff --git a/linear_function_6qT.json b/linear_function_6qT.json new file mode 100644 index 0000000000000000000000000000000000000000..c6f30f9d9299f5f457da7828b206a27c483f67c3 --- /dev/null +++ b/linear_function_6qT.json @@ -0,0 +1,142 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 6, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 2 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 0 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ] + ], + "depth_slope": 2, + "max_depth": 256, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 512, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_6qT.pt b/linear_function_6qT.pt new file mode 100644 index 0000000000000000000000000000000000000000..ee73e9446d39e6c6d4bba4fac54cc906e1eddf6d --- /dev/null +++ b/linear_function_6qT.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:40066c82b0f857db29b76f194b6978078b1c2bc47dc7182ea794f919fbe58c69 +size 615757 diff --git a/linear_function_6qY.json b/linear_function_6qY.json new file mode 100644 index 0000000000000000000000000000000000000000..4fbf334b208fe9899e91830564d7c876753482ba --- /dev/null +++ b/linear_function_6qY.json @@ -0,0 +1,142 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 6, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 3 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 1 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ] + ], + "depth_slope": 2, + "max_depth": 256, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 512, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_6qY.pt b/linear_function_6qY.pt new file mode 100644 index 0000000000000000000000000000000000000000..b204e49c2c9313dd3fe6af0ecea4cde47fd0a0f3 --- /dev/null +++ b/linear_function_6qY.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b4a10dc6c20f84bf9b82a2cdb7a224ec512d99d56d75d4b4880b82c0b12dcec +size 615757 diff --git a/linear_function_7qF.json b/linear_function_7qF.json new file mode 100644 index 0000000000000000000000000000000000000000..f072b1ecdbb995f8fbc5de300112803d36238c93 --- /dev/null +++ b/linear_function_7qF.json @@ -0,0 +1,156 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 7, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 3 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 1 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ] + ], + "depth_slope": 2, + "max_depth": 256, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 512, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_7qF.pt b/linear_function_7qF.pt new file mode 100644 index 0000000000000000000000000000000000000000..0c0dca89fc2238ec334d3c9e335fc73b1d53a8a1 --- /dev/null +++ b/linear_function_7qF.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:12f87af007dc3ee4c3e6dd2198dd2e1def57a638c790676557bfe262ba5d5019 +size 644429 diff --git a/linear_function_7qH.json b/linear_function_7qH.json new file mode 100644 index 0000000000000000000000000000000000000000..dce2609406176829bb0256ef1217b29474ab22da --- /dev/null +++ b/linear_function_7qH.json @@ -0,0 +1,156 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 7, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 2 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 0 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 4, + 6 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 6, + 4 + ] + ] + ], + "depth_slope": 2, + "max_depth": 256, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 512, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_7qH.pt b/linear_function_7qH.pt new file mode 100644 index 0000000000000000000000000000000000000000..e899b747fb93b5d1aab6b471eaef3eec6c5d683b --- /dev/null +++ b/linear_function_7qH.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6b8112b7aa3e6c2c65cf292018b0d3c30d38685a34ca3ed7e3645491c22c1216 +size 644429 diff --git a/linear_function_7qL.json b/linear_function_7qL.json new file mode 100644 index 0000000000000000000000000000000000000000..e7d69721f1fef44985eb4c6e2693a8e8c328907a --- /dev/null +++ b/linear_function_7qL.json @@ -0,0 +1,156 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 7, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 4 + ] + ], + [ + "CX", + [ + 3, + 6 + ] + ], + [ + "CX", + [ + 4, + 2 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 3 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ] + ], + "depth_slope": 2, + "max_depth": 256, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 512, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_7qL.pt b/linear_function_7qL.pt new file mode 100644 index 0000000000000000000000000000000000000000..285b666f9201738a0cc6c0627638c8284daf84ab --- /dev/null +++ b/linear_function_7qL.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b3d1406d80a7b7e90905b096a58eac4ab1189de0d1fc2ab332aab2aed118bd80 +size 644429 diff --git a/linear_function_7qT.json b/linear_function_7qT.json new file mode 100644 index 0000000000000000000000000000000000000000..4866409217f8d86e2687cf4749dd6ddcac905053 --- /dev/null +++ b/linear_function_7qT.json @@ -0,0 +1,156 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 7, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 2 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 0 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ] + ], + "depth_slope": 2, + "max_depth": 256, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 512, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_7qT.pt b/linear_function_7qT.pt new file mode 100644 index 0000000000000000000000000000000000000000..cf253824584960db12b6ace4be4c2c2ae0778b31 --- /dev/null +++ b/linear_function_7qT.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd0233b1c6be8f029c13339cb1ae06fad9010f19297d9ca7e8784ffc236fde15 +size 644429 diff --git a/linear_function_7qY.json b/linear_function_7qY.json new file mode 100644 index 0000000000000000000000000000000000000000..48e38aa374da2ec1355bc86d79ffde9ca723ee58 --- /dev/null +++ b/linear_function_7qY.json @@ -0,0 +1,156 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 7, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 2, + 5 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 5, + 2 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ] + ], + "depth_slope": 2, + "max_depth": 256, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 512, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_7qY.pt b/linear_function_7qY.pt new file mode 100644 index 0000000000000000000000000000000000000000..b5cfc9aa2563e1fec095353cfee49df22c30ba9f --- /dev/null +++ b/linear_function_7qY.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a144bdcad6ad121c506ca7adc0c729abed08d0327b9b02bac1c0873cd1d077e3 +size 644429 diff --git a/linear_function_8qF.json b/linear_function_8qF.json new file mode 100644 index 0000000000000000000000000000000000000000..a63db0bac750be91acb536a5c2abba20d1f995ea --- /dev/null +++ b/linear_function_8qF.json @@ -0,0 +1,170 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 8, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 3 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 1 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 6, + 7 + ] + ], + [ + "CX", + [ + 7, + 6 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_8qF.pt b/linear_function_8qF.pt new file mode 100644 index 0000000000000000000000000000000000000000..f677e396e6562910adfd64570f9bfa355b4ecc60 --- /dev/null +++ b/linear_function_8qF.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bf4f9305e9ea527dddfc237596ba641e3abf6fb1ecaed7137a13b1e9ff10082c +size 677197 diff --git a/linear_function_8qJ.json b/linear_function_8qJ.json new file mode 100644 index 0000000000000000000000000000000000000000..bfda27fda41e57faf679f52ef0acf056641512f6 --- /dev/null +++ b/linear_function_8qJ.json @@ -0,0 +1,170 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 8, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 2 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 0 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 4, + 6 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 6, + 4 + ] + ], + [ + "CX", + [ + 6, + 7 + ] + ], + [ + "CX", + [ + 7, + 6 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_8qJ.pt b/linear_function_8qJ.pt new file mode 100644 index 0000000000000000000000000000000000000000..46eaefcaa89e6db854247145bb9e610ed653a0d5 --- /dev/null +++ b/linear_function_8qJ.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5287fbaad86868dadad48a41de3455a9df789b94a8c28d1e82e88f02abc797fe +size 677197 diff --git a/linear_function_8qL.json b/linear_function_8qL.json new file mode 100644 index 0000000000000000000000000000000000000000..e699627f37ee70e6be0891c78e3ec719875a0b18 --- /dev/null +++ b/linear_function_8qL.json @@ -0,0 +1,170 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 8, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 3 + ] + ], + [ + "CX", + [ + 2, + 4 + ] + ], + [ + "CX", + [ + 3, + 1 + ] + ], + [ + "CX", + [ + 3, + 5 + ] + ], + [ + "CX", + [ + 4, + 2 + ] + ], + [ + "CX", + [ + 4, + 7 + ] + ], + [ + "CX", + [ + 5, + 3 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 6, + 7 + ] + ], + [ + "CX", + [ + 7, + 4 + ] + ], + [ + "CX", + [ + 7, + 6 + ] + ] + ], + "depth_slope": 2, + "max_depth": 256, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 512, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_8qL.pt b/linear_function_8qL.pt new file mode 100644 index 0000000000000000000000000000000000000000..98beb7e250ac8af8e0598027472abd03bb2321d5 --- /dev/null +++ b/linear_function_8qL.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a8d1e8219a25343644c1afa029fb708edfa2ca3ba4a4ed96afb22a2548c0061a +size 677197 diff --git a/linear_function_8qT1.json b/linear_function_8qT1.json new file mode 100644 index 0000000000000000000000000000000000000000..1d282e3bbcece285d1d466ceaa6865e0e4eff8c4 --- /dev/null +++ b/linear_function_8qT1.json @@ -0,0 +1,170 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 8, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 2 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 0 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 5 + ] + ], + [ + "CX", + [ + 4, + 7 + ] + ], + [ + "CX", + [ + 5, + 3 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 6, + 7 + ] + ], + [ + "CX", + [ + 7, + 4 + ] + ], + [ + "CX", + [ + 7, + 6 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_8qT1.pt b/linear_function_8qT1.pt new file mode 100644 index 0000000000000000000000000000000000000000..d035b1835cf965116d092cfc934ab02e753fb731 --- /dev/null +++ b/linear_function_8qT1.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d28c610a64761f8adaebffafa7abb099edb3fd65e210f2e5aaf6cf0ff35d2e11 +size 677197 diff --git a/linear_function_8qT2.json b/linear_function_8qT2.json new file mode 100644 index 0000000000000000000000000000000000000000..4e558fd5ba71043cca756cc04b052052810d0bf5 --- /dev/null +++ b/linear_function_8qT2.json @@ -0,0 +1,170 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 8, + "difficulty": 1024, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 3, + 6 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 6, + 3 + ] + ], + [ + "CX", + [ + 6, + 7 + ] + ], + [ + "CX", + [ + 7, + 6 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.05, + "n_layers_cnots": 0.05, + "n_layers": 0.05, + "n_gates": 0.05 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} diff --git a/linear_function_8qT2.pt b/linear_function_8qT2.pt new file mode 100644 index 0000000000000000000000000000000000000000..dbc3a362573607857971e34ec53644e74922da8b --- /dev/null +++ b/linear_function_8qT2.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:861ff5fd4a628dc1ec6f53ead274cfc15462f44ffe73317c98bc2049fc46c16f +size 677197 diff --git a/linear_function_8qY.json b/linear_function_8qY.json new file mode 100644 index 0000000000000000000000000000000000000000..d703606f085190be4d778f219fa27c659b8b8abe --- /dev/null +++ b/linear_function_8qY.json @@ -0,0 +1,170 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 8, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 4 + ] + ], + [ + "CX", + [ + 3, + 6 + ] + ], + [ + "CX", + [ + 4, + 2 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 4, + 7 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 3 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 7, + 4 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_8qY.pt b/linear_function_8qY.pt new file mode 100644 index 0000000000000000000000000000000000000000..c59e58c8947897e52268a323418860968a2b4e88 --- /dev/null +++ b/linear_function_8qY.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cff98724db8c6ea9b183eeae831074561343d75e8c67b0ba73e93918ce0013b8 +size 677197 diff --git a/linear_function_9qF1.json b/linear_function_9qF1.json new file mode 100644 index 0000000000000000000000000000000000000000..36202a4b56af5a02b30981f2ac66c6e73393badd --- /dev/null +++ b/linear_function_9qF1.json @@ -0,0 +1,184 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 9, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 3 + ] + ], + [ + "CX", + [ + 2, + 4 + ] + ], + [ + "CX", + [ + 3, + 1 + ] + ], + [ + "CX", + [ + 3, + 5 + ] + ], + [ + "CX", + [ + 4, + 2 + ] + ], + [ + "CX", + [ + 4, + 7 + ] + ], + [ + "CX", + [ + 5, + 3 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 6, + 7 + ] + ], + [ + "CX", + [ + 7, + 4 + ] + ], + [ + "CX", + [ + 7, + 6 + ] + ], + [ + "CX", + [ + 7, + 8 + ] + ], + [ + "CX", + [ + 8, + 7 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_9qF1.pt b/linear_function_9qF1.pt new file mode 100644 index 0000000000000000000000000000000000000000..9a750f07c8a10755beddd154eed353a65e791564 --- /dev/null +++ b/linear_function_9qF1.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c834b30b6178c15000fe71a86f109a0fd97cbaa221f69e047e34182f0618f6cb +size 714061 diff --git a/linear_function_9qF2.json b/linear_function_9qF2.json new file mode 100644 index 0000000000000000000000000000000000000000..dc01a97e3bec725a4b2f65e87b81f716fcd29712 --- /dev/null +++ b/linear_function_9qF2.json @@ -0,0 +1,184 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 9, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 3 + ] + ], + [ + "CX", + [ + 2, + 4 + ] + ], + [ + "CX", + [ + 3, + 1 + ] + ], + [ + "CX", + [ + 3, + 5 + ] + ], + [ + "CX", + [ + 4, + 2 + ] + ], + [ + "CX", + [ + 4, + 7 + ] + ], + [ + "CX", + [ + 5, + 3 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 5, + 8 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 6, + 7 + ] + ], + [ + "CX", + [ + 7, + 4 + ] + ], + [ + "CX", + [ + 7, + 6 + ] + ], + [ + "CX", + [ + 8, + 5 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_9qF2.pt b/linear_function_9qF2.pt new file mode 100644 index 0000000000000000000000000000000000000000..6c2328e595778b4040455feb10fe9dd0a90452eb --- /dev/null +++ b/linear_function_9qF2.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c3621cbc84fa021ab0cde2b619089fb324077539a8530597023790b2786e83e +size 714061 diff --git a/linear_function_9qH1.json b/linear_function_9qH1.json new file mode 100644 index 0000000000000000000000000000000000000000..2542089b4034b87c162469746fccc6f3fee3752b --- /dev/null +++ b/linear_function_9qH1.json @@ -0,0 +1,184 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 9, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 2 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 0 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 5 + ] + ], + [ + "CX", + [ + 4, + 7 + ] + ], + [ + "CX", + [ + 5, + 3 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 6, + 7 + ] + ], + [ + "CX", + [ + 7, + 4 + ] + ], + [ + "CX", + [ + 7, + 6 + ] + ], + [ + "CX", + [ + 7, + 8 + ] + ], + [ + "CX", + [ + 8, + 7 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_9qH1.pt b/linear_function_9qH1.pt new file mode 100644 index 0000000000000000000000000000000000000000..7950dcb248bb599e11e8fce85f179898136f7d59 --- /dev/null +++ b/linear_function_9qH1.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:df1b40bd9b91d498cd783146822ed94efa6a23566dc87ffe3acbd99127838ab1 +size 714061 diff --git a/linear_function_9qH2.json b/linear_function_9qH2.json new file mode 100644 index 0000000000000000000000000000000000000000..e6407d9a97a0573a4b3dc6696c35b6b9edfd56b4 --- /dev/null +++ b/linear_function_9qH2.json @@ -0,0 +1,184 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 9, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 3 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 1 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 5, + 7 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 7, + 5 + ] + ], + [ + "CX", + [ + 7, + 8 + ] + ], + [ + "CX", + [ + 8, + 7 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_9qH2.pt b/linear_function_9qH2.pt new file mode 100644 index 0000000000000000000000000000000000000000..9fd4a317bf4e6791386ba21d73c87868e78c8ea6 --- /dev/null +++ b/linear_function_9qH2.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bc8ab12236ca845138c10739be7dd5fe4165594a65c3d67ba9c9cbd000e9247c +size 714061 diff --git a/linear_function_9qH3.json b/linear_function_9qH3.json new file mode 100644 index 0000000000000000000000000000000000000000..319ae31b9fb9b37fa36e6e37203fc204c64c1ace --- /dev/null +++ b/linear_function_9qH3.json @@ -0,0 +1,184 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 9, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 2 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 0 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 4 + ] + ], + [ + "CX", + [ + 4, + 3 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 4, + 7 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 7, + 4 + ] + ], + [ + "CX", + [ + 7, + 8 + ] + ], + [ + "CX", + [ + 8, + 7 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_9qH3.pt b/linear_function_9qH3.pt new file mode 100644 index 0000000000000000000000000000000000000000..ba5d4f76e403c1fe999a47441b3ffb8363d86ec8 --- /dev/null +++ b/linear_function_9qH3.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2cfee21d6d3cb510b7609902cdd7fcae0741ebd1ad4dcfc48017ec760eddb7ef +size 714061 diff --git a/linear_function_9qJ.json b/linear_function_9qJ.json new file mode 100644 index 0000000000000000000000000000000000000000..9025d1d59ae8ab3d905e5fc5cba0d46abeddf015 --- /dev/null +++ b/linear_function_9qJ.json @@ -0,0 +1,184 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 9, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 2 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 0 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 3, + 5 + ] + ], + [ + "CX", + [ + 4, + 7 + ] + ], + [ + "CX", + [ + 5, + 3 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 5, + 8 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 6, + 7 + ] + ], + [ + "CX", + [ + 7, + 4 + ] + ], + [ + "CX", + [ + 7, + 6 + ] + ], + [ + "CX", + [ + 8, + 5 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_9qJ.pt b/linear_function_9qJ.pt new file mode 100644 index 0000000000000000000000000000000000000000..4cd2c2fc1c92023901021980165b79b6afeb5349 --- /dev/null +++ b/linear_function_9qJ.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7da09fa20402609d4c31b4449e0b68a9b2edece18a1d414b675590a2e4c39213 +size 714061 diff --git a/linear_function_9qL.json b/linear_function_9qL.json new file mode 100644 index 0000000000000000000000000000000000000000..92b3f6b81400bc694ea75ba07ec356a58eff5d1d --- /dev/null +++ b/linear_function_9qL.json @@ -0,0 +1,184 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 9, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 4 + ] + ], + [ + "CX", + [ + 2, + 3 + ] + ], + [ + "CX", + [ + 2, + 5 + ] + ], + [ + "CX", + [ + 3, + 2 + ] + ], + [ + "CX", + [ + 4, + 1 + ] + ], + [ + "CX", + [ + 4, + 6 + ] + ], + [ + "CX", + [ + 5, + 2 + ] + ], + [ + "CX", + [ + 5, + 8 + ] + ], + [ + "CX", + [ + 6, + 4 + ] + ], + [ + "CX", + [ + 6, + 7 + ] + ], + [ + "CX", + [ + 7, + 6 + ] + ], + [ + "CX", + [ + 7, + 8 + ] + ], + [ + "CX", + [ + 8, + 5 + ] + ], + [ + "CX", + [ + 8, + 7 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_9qL.pt b/linear_function_9qL.pt new file mode 100644 index 0000000000000000000000000000000000000000..95bc977728830191bbc667fca0d46e25769ede6b --- /dev/null +++ b/linear_function_9qL.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8ae33a663518033d2cb069cb106f6ee0f434a2474d47a6b2331de83557bbebd7 +size 714061 diff --git a/linear_function_9qT1.json b/linear_function_9qT1.json new file mode 100644 index 0000000000000000000000000000000000000000..e298e59e9a92310466aa6f4ef9ff7372d88895dc --- /dev/null +++ b/linear_function_9qT1.json @@ -0,0 +1,184 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 9, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 2 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 0 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 4 + ] + ], + [ + "CX", + [ + 3, + 5 + ] + ], + [ + "CX", + [ + 4, + 2 + ] + ], + [ + "CX", + [ + 4, + 6 + ] + ], + [ + "CX", + [ + 5, + 3 + ] + ], + [ + "CX", + [ + 5, + 8 + ] + ], + [ + "CX", + [ + 6, + 4 + ] + ], + [ + "CX", + [ + 6, + 7 + ] + ], + [ + "CX", + [ + 7, + 6 + ] + ], + [ + "CX", + [ + 7, + 8 + ] + ], + [ + "CX", + [ + 8, + 5 + ] + ], + [ + "CX", + [ + 8, + 7 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_9qT1.pt b/linear_function_9qT1.pt new file mode 100644 index 0000000000000000000000000000000000000000..86cc461eb91a91577b739ff8f6e962e08266f29a --- /dev/null +++ b/linear_function_9qT1.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:05cf229494faf59dfe35f64bec166f3ece2ccbd3fc7242c42c09d4d0ffcbc9f8 +size 714061 diff --git a/linear_function_9qT2.json b/linear_function_9qT2.json new file mode 100644 index 0000000000000000000000000000000000000000..541894a747c88eb883025a159380c899d841df05 --- /dev/null +++ b/linear_function_9qT2.json @@ -0,0 +1,184 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 9, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 2 + ] + ], + [ + "CX", + [ + 1, + 3 + ] + ], + [ + "CX", + [ + 2, + 0 + ] + ], + [ + "CX", + [ + 2, + 4 + ] + ], + [ + "CX", + [ + 3, + 1 + ] + ], + [ + "CX", + [ + 3, + 6 + ] + ], + [ + "CX", + [ + 4, + 2 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 4, + 7 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 3 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 7, + 4 + ] + ], + [ + "CX", + [ + 7, + 8 + ] + ], + [ + "CX", + [ + 8, + 7 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_9qT2.pt b/linear_function_9qT2.pt new file mode 100644 index 0000000000000000000000000000000000000000..bd10ccb8b448470bbf2f34c585c203bc47339487 --- /dev/null +++ b/linear_function_9qT2.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ec9859490862d58cce3b26130d4869ab4ca29e1f68307549c116511925e1815a +size 714061 diff --git a/linear_function_9qY.json b/linear_function_9qY.json new file mode 100644 index 0000000000000000000000000000000000000000..fc483b2a72d2c3c934557d2fd3074f68787264a8 --- /dev/null +++ b/linear_function_9qY.json @@ -0,0 +1,184 @@ +{ + "env_cls": "qiskit_gym.envs.synthesis.LinearFunctionEnv", + "env": { + "num_qubits": 9, + "difficulty": 1, + "gateset": [ + [ + "CX", + [ + 0, + 1 + ] + ], + [ + "CX", + [ + 1, + 0 + ] + ], + [ + "CX", + [ + 1, + 2 + ] + ], + [ + "CX", + [ + 2, + 1 + ] + ], + [ + "CX", + [ + 2, + 4 + ] + ], + [ + "CX", + [ + 3, + 6 + ] + ], + [ + "CX", + [ + 4, + 2 + ] + ], + [ + "CX", + [ + 4, + 5 + ] + ], + [ + "CX", + [ + 4, + 7 + ] + ], + [ + "CX", + [ + 5, + 4 + ] + ], + [ + "CX", + [ + 5, + 6 + ] + ], + [ + "CX", + [ + 6, + 3 + ] + ], + [ + "CX", + [ + 6, + 5 + ] + ], + [ + "CX", + [ + 7, + 4 + ] + ], + [ + "CX", + [ + 7, + 8 + ] + ], + [ + "CX", + [ + 8, + 7 + ] + ] + ], + "depth_slope": 2, + "max_depth": 512, + "metrics_weights": { + "n_cnots": 0.01, + "n_layers_cnots": 0.01, + "n_layers": 0.01, + "n_gates": 0.01 + } + }, + "policy_cls": "twisterl.nn.BasicPolicy", + "policy": { + "embedding_size": 512, + "common_layers": [ + 256 + ], + "policy_layers": [], + "value_layers": [] + }, + "algorithm_cls": "twisterl.rl.PPO", + "algorithm": { + "collecting": { + "num_cores": 32, + "num_episodes": 1024, + "lambda": 0.995, + "gamma": 0.995 + }, + "training": { + "num_epochs": 10, + "vf_coef": 0.8, + "ent_coef": 0.01, + "clip_ratio": 0.1, + "normalize_advantage": false + }, + "learning": { + "diff_threshold": 0.85, + "diff_max": 1024, + "diff_metric": "ppo_deterministic" + }, + "optimizer": { + "lr": 0.0003 + }, + "evals": { + "ppo_deterministic": { + "num_episodes": 100, + "deterministic": true, + "num_searches": 1, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + }, + "ppo_10": { + "num_episodes": 100, + "deterministic": false, + "num_searches": 10, + "num_mcts_searches": 0, + "num_cores": 32, + "C": 1.41 + } + }, + "logging": { + "log_freq": 1, + "checkpoint_freq": 10 + } + } +} \ No newline at end of file diff --git a/linear_function_9qY.pt b/linear_function_9qY.pt new file mode 100644 index 0000000000000000000000000000000000000000..a35c0d3e869d18a545e50fdc012fa22bea11c4d7 --- /dev/null +++ b/linear_function_9qY.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6b88aa8c8641109f13ef199e6d963dc6f47318415443894564d24a33cf29d042 +size 714061