㈠ 急求:k-Means聚類演算法實現
K-MEANS演算法:
k-means 演算法接受輸入量 k ；然後將n個數據對象劃分為 k個聚類以便使得所獲得的聚類滿足：同一聚類中的對象相似度較高；而不同聚類中的對象相似度較小。聚類相似度是利用各聚類中對象的均值所獲得一個「中心對象」（引力中心）來進行計算的。
k-means 演算法的工作過程說明如下：首先從n個數據對象任意選擇 k 個對象作為初始聚類中心；而對於所剩下其它對象，則根據它們與這些聚類中心的相似度（距離），分別將它們分配給與其最相似的（聚類中心所代表的）聚類；然後再計算每個所獲新聚類的聚類中心（該聚類中所有對象的均值）；不斷重復這一過程直到標准測度函數開始收斂為止。一般都採用均方差作為標准測度函數. k個聚類具有以下特點：各聚類本身盡可能的緊湊，而各聚類之間盡可能的分開。
具體如下：
輸入：k, data[n];
（1） 選擇k個初始中心點，例如c[0]=data[0],…c[k-1]=data[k-1];
（2） 對於data[0]….data[n], 分別與c[0]…c[n-1]比較，假定與c[i]差值最少，就標記為i;
（3） 對於所有標記為i點，重新計算c[i]={ 所有標記為i的data[j]之和}/標記為i的個數；
（4） 重復(2)(3),直到所有c[i]值的變化小於給定閾值。
演算法實現起來應該很容易，就不幫你編寫代碼了。
㈡ 求一個用c語言寫的基於K-means聚類的圖像分割代碼
基於Kmeans圖像分割
..................\程序
..................\....\ChildFrm.cpp
..................\....\ChildFrm.h
..................\....\Debug
..................\....\Dib.cpp
..................\....\Dib.h
..................\....\MainFrm.cpp
..................\....\MainFrm.h
..................\....\ReadMe.txt
..................\....\res
..................\....\...\trace.rc2
..................\....\Resource.h
..................\....\StdAfx.cpp
..................\....\StdAfx.h
..................\....\trace.aps
..................\....\trace.clw
..................\....\trace.cpp
..................\....\trace.dsp
..................\....\trace.dsw
..................\....\trace.h
..................\....\trace.ncb
..................\....\trace.opt
..................\....\trace.plg
..................\....\trace.rc
..................\....\traceDoc.cpp
..................\....\traceDoc.h
..................\....\traceView.cpp
..................\....\traceView.h
㈢ 高分求一個C語言編寫的聚類分析演算法!!!
用c語言寫？有點瘋狂了，現在都用python寫，你要的話我發給你，很多函數庫，在c語言下不知道能不能找到呢
㈣ kmeans聚類演算法是什麼
K-means演算法是最為經典的基於劃分的聚類方法，是十大經典數據挖掘演算法之一。K-means演算法的基本思想是：以空間中k個點為中心進行聚類，對最靠近他們的對象歸類。通過迭代的方法，逐次更新各聚類中心的值，直至得到最好的聚類結果。
聚類屬於無監督學習，以往的回歸、樸素貝葉斯、SVM等都是有類別標簽y的，也就是說樣例中已經給出了樣例的分類。而聚類的樣本中卻沒有給定y，只有特徵x，比如假設宇宙中的星星可以表示成三維空間中的點集。
(4)kmeans演算法c語言擴展閱讀：
k個聚類以便使得所獲得的聚類滿足：同一聚類中的對象相似度較高；而不同聚類中的對象相似度較小。聚類相似度是利用各聚類中對象的均值所獲得一個「中心對象」（引力中心）來進行計算的。
（1）適當選擇c個類的初始中心；
（2）在第k次迭代中，對任意一個樣本，求其到c個中心的距離，將該樣本歸到距離最短的中心所在的類；
（3）利用均值等方法更新該類的中心值；
（4）對於所有的c個聚類中心，如果利用（2）（3）的迭代法更新後，值保持不變，則迭代結束，否則繼續迭代。
㈤ kmeans聚類演算法是什麼
kmeans聚類演算法是將樣本聚類成k個簇（cluster）。
K-Means演算法的思想很簡單，對於給定的樣本集，按照樣本之間的距離大小，將樣本集劃分為K個簇。讓簇內的點盡量緊密的連在一起，而讓簇間的距離盡量的大。在實際K-Mean演算法中，我們一般會多次運行圖c和圖d，才能達到最終的比較優的類別。
用數據表達式表示
假設簇劃分為$(C_1,C_2,...C_k)$，則我們的目標是最小化平方誤差E：$$ E = sumlimits_{i=1}^ksumlimits_{x in C_i} ||x-mu_i||_2^2$$。
其中$mu_i$是簇$C_i$的均值向量，有時也稱為質心，表達式為：$$mu_i = frac{1}{|C_i|}sumlimits_{x in C_i}x$$。
㈥ 急求用C#寫的K-means演算法的源程序 不懂的別來忽悠我
日 這都什麼人？ 一點共享精神也沒有！！自己動手豐衣足食 ，自己來給大家分享 下（8個點聚成3個簇 輸出不明顯 有待改進）
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text.RegularExpressions;
using System.Data.SqlClient;
using System.Windows.Forms;
namespace kmeans
{
public partial class Form1 : Form
{
public SqlConnection conn= new SqlConnection("server=localhost;uid=sa;pwd=123;database=Stu_info");
public Form1()
{
InitializeComponent();
}
private void button3_Click(object sender, EventArgs e)
{
/*float numCluster = float.Parse (textBox2.Text);
if (textBox2.Text == "")
{
MessageBox.Show("請輸入期望簇的數目！");
return;
}
this.numCluster = float.Parse(numCluster);*/
int k = 3; //簇的數目
int n = 8;
List<points> lp=new List<points>(); //n條數據
lp.Add(new points(2, 10));
lp.Add(new points(5, 8));
lp.Add(new points(1, 2));
lp.Add(new points(2, 5));
lp.Add(new points(8, 4));
lp.Add(new points(7, 5));
lp.Add(new points(6, 4));
lp.Add(new points(4, 9));
/*lp.Add(new points(1,4 ));
lp.Add(new points(7,2));*/
string[] clusters = new string[k]; //k個簇,每個簇存儲數據在points中的位置，數據之間用","分開
points[] centers = new points[k]; //k個簇的中心
points[] preCenters = new points[k];//前一次計算的簇中心
Regex r = new Regex(",");
for (int i = 0; i < k; i++) //取前k個對象作為初始的簇中心
{
centers[i] = new points(lp[i].X, lp[i].Y);
}
bool stop = false;
while (!stop)
{
for (int i = 0; i < clusters.Length; i++)//清空簇中的數據
{
clusters[i] = null;
}
for (int i = 0; i < n; i++)//搜索所有對象
{
double distance = points.DistanceBetween(lp[i], centers[0]);
double temp;
int num = 0;
for (int j = 0; j < k; j++)//搜索k個簇，比較對象與簇中心的距離，將與當前對象距離最小的簇的編號放入num
{
if ((temp = points.DistanceBetween(lp[i], centers[j])) < distance) { num = j; distance = temp; }
}
clusters[num] = clusters[num] + i + ",";
}
for (int i = 0; i < k; i++)
{
preCenters[i] = new points(centers[i].X, centers[i].Y);//保存先前的簇中心
}
for (int i = 0; i < k; i++)
{
centers[i].X = 0;
centers[i].Y = 0;
if (clusters[i] != null)
{
string[] pointsNum = r.Split(clusters[i]);
for (int j = 0; j < pointsNum.Length - 1; j++)
{
centers[i].X = centers[i].X + lp[Convert.ToInt32(pointsNum[j])].X;
centers[i].Y = centers[i].Y + lp[Convert.ToInt32(pointsNum[j])].Y;
}
centers[i].X = Convert.ToDouble(centers[i].X) / (pointsNum.Length - 1);
centers[i].Y = Convert.ToDouble(centers[i].Y) / (pointsNum.Length - 1);
}
}
stop = true;
for (int i = 0; i < k; i++)
{
if (preCenters[i].X != centers[i].X || preCenters[i].Y != centers[i].Y) stop = false;
}
}
listBox1.Items.Clear();
for (int i = 0; i < k; i++)//輸出每個簇中數據所在的位置
{
string[] nums = r.Split(clusters[i]);
for (int j = 0; j < nums.Length - 1; j++)
{
//Console.Write("({0},{1}) ", lp[Convert.ToInt32(nums[j])].X, lp[Convert.ToInt32(nums[j])].Y);
listBox1.Items.Add(lp[Convert.ToInt32(nums[j])].X+","+lp[Convert.ToInt32(nums[j])].Y);
}
//Console.Write('\n');
}
//Console.Read();
}
private void button2_Click_1(object sender, EventArgs e)
{
this.Close();
}
private void button1_Click_1(object sender, EventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.ShowDialog();
textBox1.Text = dlg.FileName;
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Collections;
using System.Text.RegularExpressions;
using System.Data.Odbc;
namespace kmeans
{
public class points
{
private double x;
private double y;
public double X
{
get { return x; }
set { x = value; }
}
public double Y
{
get { return y; }
set { y = value; }
}
public points()
{
x = 0;
y = 0;
}
public points(double xx, double yy)
{
x = xx;
y = yy;
}
public void SetPoint(double xx, double yy)
{
x = xx;
y = yy;
}
public static double DistanceBetween(points p1,points p2)
{
double distance;
return distance=Math.Pow((p1.X - p2.X) * (p1.X - p2.X) + (p1.Y - p2.Y) * (p1.Y - p2.Y),1.0/2);
}
}
}
㈦ 大數據十大經典演算法之k-means
大數據十大經典演算法之k-means
k均值演算法基本思想：
K均值演算法是基於質心的技術。它以K為輸入參數，把n個對象集合分為k個簇，使得簇內的相似度高，簇間的相似度低。
處理流程：
1、為每個聚類確定一個初始聚類中心，這樣就有k個初始聚類中心；
2、將樣本按照最小距離原則分配到最鄰近聚類
3、使用每個聚類中的樣本均值作為新的聚類中心
4、重復步驟2直到聚類中心不再變化
5、結束，得到K個聚類
劃分聚類方法對數據集進行聚類時的要點：
1、選定某種距離作為數據樣本間的相似性度量，通常選擇歐氏距離。
2、選擇平價聚類性能的准則函數
用誤差平方和准則函數來評價聚類性能。
3、相似度的計算分局一個簇中對象的平均值來進行
K均值演算法的優點：
如果變數很大，K均值比層次聚類的計算速度較快（如果K很小）；
與層次聚類相比，K均值可以得到更緊密的簇，尤其是對於球狀簇；
對於大數據集，是可伸縮和高效率的；
演算法嘗試找出使平方誤差函數值最小的k個劃分。當結果簇是密集的，而簇與簇之間區別明顯的時候，效果較好。
K均值演算法缺點：
最後結果受初始值的影響。解決辦法是多次嘗試取不同的初始值。
可能發生距離簇中心m最近的樣本集為空的情況，因此m得不到更新。這是一個必須處理的問題，但我們忽略該問題。
不適合發現非凸面形狀的簇，並對雜訊和離群點數據較敏感，因為少量的這類數據能夠對均值產生較大的影響。
K均值演算法的改進：
樣本預處理。計算樣本對象量量之間的距離，篩掉與其他所有樣本那的距離和最大的m個對象。
初始聚類中心的選擇。選用簇中位置最靠近中心的對象，這樣可以避免孤立點的影響。
K均值演算法的變種：
K眾數（k-modes）演算法，針對分類屬性的度量和更新質心的問題而改進。
EM（期望最大化）演算法
k-prototype演算法
這種演算法不適合處理離散型屬性，但是對於連續型具有較好的聚類效果。
k均值演算法用途：
圖像分割；
衡量足球隊的水平；
下面給出代碼：
#include <iostream>
#include <vector>
//auther archersc
//JLU
namespace CS_LIB
{
using namespace std;
class Kmean
{
public:
//輸入格式
//數據數量N 維度D
//以下N行，每行D個數據
istream& loadData(istream& in);
//輸出格式
//聚類的數量CN
//中心維度CD
//CN行，每行CD個數據
//數據數量DN
//數據維度DD
//以下DN組，每組的第一行兩個數值DB, DDis
//第二行DD個數值
//DB表示改數據屬於一類，DDis表示距離改類的中心的距離
ostream& saveData(ostream& out);
//設置中心的數量
void setCenterCount(const size_t count);
size_t getCenterCount() const;
//times最大迭代次數， maxE ,E(t)表示第t次迭代後的平方誤差和，當|E(t+1) - E(t)| < maxE時終止
void clustering(size_t times, double maxE);
private:
double calDistance(vector<double>& v1, vector<double>& v2);
private:
vector< vector<double> > m_Data;
vector< vector<double> > m_Center;
vector<double> m_Distance;
vector<size_t> m_DataBelong;
vector<size_t> m_DataBelongCount;
};
}
#include "kmean.h"
#include <ctime>
#include <cmath>
#include <cstdlib>
//auther archersc
//JLU
namespace CS_LIB
{
template<class T>
void swap(T& a, T& b)
{
T c = a;
a = b;
b = c;
}
istream& Kmean::loadData(istream& in)
{
if (!in){
cout << "input error" << endl;
return in;
}
size_t dCount, dDim;
in >> dCount >> dDim;
m_Data.resize(dCount);
m_DataBelong.resize(dCount);
m_Distance.resize(dCount);
for (size_t i = 0; i < dCount; ++i){
m_Data[i].resize(dDim);
for (size_t j = 0; j < dDim; ++j){
in >> m_Data[i][j];
}
}
return in;
}
ostream& Kmean::saveData(ostream& out)
{
if (!out){
cout << "output error" << endl;
return out;
}
out << m_Center.size();
if (m_Center.size() > 0)
out << << m_Center[0].size();
else
out << << 0;
out << endl << endl;
for (size_t i = 0; i < m_Center.size(); ++i){
for (size_t j = 0; j < m_Center[i].size(); ++j){
out << m_Center[i][j] << ;
}
out << endl;
}
out << endl;
out << m_Data.size();
if (m_Data.size() > 0)
out << << m_Data[0].size();
else
out << << 0;
out << endl << endl;
for (size_t i = 0; i < m_Data.size(); ++i){
out << m_DataBelong[i] << << m_Distance[i] << endl;
for (size_t j = 0; j < m_Data[i].size(); ++j){
out << m_Data[i][j] << ;
}
out << endl << endl;
}
return out;
}
void Kmean::setCenterCount(const size_t count)
{
m_Center.resize(count);
m_DataBelongCount.resize(count);
}
size_t Kmean::getCenterCount() const
{
return m_Center.size();
}
void Kmean::clustering(size_t times, double maxE)
{
srand((unsigned int)time(NULL));
//隨機從m_Data中選取m_Center.size()個不同的樣本點作為初始中心。
size_t *pos = new size_t[m_Data.size()];
size_t i, j, t;
for (i = 0; i < m_Data.size(); ++i){
pos[i] = i;
}
for (i = 0; i < (m_Data.size() << 1); ++i){
size_t s1 = rand() % m_Data.size();
size_t s2 = rand() % m_Data.size();
swap(pos[s1], pos[s2]);
}
for (i = 0; i < m_Center.size(); ++i){
m_Center[i].resize(m_Data[pos[i]].size());
for (j = 0; j < m_Data[pos[i]].size(); ++j){
m_Center[i][j] = m_Data[pos[i]][j];
}
}
delete []pos;
double currE, lastE;
for (t = 0; t < times; ++t){
for (i = 0; i < m_Distance.size(); ++i)
m_Distance[i] = LONG_MAX;
for (i = 0; i < m_DataBelongCount.size(); ++i)
m_DataBelongCount[i] = 0;
currE = 0.0;
for (i = 0; i < m_Data.size(); ++i){
for (j = 0; j < m_Center.size(); ++j){
double dis = calDistance(m_Data[i], m_Center[j]);
if (dis < m_Distance[i]){
m_Distance[i] = dis;
m_DataBelong[i] = j;
}
}
currE += m_Distance[i];
m_DataBelongCount[m_DataBelong[i]]++;
}
cout << currE << endl;
if (t == 0 || fabs(currE - lastE) > maxE)
lastE = currE;
else
break;
for (i = 0; i < m_Center.size(); ++i){
for (j = 0; j < m_Center[i].size(); ++j)
m_Center[i][j] = 0.0;
}
for (i = 0; i < m_DataBelong.size(); ++i){
for (j = 0; j < m_Data[i].size(); ++j){
m_Center[m_DataBelong[i]][j] += m_Data[i][j] / m_DataBelongCount[m_DataBelong[i]];
}
}
}
}
double Kmean::calDistance(vector<double>& v1, vector<double>& v2)
{
double result = 0.0;
for (size_t i = 0; i < v1.size(); ++i){
result += (v1[i] - v2[i]) * (v1[i] - v2[i]);
}
return pow(result, 1.0 / v1.size());
//return sqrt(result);
}
}
#include <iostream>
#include <fstream>
#include "kmean.h"
using namespace std;
using namespace CS_LIB;
int main()
{
ifstream in("in.txt");
ofstream out("out.txt");
Kmean kmean;
kmean.loadData(in);
kmean.setCenterCount(4);
kmean.clustering(1000, 0.000001);
kmean.saveData(out);
return 0;
}
㈧ 使用K-Means 演算法進行聚類分析程序
你這是四維數據，我這是一維數據kmeans，你試試吧
#include<iostream>
#include<math.h>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
int N; //數據個數
int K; //集合個數
int *CenterIndex; //質心索引集合,即屬於第幾個參考點
double *Center; //質心集合
double *CenterCopy;
double *DataSet;
double **Cluster;
int *Top;
/*演算法描述:
C-Fuzzy均值聚類演算法採用的是給定類的個數K,將N個元素(對象)分配到K個類中去使得類內對象之間的相似性最大,而類之間的相似性最小 */
//函數聲明部分
void InitData();
void InitCenter();
void CreateRandomArray(int n,int k,int *centerIndex);
void CopyCenter();
void UpdateCluster();
void UpdateCenter();
int GetIndex(double value,double *centerIndex);
void AddtoCluster(int index,double value);
void print();
bool IsEqual(double *center,double *center);
int main()
{
int Flag=1;
InitData();
while(Flag)//無限次循環
{
UpdateCluster();
UpdateCenter();
if(IsEqual(Center,CenterCopy))
{
Flag=0;
}
else
{
CopyCenter();
}
}
print();
getchar();
system("pause");
}
void InitData()
{
int i=0;
int a;
cout<<"請輸入數據元素的個數: ";
cin>>N;
cout<<"請輸入分類數: ";
cin>>K;
if(K>N)
{
return;
}
CenterIndex =new int [sizeof(int)];
Center =new double [sizeof(double)*K];
CenterCopy =new double [sizeof(double)*K];
DataSet =new double [sizeof(double)*N];
Cluster =new double* [sizeof(double*)*K];
Top =new int [sizeof(int)*K];
//初始化K個類的集合
for(i=0;i<K;i++)
{
Cluster[i]=new double [sizeof(double)*N];
Top[i]=0;
}
cout<<"請輸入數據"<<endl;
for(i=0;i<N;i++)
{
cin>>a;
DataSet[i]=a;
}
//初始化質心集合
InitCenter();
UpdateCluster();
}
void InitCenter()//初始化中心點（參照點）
{
int i=0;
//產生隨即的K個<N的不同的序列
CreateRandomArray(N,K,CenterIndex);
for(i=0;i<K;i++)
{
Center[i]=DataSet[CenterIndex[i]];
}
CopyCenter();
}
void CreateRandomArray(int n,int k,int *centerIndex)//產生可以隨輸出控制的 k與n （可舍棄）
{
int i=0,j=0;
for(i=0;i<K;i++)
{
int a=rand()%n;
for(j=0;j<i;j++)
{
if(centerIndex[j]==a)
break;
}
if(j>=i)
{
centerIndex[i]=a;
}
else
{
i--;
}
}
}
void CopyCenter()//將舊的中心點保留以作比較
{
int i=0;
for(i=0;i<K;i++)
{
CenterCopy[i]=Center[i];
}
}
void UpdateCluster()//
{
int i=0;
int tindex;
for(;i<K;i++)
{
Top[i]=0;
}
for(i=0;i<N;i++)
{
tindex=GetIndex(DataSet[i],Center);
AddtoCluster(tindex,DataSet[i]);
}
}
int GetIndex(double value,double *center)//判斷屬於哪個參照點
{
int i=0;
int index=i;
double min=fabs(value-center[i]);
for(i=0;i<K;i++)
{
if(fabs(value-center[i])<min)
{
index=i;
min=fabs(value-center[i]);
}
}
return index;
}
void AddtoCluster(int index,double value)//統計每組個數（用於均值法求新的參照點）
{
Cluster[index][Top[index]]=value;
Top[index]++;
}
void UpdateCenter()//更新參照點
{
int i=0,j=0;
double sum;
for(i=0;i<K;i++)
{
sum=0.0;
for(j=0;j<Top[i];j++)
{
sum+=Cluster[i][j];
}
if(Top[i]>0)
{
Center[i]=sum/Top[i];
}
}
}
bool IsEqual(double *center,double*center)//
{
int i;
for(i=0;i<K;i++)
{
if(fabs(center[i]!=center[i]))
return 0;
}
return 1;
}
void print()//
{
int i,j;
cout<<"===================================="<<endl;
for(i=0;i<K;i++)
{
cout<<"第"<<i<<"組：質心為："<<Center[i]<<endl;
cout<<"數據元素為:\n";
for(j=0;j<Top[i];j++)
{
cout<<Cluster[i][j]<<'\t';
}
cout<<endl;
}
}