ขั้นตอนการทำคลัสเตอร์ที่แต่ละกลุ่มมีจำนวนคะแนนเท่ากันหรือไม่

ฉันมีบางจุดในR pและฉันต้องการจัดกลุ่มคะแนนเพื่อให้:$X=\{x_1,...,x_n\}$$R^p$

1. แต่ละคลัสเตอร์มีจำนวนเท่ากันขององค์ประกอบของX(สมมติว่าจำนวนกลุ่มหารn )$X$$n$

2. แต่ละกลุ่มมี "ความสัมพันธ์เชิงพื้นที่" ในบางกรณีเช่นกลุ่มจาก -means$k$

เป็นเรื่องง่ายที่จะนึกถึงกระบวนการจัดกลุ่มจำนวนมากที่ตอบสนองความต้องการอย่างใดอย่างหนึ่ง แต่ไม่มีใครรู้วิธีที่จะทำให้ทั้งสองอย่างพร้อมกันได้หรือไม่

ฉันขอแนะนำวิธีสองขั้นตอน:

1. รับการประมาณค่าเริ่มต้นที่ดีของศูนย์คลัสเตอร์เช่นการใช้ K-mean อย่างหนักหรือคลุมเครือ

2. การใช้งานทั่วโลกที่ใกล้ที่สุดที่ได้รับมอบหมายเพื่อนบ้านไปยังจุดเชื่อมโยงกับศูนย์คลัสเตอร์: การคำนวณเมทริกซ์ระยะห่างระหว่างจุดแต่ละจุดและศูนย์คลัสเตอร์แต่ละ (คุณสามารถทำให้ปัญหาบิตขนาดเล็กโดยเฉพาะการคำนวณระยะทางที่เหมาะสม) ทำซ้ำแต่ละศูนย์คลัสเตอร์ X ครั้งและแก้ปัญหาเชิงเส้น ปัญหาที่ได้รับมอบหมาย คุณจะได้รับสำหรับแต่ละศูนย์คลัสเตอร์ตรงกับ X จุดข้อมูลเพื่อให้ทั่วโลกระยะห่างระหว่างจุดข้อมูลและศูนย์คลัสเตอร์จะลดลง

โปรดทราบว่าคุณสามารถอัปเดตศูนย์คลัสเตอร์หลังจากขั้นตอนที่ 2 และทำซ้ำขั้นตอนที่ 2 เพื่อเรียกใช้ K-Mean ด้วยจำนวนคะแนนคงที่ต่อคลัสเตอร์ แต่ถึงกระนั้นก็เป็นความคิดที่ดีที่จะคาดเดาการเริ่มต้นที่ดีก่อน

ลองรูปแบบ k-mean นี้:

การเริ่มต้น :

• เลือกkศูนย์จากชุดข้อมูลโดยการสุ่มหรือดียิ่งขึ้นโดยใช้กลยุทธ์ kmeans ++
• สำหรับแต่ละจุดคำนวณระยะทางไปยังศูนย์คลัสเตอร์ที่ใกล้ที่สุดและสร้างฮีปสำหรับสิ่งนี้
• ดึงคะแนนจากฮีปและกำหนดให้กับคลัสเตอร์ที่ใกล้ที่สุดยกเว้นว่าคลัสเตอร์นั้นเต็มแล้ว ถ้าเป็นเช่นนั้นให้คำนวณศูนย์คลัสเตอร์ถัดไปที่ใกล้ที่สุดแล้วแทรกเข้าไปใน heap

ในท้ายที่สุดคุณควรจะมี paritioning ที่ตอบสนองความต้องการของคุณที่ + -1 หมายเลขเดียวกันของวัตถุต่อคลัสเตอร์ (ให้แน่ใจว่ากลุ่มที่ไม่กี่ครั้งยังมีจำนวนที่เหมาะสม. ครั้งแรกที่mกลุ่มควรมีceilวัตถุที่เหลือตรงfloorวัตถุ.)

ขั้นตอนการทำซ้ำ :

สิ่งที่ต้องการ: รายการสำหรับแต่ละกลุ่มที่มี "ข้อเสนอการแลกเปลี่ยน" (วัตถุที่ต้องการอยู่ในกลุ่มอื่น)

ขั้นตอนE : คำนวณศูนย์คลัสเตอร์ที่อัพเดตเช่นเดียวกับใน k-mean ปกติ

ขั้นตอนM : วนซ้ำทุกจุด (เพียงจุดเดียวหรือทั้งหมดในชุดเดียว)

