blueqat cloud経由でのD-Waveでのクラスタリング問題

Copy
import json
import urllib.request

import numpy as np
import pandas as pd
import networkx as nx
from blueqat.wq import *
import matplotlib.pyplot as plt

%matplotlib inline


f = open('.pass', 'r', encoding='UTF-8')
API_KEY = f.read()[:-1]
f.close()

API_ENDPOINT = "https://cloudapi.blueqat.com/v1/"

def post_request(path, body):
    headers = {
        'Content-Type': 'application/json',
        'X-Api-Key': API_KEY,
    }
    req = urllib.request.Request(
        API_ENDPOINT + path, json.dumps(body).encode(), headers)
    with urllib.request.urlopen(req) as res:
        body = res.read()
    return json.loads(body)


def get_quantum_tasks(index):
    path = "quantum-tasks/list"
    body = {
        "index": index,
    }
    return post_request(path, body)


def get_quantum_task(id):
    path = "quantum-tasks/get"
    body = {
        "id": id,
    }
    return post_request(path, body)


def create_quantum_task(qubo, num_reads, chain_strength=8):
    path = "quantum-tasks/create"
    body = {
        "qubo": qubo,
        "num_reads": num_reads,
        "chain_strength": chain_strength
    }
    return post_request(path, body)


def get_credit():
    path = "credit/get"
    return post_request(path, {})

Copy
n_node = 20
n_cluster = 2
N = n_node*n_cluster

print(N)

Copy
x = np.random.normal(0, 1.5, int(n_node/2))
y = np.random.normal(0, 1.5, int(n_node/2)) 

x = np.append(x, np.random.normal(5, 1.5, int(n_node/2)))
y = np.append(y, np.random.normal(5, 1.5, int(n_node/2)))
 
# 散布図を描画
plt.scatter(x, y)

Copy
#initialize distance
d = np.zeros((n_node,n_node))

for i in range(0, n_node-1):
    for j in range(i+1, n_node):
        a = np.array([x[i],y[i]])
        b = np.array([x[j],y[j]])
        d[i][j] = np.linalg.norm(a-b)

#map distance to qubo
A = np.zeros((N,N))

for i in range(0, n_node-1):
    for j in range(i+1, n_node):
        A[i*2][j*2] = A[i*2+1][j*2+1] = d[i][j]
        
#initialize constraint
B = np.zeros((N,N))

for i in range(N):
    B[i][i] = -1

for i in range(n_node):
    B[i*2][i*2+1] = 2

Copy
#set a QUBO
M = 1
qubo = A+B*M

#show as network
G = nx.from_numpy_matrix(qubo)
nx.draw_networkx(G)
plt.show()

Copy
plt.imshow(qubo)
plt.colorbar()
plt.show()

Copy
#to simulator
M = 50
qubo = A+B*M

a = Opt()
a.qubo = qubo
res = a.run()

print(sum(res))

plt.scatter(x, y, c=res[::2])

Copy
num_reads = 10000

#to D-Wave Advantage
M = 100
qubo = (A+B*M).tolist()

result = create_quantum_task(qubo, num_reads)
table = pd.read_json(result["task"]["dataframe"]).sort_values('energy')
result2 = table.loc[0][0:N].astype('int').to_list()

print(sum(result2))

plt.scatter(x, y, c=result2[::2])

Copy
table