def cluster_points(scattered_points, filename):
# Set up problem
# Note: max_distance gets used in division later on. Hence, the max(.., 1)
# is used to prevent a division by zero
coordinates = [Coordinate(x, y) for x, y in scattered_points]
max_distance = max(get_max_distance(coordinates), 1)
# Build constraints
csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)
# Apply constraint: coordinate can only be in one colour group
choose_one_group = {(0, 0, 1), (0, 1, 0), (1, 0, 0)}
for coord in coordinates:
csp.add_constraint(choose_one_group, (coord.r, coord.g, coord.b))
# Build initial BQM
bqm = dwavebinarycsp.stitch(csp)
# Edit BQM to bias for close together points to share the same color
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
d = get_distance(coord0, coord1) / max_distance # rescale distance
weight = -math.cos(d * math.pi)
# Apply weights to BQM
bqm.add_interaction(coord0.r, coord1.r, weight)
bqm.add_interaction(coord0.g, coord1.g, weight)
bqm.add_interaction(coord0.b, coord1.b, weight)
# Edit BQM to bias for far away points to have different colors
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
# Note: rescaled and applied square root so that far off distances
# are all weighted approximately the same
d = math.sqrt(get_distance(coord0, coord1) / max_distance)
weight = -math.tanh(d) * 0.1
# Apply weights to BQM
bqm.add_interaction(coord0.r, coord1.b, weight)
bqm.add_interaction(coord0.r, coord1.g, weight)
bqm.add_interaction(coord0.b, coord1.r, weight)
bqm.add_interaction(coord0.b, coord1.g, weight)
bqm.add_interaction(coord0.g, coord1.r, weight)
bqm.add_interaction(coord0.g, coord1.b, weight)
# Submit problem to D-Wave sampler
sampler = EmbeddingComposite(DWaveSampler(solver={'qpu': True}))
#sampler = neal.SimulatedAnnealingSampler()
sampleset = sampler.sample(bqm, chain_strength=4, num_reads=1000)
best_sample = sampleset.first.sample
# Visualize graph problem
dwave.inspector.show(bqm, sampleset)
# Visualize solution
groupings = get_groupings(best_sample)
visualize_groupings(groupings, filename)
return groupings
def clustering(scattered_points, filename):
kmeans = KMeans(n_clusters=8,
random_state=42,
init='k-means++',
n_init=10,
max_iter=30,
algorithm='full').fit(scattered_points)
groupings = {}
dist_from_cent = {}
for i in range(Number_Deliveries):
groupings[str(i)] = []
dist_from_cent[str(i)] = []
for i in range(len(scattered_points)):
for key in groupings.keys():
if str(kmeans.labels_[i]) == key:
groupings[key].append(scattered_points[i])
#print(groupings)
visualize_groupings(groupings, filename)
return groupings
def cluster_points(scattered_points, filename, architecture):
# Set up problem
# Note: max_distance gets used in division later on. Hence, the max(.., 1)
# is used to prevent a division by zero
coordinates = [Coordinate(x, y) for x, y in scattered_points]
max_distance = max(get_max_distance(coordinates), 1)
# Build constraints
csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)
# Apply constraint: coordinate can only be in one colour group
choose_one_group = {(0, 0, 1), (0, 1, 0), (1, 0, 0)}
for coord in coordinates:
csp.add_constraint(choose_one_group, (coord.r, coord.g, coord.b))
# Build initial BQM
bqm = dwavebinarycsp.stitch(csp)
# Edit BQM to bias for close together points to share the same color
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
d = get_distance(coord0, coord1) / max_distance # rescale distance
weight = -math.cos(d * math.pi)
# Apply weights to BQM
bqm.add_interaction(coord0.r, coord1.r, weight)
bqm.add_interaction(coord0.g, coord1.g, weight)
bqm.add_interaction(coord0.b, coord1.b, weight)
# Edit BQM to bias for far away points to have different colors
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
# Note: rescaled and applied square root so that far off distances
# are all weighted approximately the same
d = math.sqrt(get_distance(coord0, coord1) / max_distance)
weight = -math.tanh(d) * 0.1
# Apply weights to BQM
bqm.add_interaction(coord0.r, coord1.b, weight)
bqm.add_interaction(coord0.r, coord1.g, weight)
bqm.add_interaction(coord0.b, coord1.r, weight)
bqm.add_interaction(coord0.b, coord1.g, weight)
bqm.add_interaction(coord0.g, coord1.r, weight)
bqm.add_interaction(coord0.g, coord1.b, weight)
# Submit problem to D-Wave sampler
if architecture == 'pegasus':
solver = DWaveSampler(solver={
'topology__type': 'pegasus',
'qpu': True
})
print(solver.solver)
sampler = EmbeddingComposite(solver)
else:
solver = DWaveSampler(solver={
'topology__type': 'chimera',
'qpu': True
})
print(solver.solver)
sampler = EmbeddingComposite(solver)
sampleset = sampler.sample(bqm,
chain_strength=4,
num_reads=1000,
return_embedding=True)
best_sample = sampleset.first.sample
# Inspect the embedding
embedding = sampleset.info['embedding_context']['embedding']
num_qubits = 0
for k in embedding.values():
num_qubits += len(k)
print("Number of qubits used in embedding = " + str(num_qubits))
# Visualize graph problem
dwave.inspector.show(bqm, sampleset)
# Visualize solution
groupings = get_groupings(best_sample)
visualize_groupings(groupings, filename)
# Print solution onto terminal
# Note: This is simply a more compact version of 'best_sample'
print(groupings)
def cluster_points(scattered_points, filename):
# Set up problem
coordinates = [Coordinate(x, y) for x, y in scattered_points]
max_distance = get_max_distance(coordinates)
# Build constraints
csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)
# Apply constraint: coordinate can only be in one colour group
choose_one_group = allowed_States(k)
for coord in coordinates:
mylist = list(vars(coord).values())
mylist.remove(coord.x)
mylist.remove(coord.y)
csp.add_constraint(choose_one_group, mylist)
# Build initial BQM
bqm = dwavebinarycsp.stitch(csp)
# Edit BQM to bias for close together points to share the same color
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
d = get_distance(coord0, coord1) / max_distance # rescale distance
weight = -math.cos(d * math.pi)
# Apply weights to BQM
for i in range(k):
bqm.add_interaction(getattr(coord0, "x" + str(i)),
getattr(coord1, "x" + str(i)), weight)
# Edit BQM to bias for far away points to have different colors
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
# Note: rescaled and applied square root so that far off distances
# are all weighted approximately the same
d = math.sqrt(get_distance(coord0, coord1) / max_distance)
weight = -math.tanh(d) * 0.1
# Apply weights to BQM
for p in range(k):
for m in range(k):
if p != m:
bqm.add_interaction(getattr(coord0, "x" + str(p)),
getattr(coord1, "x" + str(m)),
weight)
# Submit problem to D-Wave sampler
sampler = EmbeddingComposite(DWaveSampler(solver={'qpu': True}))
sampleset = sampler.sample(bqm, chain_strength=4, num_reads=1000)
best_sample = sampleset.first.sample
# Visualize graph problem
dwave.inspector.show(bqm, sampleset)
# Visualize solution
groupings = get_groupings(best_sample)
visualize_groupings(groupings, filename)
# Print solution onto terminal
# Note: This is simply a more compact version of 'best_sample'
print(groupings)
def cluster_points(scattered_points, filename, problem_inspector):
"""Perform clustering analysis on given points
Args:
scattered_points (list of tuples):
Points to be clustered
filename (str):
Output file for graphic
problem_inspector (bool):
Whether to show problem inspector
"""
# Set up problem
# Note: max_distance gets used in division later on. Hence, the max(.., 1)
# is used to prevent a division by zero
coordinates = [Coordinate(x, y) for x, y in scattered_points]
max_distance = max(get_max_distance(coordinates), 1)
# Build constraints
csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY)
# Apply constraint: coordinate can only be in one colour group
choose_one_group = {(0, 0, 1), (0, 1, 0), (1, 0, 0)}
for coord in coordinates:
csp.add_constraint(choose_one_group, (coord.r, coord.g, coord.b))
# Build initial BQM
bqm = dwavebinarycsp.stitch(csp)
# Edit BQM to bias for close together points to share the same color
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
d = get_distance(coord0, coord1) / max_distance # rescale distance
weight = -math.cos(d * math.pi)
# Apply weights to BQM
bqm.add_interaction(coord0.r, coord1.r, weight)
bqm.add_interaction(coord0.g, coord1.g, weight)
bqm.add_interaction(coord0.b, coord1.b, weight)
# Edit BQM to bias for far away points to have different colors
for i, coord0 in enumerate(coordinates[:-1]):
for coord1 in coordinates[i + 1:]:
# Set up weight
# Note: rescaled and applied square root so that far off distances
# are all weighted approximately the same
d = math.sqrt(get_distance(coord0, coord1) / max_distance)
weight = -math.tanh(d) * 0.1
# Apply weights to BQM
bqm.add_interaction(coord0.r, coord1.b, weight)
bqm.add_interaction(coord0.r, coord1.g, weight)
bqm.add_interaction(coord0.b, coord1.r, weight)
bqm.add_interaction(coord0.b, coord1.g, weight)
bqm.add_interaction(coord0.g, coord1.r, weight)
bqm.add_interaction(coord0.g, coord1.b, weight)
# Submit problem to D-Wave sampler
sampler = EmbeddingComposite(DWaveSampler())
sampleset = sampler.sample(bqm,
chain_strength=4,
num_reads=1000,
label='Example - Clustering')
best_sample = sampleset.first.sample
# Visualize graph problem
if problem_inspector:
dwave.inspector.show(bqm, sampleset)
# Visualize solution
groupings = get_groupings(best_sample)
visualize_groupings(groupings, filename)
# Print solution onto terminal
# Note: This is simply a more compact version of 'best_sample'
print(groupings)