คำนวณศูนย์คลัสเตอร์ที่ใกล้ที่สุดไปยังวัตถุ / ศูนย์คลัสเตอร์ทั้งหมดที่อยู่ใกล้กว่าคลัสเตอร์ปัจจุบัน ถ้าเป็นคลัสเตอร์อื่น:

• หากคลัสเตอร์อื่นมีขนาดเล็กกว่าคลัสเตอร์ปัจจุบันให้ย้ายไปยังคลัสเตอร์ใหม่
• หากมีข้อเสนอการแลกเปลี่ยนจากคลัสเตอร์อื่น (หรือคลัสเตอร์ใด ๆ ที่มีระยะทางต่ำกว่า) ให้สลับการมอบหมายคลัสเตอร์สององค์ประกอบ (หากมีมากกว่าหนึ่งข้อเสนอให้เลือกรายการที่มีการปรับปรุงมากที่สุด)
• มิฉะนั้นให้ระบุข้อเสนอการแลกเปลี่ยนสำหรับคลัสเตอร์อื่น

ขนาดของคลัสเตอร์ยังคงไม่เปลี่ยนแปลง (+ - ความแตกต่างของเพดาน / พื้น) วัตถุจะถูกย้ายจากกลุ่มหนึ่งไปยังอีกกลุ่มหนึ่งตราบเท่าที่ยังส่งผลให้มีการปรับปรุงการประมาณค่า ดังนั้นจึงควรมาบรรจบกันในบางจุดเช่นค่า k มันอาจจะช้าลงเล็กน้อย (เช่นการทำซ้ำมากกว่า)

ฉันไม่ทราบว่าสิ่งนี้ได้รับการเผยแพร่หรือนำมาใช้ก่อน มันเป็นสิ่งที่ฉันจะลอง (ถ้าฉันจะลอง k-mean มีอัลกอริทึมการจัดกลุ่มที่ดีกว่ามาก)

จุดเริ่มต้นที่ดีอาจอยู่ที่การนำ k- meanมาใช้ในELKIซึ่งดูเหมือนว่าจะรองรับการเริ่มต้นที่แตกต่างกันสามแบบ (รวมถึง k-หมายถึง ++) และผู้เขียนกล่าวว่าพวกเขาต้องการมีกลยุทธ์การทำซ้ำที่แตกต่างกัน มีหลากหลายรูปแบบ (เช่น Lloyd, MacQueen, ... )

นี่เป็นปัญหาการเพิ่มประสิทธิภาพ เรามีไลบรารี java แบบโอเพ่นซอร์สซึ่งสามารถแก้ปัญหานี้ได้ (การจัดกลุ่มโดยที่ปริมาณต่อคลัสเตอร์ต้องอยู่ระหว่างช่วงชุด) คุณจะต้องมีคะแนนรวมสูงสุดไม่เกินสองสามพันคะแนน - ไม่เกิน 5,000 หรืออาจ 10,000

ห้องสมุดอยู่ที่นี่:

https://github.com/PGWelch/territorium/tree/master/territorium.core

ห้องสมุดเองมีการตั้งค่าสำหรับปัญหาประเภททางภูมิศาสตร์ / GIS ดังนั้นคุณจะเห็นการอ้างอิงถึง X และ Ys ละติจูดและลองจิจูดลูกค้าระยะทางและเวลา ฯลฯ คุณสามารถเพิกเฉยต่อองค์ประกอบ 'ทางภูมิศาสตร์' ได้และใช้มันเป็นของแท้ clusterer

คุณจัดเตรียมชุดของกลุ่มอินพุตเริ่มแรกที่ว่างเปล่าแต่ละกลุ่มมีปริมาณเป้าหมายขั้นต่ำและสูงสุด คลัสเตอร์จะกำหนดคะแนนให้กับกลุ่มอินพุตของคุณโดยใช้อัลกอริทึมการเพิ่มประสิทธิภาพที่ยึดตามการแก้ปัญหา (สลับ, ย้าย ฯลฯ ) ในการปรับให้เหมาะสมก่อนจะจัดลำดับความสำคัญให้แต่ละคลัสเตอร์อยู่ในช่วงปริมาณขั้นต่ำและสูงสุดจากนั้นจึงลดระยะห่างระหว่างจุดทั้งหมดในคลัสเตอร์และจุดศูนย์กลางของคลัสเตอร์ให้เหลือน้อยที่สุด

คุณให้ฟังก์ชันเมทริก (เช่นฟังก์ชันระยะทาง) ของตัวแก้ปัญหาระหว่างจุดที่ใช้อินเทอร์เฟซนี้:

https://github.com/PGWelch/territorium/blob/master/territorium.core/src/main/java/com/opendoorlogistics/territorium/problem/TravelMatrix.java

