Bir korelasyon matrisinin kümelenmesi

Her öğenin diğer öğeyle nasıl ilişkilendirildiğini belirten bir korelasyon matrisim var. Dolayısıyla bir N maddesi için zaten bir N * N korelasyon matrisi var. Bu korelasyon matrisini kullanarak, K bölmesindeki Nk Öğelerinin aynı şekilde davrandığını söyleyebilmem için M bölmelerindeki N öğelerini nasıl kümeleyebilirim. Lütfen bana yardım et. Tüm öğe değerleri kategoriktir.

Teşekkürler. Daha fazla bilgiye ihtiyacınız olursa bana bildirin. Python'da bir çözüme ihtiyacım var ama beni gereksinimlere doğru itmede herhangi bir yardım büyük bir yardım olacak.

Blok modelleme için bir iş gibi görünüyor. "Blok modelleme" için Google ve ilk birkaç isabet yararlıdır.

Diyelim ki N = 100 olan ve aslında 5 küme olan bir kovaryans matrisimiz var:

Blok modellemenin yapmaya çalıştığı şey, satırların sırasını bulmaktır, böylece kümeler 'bloklar' olarak görünür hale gelir:

Aşağıda, bunu gerçekleştirmek için temel bir açgözlü arama yapan bir kod örneği verilmiştir. Muhtemelen 250-300 değişkeniniz için çok yavaş, ama bu bir başlangıç. Yorumlarla birlikte takip edip edemeyeceğinize bakın:

import numpy as np
from matplotlib import pyplot as plt

# This generates 100 variables that could possibly be assigned to 5 clusters
n_variables = 100
n_clusters = 5
n_samples = 1000

# To keep this example simple, each cluster will have a fixed size
cluster_size = n_variables // n_clusters

# Assign each variable to a cluster
belongs_to_cluster = np.repeat(range(n_clusters), cluster_size)
np.random.shuffle(belongs_to_cluster)

# This latent data is used to make variables that belong
# to the same cluster correlated.
latent = np.random.randn(n_clusters, n_samples)

variables = []
for i in range(n_variables):
    variables.append(
        np.random.randn(n_samples) + latent[belongs_to_cluster[i], :]
    )

variables = np.array(variables)

C = np.cov(variables)

def score(C):
    '''
    Function to assign a score to an ordered covariance matrix.
    High correlations within a cluster improve the score.
    High correlations between clusters decease the score.
    '''
    score = 0
    for cluster in range(n_clusters):
        inside_cluster = np.arange(cluster_size) + cluster * cluster_size
        outside_cluster = np.setdiff1d(range(n_variables), inside_cluster)

        # Belonging to the same cluster
        score += np.sum(C[inside_cluster, :][:, inside_cluster])

        # Belonging to different clusters
        score -= np.sum(C[inside_cluster, :][:, outside_cluster])
        score -= np.sum(C[outside_cluster, :][:, inside_cluster])

    return score


initial_C = C
initial_score = score(C)
initial_ordering = np.arange(n_variables)

plt.figure()
plt.imshow(C, interpolation='nearest')
plt.title('Initial C')
print 'Initial ordering:', initial_ordering
print 'Initial covariance matrix score:', initial_score

# Pretty dumb greedy optimization algorithm that continuously
# swaps rows to improve the score
def swap_rows(C, var1, var2):
    '''
    Function to swap two rows in a covariance matrix,
    updating the appropriate columns as well.
    '''
    D = C.copy()
    D[var2, :] = C[var1, :]
    D[var1, :] = C[var2, :]

    E = D.copy()
    E[:, var2] = D[:, var1]
    E[:, var1] = D[:, var2]

    return E

current_C = C
current_ordering = initial_ordering
current_score = initial_score

max_iter = 1000
for i in range(max_iter):
    # Find the best row swap to make
    best_C = current_C
    best_ordering = current_ordering
    best_score = current_score
    for row1 in range(n_variables):
        for row2 in range(n_variables):
            if row1 == row2:
                continue
            option_ordering = best_ordering.copy()
            option_ordering[row1] = best_ordering[row2]
            option_ordering[row2] = best_ordering[row1]
            option_C = swap_rows(best_C, row1, row2)
            option_score = score(option_C)

            if option_score > best_score:
                best_C = option_C
                best_ordering = option_ordering
                best_score = option_score

    if best_score > current_score:
        # Perform the best row swap
        current_C = best_C
        current_ordering = best_ordering
        current_score = best_score
    else:
        # No row swap found that improves the solution, we're done
        break

# Output the result
plt.figure()
plt.imshow(current_C, interpolation='nearest')
plt.title('Best C')
print 'Best ordering:', current_ordering
print 'Best score:', current_score
print
print 'Cluster     [variables assigned to this cluster]'
print '------------------------------------------------'
for cluster in range(n_clusters):
    print 'Cluster %02d  %s' % (cluster + 1, current_ordering[cluster*cluster_size:(cluster+1)*cluster_size])

Hiyerarşik kümelemeye baktınız mı? Sadece mesafelerle değil, benzerliklerle çalışabilir. Dendrogramı k kümelerine bölündüğü bir yükseklikte kesebilirsiniz, ancak genellikle dendrogramı görsel olarak incelemek ve kesmek için bir yüksekliğe karar vermek daha iyidir.

Hiyerarşik kümeleme genellikle diğer cevapta görüldüğü gibi benzerlik matrisi vidualizasyonu için akıllı bir yeniden sıralama üretmek için kullanılır: yan yana daha benzer girişler yerleştirir. Bu, kullanıcı için de bir doğrulama aracı olarak kullanılabilir!

Korelasyon kümelenmesine baktınız mı ? Bu kümeleme algoritması, iyi tanımlanmış bir işlevsel ve titiz bir üretken olasılıksal yorumlama ile optimum sayıda kümeyi otomatik olarak önermek için çift yönlü pozitif / negatif korelasyon bilgilerini kullanır .

Bazı anlamlı (istatistiksel anlamlılık) eşikte filtreleyecek ve daha sonra bağlı bileşenleri almak için dulmage-mendelsohn ayrışmasını kullanacağım. Belki geçişli korelasyonlar gibi bir problemi gidermeye çalışmadan önce (A, B, B'den C'ye, C'den D'ye yüksek derecede korelasyon gösterir, bu yüzden hepsini içeren bir bileşen vardır, ancak aslında D'den A'ya düşüktür). bazı bağımlılık tabanlı algoritmalar kullanabilirsiniz. Korelasyon matrisi simetrik olduğu ve dolayısıyla bi-şey olmadığı için, birinin önerdiği gibi bir mırıldanma sorunu değildir.