當前位置:首頁 » 編程語言 » kmeans演算法c語言
擴展閱讀
webinf下怎麼引入js 2023-08-31 21:54:13
堡壘機怎麼打開web 2023-08-31 21:54:11

kmeans演算法c語言

發布時間: 2022-08-09 19:50:02

㈠ 急求: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;
}
}