ตัวชี้วัดมีโครงสร้างจริง ๆ เพื่อส่งคืนทั้งระยะทางและ 'เวลา' เนื่องจากได้รับการออกแบบมาสำหรับปัญหาทางภูมิศาสตร์ตามการเดินทาง แต่สำหรับปัญหาการจัดกลุ่มตามอำเภอใจเพียงกำหนด 'เวลา' ให้เป็นศูนย์และระยะทางเพื่อเป็นตัวชี้วัดจริงของคุณ จุด

คุณจะตั้งค่าปัญหาของคุณในชั้นนี้:

https://github.com/PGWelch/territorium/blob/master/territorium.core/src/main/java/com/opendoorlogistics/territorium/problem/Problem.java

คะแนนของคุณจะเป็น 'ลูกค้า' และปริมาณของพวกเขาจะเป็น 1 ในระดับลูกค้าให้แน่ใจว่าคุณตั้งค่า costPerUnitTime = 0 และ costPerUnitDistance = 1 สมมติว่าคุณส่งคืนระยะทางเมตริกของคุณในฟิลด์ 'ระยะทาง' ที่ส่งคืนโดย TravelMatrix

https://github.com/PGWelch/territorium/blob/master/territorium.core/src/main/java/com/opendoorlogistics/territorium/problem/Customer.java

ดูที่นี่สำหรับตัวอย่างของการเรียกใช้ตัวแก้ปัญหา:

https://github.com/PGWelch/territorium/blob/master/territorium.core/src/test/java/com/opendoorlogistics/territorium/TestSolver.java

ฉันแนะนำให้ใช้การจำแนกกลุ่มบนกระดาษเมื่อไม่นานมานี้โดยการทำให้ข้อมูลเป็นปกติ (และการอ้างอิงในนั้น) โดยเฉพาะอย่างยิ่งส่วนที่ 2 พูดถึงความสมดุลของคลาสและข้อสมมติของคลัสเตอร์

เมื่อเร็ว ๆ นี้ฉันต้องการสิ่งนี้เองสำหรับชุดข้อมูลที่ไม่ใหญ่มาก คำตอบของฉันแม้ว่ามันจะใช้เวลาค่อนข้างนาน แต่ก็รับประกันได้ว่าจะมาบรรจบกันกับท้องถิ่นที่ดีที่สุด

def eqsc(X, K=None, G=None):
    "equal-size clustering based on data exchanges between pairs of clusters"
    from scipy.spatial.distance import pdist, squareform
    from matplotlib import pyplot as plt
    from matplotlib import animation as ani    
    from matplotlib.patches import Polygon   
    from matplotlib.collections import PatchCollection
    def error(K, m, D):
        """return average distances between data in one cluster, averaged over all clusters"""
        E = 0
        for k in range(K):
            i = numpy.where(m == k)[0] # indeces of datapoints belonging to class k
            E += numpy.mean(D[numpy.meshgrid(i,i)])
        return E / K
    numpy.random.seed(0) # repeatability
    N, n = X.shape
    if G is None and K is not None:
        G = N // K # group size
    elif K is None and G is not None:
        K = N // G # number of clusters
    else:
        raise Exception('must specify either K or G')
    D = squareform(pdist(X)) # distance matrix
    m = numpy.random.permutation(N) % K # initial membership
    E = error(K, m, D)
    # visualization
    #FFMpegWriter = ani.writers['ffmpeg']
    #writer = FFMpegWriter(fps=15)
    #fig = plt.figure()
    #with writer.saving(fig, "ec.mp4", 100):
    t = 1
    while True:
        E_p = E
        for a in range(N): # systematically
            for b in range(a):
                m[a], m[b] = m[b], m[a] # exchange membership
                E_t = error(K, m, D)
                if E_t < E:
                    E = E_t
                    print("{}: {}<->{} E={}".format(t, a, b, E))
                    #plt.clf()
                    #for i in range(N):
                        #plt.text(X[i,0], X[i,1], m[i])
                    #writer.grab_frame()
                else:
                    m[a], m[b] = m[b], m[a] # put them back
        if E_p == E:
            break
        t += 1           
    fig, ax = plt.subplots()
    patches = []
    for k in range(K):
        i = numpy.where(m == k)[0] # indeces of datapoints belonging to class k
        x = X[i]        
        patches.append(Polygon(x[:,:2], True)) # how to draw this clock-wise?
        u = numpy.mean(x, 0)
        plt.text(u[0], u[1], k)
    p = PatchCollection(patches, alpha=0.5)        
    ax.add_collection(p)
    plt.show()

if __name__ == "__main__":
    N, n = 100, 2    
    X = numpy.random.rand(N, n)
    eqsc(X, G=3)