Optimization 选择具有一定阈值的重叠簇

比如说，我已经对我的数据集进行了聚类，共有10个聚类。这些簇是不重叠的。但现在假设我更改了所有数据点中的某些特性，并再次进行聚类。现在我还有10个集群。如果我再重复3次，最后我会有50个集群。每个聚类都有一个与其相关联的分数，该分数是根据其组成部分的数据点计算得出的

这50个集群现在有重叠的数据点。我想从这50个允许重叠的集群中选择所有可能的集群，以获得所选集群的最高总分

一种方法是贪婪方法，我根据得分从高到低对集群进行排序。然后选择得分最高的集群。然后，继续选择与已选择的簇重叠在阈值内的簇。但它似乎不是最佳解决方案，尽管它很快

示例：假设我有3个集群，得分如下：

C1=（A、B、C、D、E、F）分数=10

C2=（A、B、C、D）得分=6

C3=（D、E、F）得分=6

允许的重叠为1个元素或小于较小集群大小的40%

贪婪方法将返回总分为10的{C1}，而更好的选择是{C2，C3}，总分为6+6=12，元素“D”重叠，即1/size（C3）=1/3=33%<40%

---

我正在寻找另一种方法，它可以提供最佳解决方案或比上述贪婪方法更好的解决方案。

以下链接给出了问题的无约束版本的答案：

可以在上面链接中编码的模型中添加新约束，以检查选定簇之间的重叠，并将其限制在允许的阈值范围内

以下是针对上述问题的python代码：

from gurobipy import *
import string
# List of all subtomograms
data_points = string.ascii_uppercase[:6]
data_points = list(data_points)

# Clusters as list of lists, where each list is list of subtomograms
clusters = []
clusters.append(['A', 'B', 'C', 'D', 'E', 'F'])
clusters.append(['A', 'B', 'C', 'D'])
clusters.append(['D', 'E', 'F'])

# Create a matrix: num_subtomograms x num_clusters
matrix = {}
for dp in data_points:
    matrix[dp] = [0]*len(clusters)

# Make matrix[subtomogram_i][cluster_i] = 1, if subtomogram_i is present in cluster_i
for i in range(0, len(clusters)):
    for dp in clusters[i]:
        matrix[dp][i] = 1

# Score of each cluster in the same order as used in matrix
cost = [10, 6, 6]

# Gurobi MIP model
m = Model("Cluster selection optimization")
m.params.outputflag = 1
m.params.method = 2 # for barrier method in Gurobi, it is used to solve quadratic programming problems

# Adding a variable x where x[i] will represent whether or not ith cluster is selected or not
x = m.addVars(len(clusters), vtype=GRB.BINARY, name='x')

# generate objective function: score[0]x[0] + score[1]x[1] .....
indices = range(0, len(clusters))
coef_x = dict()
obj = 0.0
for i in indices:
    coef_x[i] = cost[i]
    obj += coef_x[i] * x[i]
m.setObjective(obj, GRB.MAXIMIZE)

# Generate constraints
threshhold = 0.4 # 40% threshold set
count = 0
m_sum = []
for i in range(len(clusters)):
    m_sum.append(sum([matrix[k][i] for k in data_points]))
for i in range(len(clusters)):
    for j in range(i+1, len(clusters)):
        if i==j:
            continue
        tmp = (sum([matrix[k][i]*matrix[k][j] for k in data_points])*x[i]*x[j] <= threshhold*min(m_sum[i], m_sum[j]))
        m.addConstr(tmp, "C"+str(count))
        count += 1

# Optimize
m.optimize()
print("Optimized")

---

还有其他方法可以解决这个问题，如人工智能方法（爬山、模拟退火等），进化优化方法（如遗传算法）（根据您的问题修改后，您可以使用NSGA2，代码可在上获得）

我们讨论了多少个集群和多少个数据点？您是否尝试过使用通用优化器？如果你只有50个集群，你可以负担得起。@juvian在我的问题中，集群的数量在每次迭代后都会增加。它从20开始，然后在每次迭代后再添加20个。我需要在每次迭代中选择之前定义的重叠集群。所以我会做我有20个集群，然后在第二次迭代中有40个集群，然后在第三次迭代中有60个集群。。。。。最多400或600次迭代。总数据点也可以是50000。好吧，听起来对于一个最佳解决方案来说数据太多了。想不出更好的贪婪算法，可以尝试使用禁忌搜索或遗传算法等启发式算法。遗传算法可以。。。但仍在寻找其他方法。。。

Parameter outputflag unchanged
   Value: 1  Min: 0  Max: 1  Default: 1
Changed value of parameter method to 2
   Prev: -1  Min: -1  Max: 5  Default: -1
Optimize a model with 0 rows, 3 columns and 0 nonzeros
Model has 3 quadratic constraints
Variable types: 0 continuous, 3 integer (3 binary)
Coefficient statistics:
  Matrix range     [0e+00, 0e+00]
  QMatrix range    [1e+00, 4e+00]
  Objective range  [6e+00, 1e+01]
  Bounds range     [1e+00, 1e+00]
  RHS range        [0e+00, 0e+00]
  QRHS range       [1e+00, 2e+00]
Found heuristic solution: objective -0.0000000
Modified 2 Q diagonals
Modified 2 Q diagonals
Presolve time: 0.00s
Presolved: 0 rows, 3 columns, 0 nonzeros
Variable types: 0 continuous, 3 integer (3 binary)
Presolve removed 0 rows and 3 columns
Presolve: All rows and columns removed

Root relaxation: objective 2.200000e+01, 0 iterations, 0.00 seconds

    Nodes    |    Current Node    |     Objective Bounds      |     Work
 Expl Unexpl |  Obj  Depth IntInf | Incumbent    BestBd   Gap | It/Node Time

*    0     0               0      12.0000000   12.00000  0.00%     -    0s

Explored 0 nodes (2 simplex iterations) in 0.01 seconds
Thread count was 32 (of 32 available processors)

Solution count 2: 12 -0 

Optimal solution found (tolerance 1.00e-04)
Best objective 1.200000000000e+01, best bound 1.200000000000e+01, gap 0.0000%
Optimized
Final Obj: 12.0
1
2