Question

我需要以一维数组的方式将项目群集交织在一起，以使同一群集的项目之间的散布最大化。

示例：

clusterA = [A, A, A, A, A, A, A, A]
clusterB = [B, B, B, B]
clusterC = [C, C]

interleaved_example = [A, B, A, C, A, A, B, A, B, A, C, A, B, A]

A值之间的价差为(2, 2, 1, 2, 2, 2, 2), mean of ~1.9

B值之间的价差为(5, 2, 4), mean of ~3.7

C值之间的差为(7) = mean of 7

平均价差== 2.8，最小价差= 1

理想情况下，将首先优化最小点差，然后再优化平均点差。

我对算法的第一步是获取最大的簇并将其放置在数组X中，然后获取第二个最大的簇并将值插入到X中线性间隔的位置（四舍五入）根据需要），然后对随后的每个较小的群集重复该操作，但这很容易证明次优，尽管平均水平还不错。

我一直努力将其建模为凸优化问题，以期在其上使用scipy.optimize.minimize。

我想知道是否有现有的原理算法可以实现这一目标。

Answer 1

我认为通过在平分线位置逐步插入，您将获得最大的传播。从最小的集到最大的集应用此方法，应能产生最佳的传播（或接近传播）：

首先，您需要一个函数，该函数将为您提供N个目标元素（其中N> = m）列表中m个源元素的二等分插入点。该功能应从头三个插入（第一个，最后一个，中间）的最大可能扩展开始，然后将中间的二等分用于其余插入点。

def iPoints(N,m):
    d = N//2
    result = [0,N,d]
    if m==N: result[1] = N-1
    while len(result)<m:
        d = max(1,d//2)
        for r in result[2:]:
            for s in [-1,1]:
                p = r+s*d
                if p in result : continue
                result.append(p)
    result = sorted(result[:m])
    result = [ p + sum(p>r for r in result[:i]) for i,p in enumerate(result)]
    return result

使用此功能，您可以从最大到最小浏览整个群集列表，并执行插入操作：

clusterA  = ["A", "A", "A", "A", "A", "A", "A", "A"]
clusterB  = ["B", "B", "B", "B"]
clusterC  = ["C", "C"]

clusters  = [clusterA,clusterB,clusterC]
totalSize = sum(map(len,clusters))
order     = -1 if all((totalSize-len(c))//(len(c)-1) for c in clusters) else 1
clusters  = sorted(clusters,key=lambda c: order*(totalSize-len(c))//(len(c)-1))
merged    = clusters[0]
for cluster in clusters[1:]:
    target = cluster.copy()
    source = merged
    if len(source) > len(target):
        source,target = target,source
    indexes = iPoints(len(target),len(source))
    for c,p in zip(source,indexes):
        target.insert(p,c)
    merged  = target

print(merged)

# ['C', 'B', 'A', 'A', 'B', 'A', 'A', 'B', 'A', 'A', 'A', 'A', 'B', 'C']

对该结果的分析表明，对于这组集群而言，它要好一些。不幸的是，它并不总是能提供最佳解决方案。

from statistics import mean
m = "".join(merged)
spreadA = [ d+1 for d in map(len,m.split("A")[1:-1])]
spreadB = [ d+1 for d in map(len,m.split("B")[1:-1])]
spreadC = [ d+1 for d in map(len,m.split("C")[1:-1])]
print("A",spreadA,mean(spreadA))
print("B",spreadB,mean(spreadB))
print("C",spreadC,mean(spreadC))
print("minimum spread",min(spreadA+spreadB+spreadC))
print("average spread", round(mean(spreadA+spreadB+spreadC), 1))

# A [1, 2, 1, 2, 1, 1, 1] 1.3
# B [3, 3, 5] 3.7
# C [13] 13
# minimum spread 1
# average spread 3

通过其他集群大小的实验，我发现集群处理的顺序很重要。我使用的顺序基于每个群集的最大传播。如果至少一个大于其余的，则升序；否则，降序。

clusterA = ["A", "A", "A", "A", "A"]
clusterB = ["B", "B", "B", "B"]
clusterC = ["C", "C"]


# ['A', 'C', 'B', 'A', 'B', 'A', 'B', 'A', 'B', 'C', 'A']
# A [3, 2, 2, 3] 2.5
# B [2, 2, 2] 2
# C [8] 8
# minimum spread 2
# average spread 3

Answer 2

如前所述，对于这种退化的情况，有一个简单的解决方案，其中一组至少具有一半的组合加上一个元素。该集合必须必须有两个相邻的成员，将最小点差固定在1。

由于您的其他指标仅取决于每个集合（第一个和最后一个元素）的总价差，因此中间排列无所谓。

在价差的每一端放置每个类别的元素，在较小的范围之外放置较大的集合。

ABCAAAAAABBCBA

A spread: 3 1 1 1 1 1 5; mean = 13/7, the same as yours
B spread: 8 1 2;         mean = 11/3, ~3.7 versus your ~3.3
C spread: 9;             mean =  9/1, better than your 7
mean spread (13+11+9) / (7+3+1) = 33/11 = 3, better than your ~2.7

我建议您将点差指标更改为RMS或类似的高阶计算。在这种情况下，引用的副本应该可以满足您的需求。

交错群集的算法

2 个答案: