OPTICS算法的C语言实现

最新推荐文章于 2023-11-24 16:07:04 发布
最新推荐文章于 2023-11-24 16:07:04 发布
阅读量3.3k 收藏 13
点赞数 2
分类专栏： 复杂网络 算法学习 文章标签： 聚类算法 OPTICS算法的C语言实现代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/robin_Xu_shuai/article/details/51755458
版权

在这个方法中，不像前面的相关的聚类的文章中产生数据集合的聚类结果，而是产生一个基于密度的表示数据的固有的聚类结构的一个增广的排序，除了应用到DBSCAN中的相关的概念（核心对象， 直接密度可达，密度可达，和密度相连），有增加了两个概念， 一个是核心距离：即使得一个object满足称为核心对象的最小的距离（即，在用户输入的ε和MinPtr的情况下成为核心对象的最小的距离，如果改对象不是在ε和MinPtr的情况下的核心对象，则核心距离为未定义的值， 需要注意的是，这两个参数的输入对于聚类的结果是没有太大的影响的， 也就是说，OPTICS算法对于输入不敏感）， 第二个引入概念是可达距离，即一个对象到达另一个核心对象的欧几里得距离和核心对象的核心距离的最大值。之所以要引入这两个概念，是因为：改方法的核心思想是，要首先找到密度高的区域。而在程序的运行过程中使得可达距离逐渐的变小的过程就是达到这个目的的过程。

算法的描述如下：



代码实现如下

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>

#define INITIAL_SIZE	5000
#define INCREASEMENT	500
#define UNDEFINE	50.0

typedef struct Core_Object
{
	int objectID;
	int* directlyDensityReachable_ID;
	int size_DDR;
	int capacity;
	double reachabilityDistance;
	double coreDistance;
	int processed;
}Core_Object;

Core_Object* core_object_set;
Core_Object* object_neighbor;

typedef struct QueueNode
{
	int data;
	struct QueueNode* next;
	double reachabilityDistance;
}QueueNode;
typedef struct LinkQueue
{
	QueueNode* front;
	QueueNode* rear;
}LinkQueue;

typedef struct Cluster_Order_Node
{
	int objectID;
	double core_distance;
	double reachability_distance;
}Cluster_Order_Node;
Cluster_Order_Node* cluster_ordering;

double radius;
int MinPts;
char filename[200];
int data_size;
int data_dimension;
int core_object_size;
int cluster_order_counter = 1;

double** dataBase;
double** distanceMatrix;

void initial();
void readDataFromFile();
double calculateDistance_betweenTwoObject(int, int);
void calculateDistanceMatrix();
void createCoreOjectSet();
void createObjectNeighborSet();
void OPTICS();
void setCoreDistance(int);
int isProcessed(int);
void saveToClusterOrdering(int, int);
void update(int);
void ExpandClusterOrder(int);
void writeClusterOrdering2File();

//queue
void initialQueue(LinkQueue*);
void insertQueue(LinkQueue*, int, double);
void deleteQueue(LinkQueue*, int*);
int isQueueEmpty(LinkQueue);
void printQueue(LinkQueue);
void decrease(LinkQueue*, int, double);
void testQueue();

LinkQueue orderSeeds;
//queue

int main(int argc, char* argv[])
{
	if( argc != 6 )
	{
		printf("This algorithm require four parameters"
				"\n\tthe neighborhood distance"
				"\n\tthe MinPts"
				"\n\tthe filename contains data"
				"\n\tthe size of data"
				"\n\tthe dimension of data"
				"\n");
		exit(0);
	}

	radius = atof(argv[1]);
	MinPts = atoi(argv[2]);
	strcat(filename, argv[3]);
	data_size = atoi(argv[4]);
	data_dimension = atoi(argv[5]);

	initial();
	readDataFromFile();
	calculateDistanceMatrix();
	createCoreOjectSet();
	createObjectNeighborSet();

	//testQueue();

	OPTICS();
	writeClusterOrdering2File();
	return 0;
}

/*
 * do some initialization work:
 * 	create the dynamic array @dataBase which be used to store the origin data
 * */
void initial()
{
	// initial dataBase
	dataBase = (double**)malloc(sizeof(double*) * (data_size + 1));
	if( !dataBase )
	{
		printf("initial: dataBase malloc error: 0\n");
		exit(0);
	}
	int i;
	for( i = 1; i <= data_size; i++ )
	{
		dataBase[i] = (double*)malloc(sizeof(double) * (data_dimension + 1));
		if( !dataBase[i] )
		{
			printf("initial: dataBase malloc error: %d\n", i);
			exit(0);
		}
	}

	// initial distance matrix 
	distanceMatrix = (double**)malloc(sizeof(double*) * (data_size + 1));
	if( !distanceMatrix )
	{
		printf("initial: distance matrix malloc error: 0");
		exit(0);
	}
	for( i = 1; i <= data_size; i++ )
	{
		distanceMatrix[i] = (double*)malloc(sizeof(double) * (data_size + 1));
		if( !distanceMatrix[i] )
		{
			printf("initial: malloc distance matrix error: %d\n", i);
			exit(0);
		}
	}

	// initial cluster_ordering
	cluster_ordering = (Cluster_Order_Node*)malloc(sizeof(Cluster_Order_Node) * (data_size + 1));
	if( !cluster_ordering )
	{
		printf("initial: cluster_ordering malloc error");
		exit(0);
	}
}

/*
 * read original data from @filename to array @dataBase
 * */
void readDataFromFile()
{
	FILE* fread;
	if( NULL == (fread = fopen(filename, "r")) )
	{
		printf("open file(%s) error\n", filename);
		exit(0);
	}
	int i, j;
	for( i = 1; i <= data_size; i++ )
	{
		for( j = 1; j <= data_dimension; j++ )
		{
			if( 1 != fscanf(fread, "%lf ", &dataBase[i][j]))
			{
				printf("dataBase fscanf error: (%d, %d)", i, j);
				exit(0);
			}
		}
	}
}

/*
 * calculate distance between two object
 * */
double calculateDistance_betweenTwoObject(int object_1, int object_2)
{
	double result = 0.0;
	int i;
	for( i = 1; i <= data_dimension; i++ )
	{
		result += pow(dataBase[object_1][i] - dataBase[object_2][i], 2);
	}	
	return sqrt(result);
}

/*
 * calculate the distance matrix
 * */
void calculateDistanceMatrix()
{
	int i, j;
	for( i = 1; i <= data_size; i++ )
	{
		distanceMatrix[i][i] = 0.0;
		for( j = i + 1; j <= data_size; j++ )
		{
			distanceMatrix[i][j] = calculateDistance_betweenTwoObject(i, j);
			distanceMatrix[j][i] = distanceMatrix[i][j];
			if( distanceMatrix[i][j] <= radius )
			{
				distanceMatrix[i][0]++;
				distanceMatrix[j][0]++;
			}
		}
	}
	//statistic the number of core object
	for( i = 1; i <= data_size; i++ )
		if( distanceMatrix[i][0] >= MinPts - 1 )
			core_object_size++;
}

/*
 * 
 * */
void createCoreOjectSet()
{
	core_object_set = (Core_Object*)malloc(sizeof(Core_Object) * (core_object_size + 1));
	if( !core_object_set )
	{
		printf("core_object_set malloc error!");
		exit(0);
	}
	int i, j;
	for( i = 1; i <= core_object_size; i++ )
	{
		core_object_set[i].directlyDensityReachable_ID = (int*)malloc(sizeof(int) * (INITIAL_SIZE + 1));
		if( !core_object_set[i].directlyDensityReachable_ID )
		{
			printf("core_object_set's directlyDensityReachable malloc error\n");
			exit(0);
		}
		core_object_set[i].capacity = INITIAL_SIZE;
		core_object_set[i].size_DDR = 0;
	}

	int counter_CO = 1;		//counter_CoreObject
	for( i = 1; i <= data_size; i++ )
	{
		if( distanceMatrix[i][0] >= MinPts - 1 )
		{
			core_object_set[counter_CO].objectID = i;
			for( j = 1; j <= data_size; j++ )
			{
				if( distanceMatrix[i][j] <= radius && i != j )
				{
					core_object_set[counter_CO].size_DDR++;
					if( core_object_set[counter_CO].size_DDR > core_object_set[counter_CO].capacity )
					{
						core_object_set[counter_CO].directlyDensityReachable_ID = (int*)realloc(core_object_set[counter_CO].directlyDensityReachable_ID, sizeof(int) * (core_object_set[counter_CO].capacity + INCREASEMENT + 1));
						if( !core_object_set[counter_CO].directlyDensityReachable_ID )
						{
							printf("realloc is error: %d ", counter_CO);
							exit(0);
						}
						core_object_set[counter_CO].capacity += INCREASEMENT;
					}
					core_object_set[counter_CO].directlyDensityReachable_ID[core_object_set[counter_CO].size_DDR] = j;
				}
			}
			counter_CO++;
		}
	}
}

/*
 * 
 * */
void createObjectNeighborSet()
{
	object_neighbor = (Core_Object*)malloc(sizeof(Core_Object) * (data_size + 1));
	if( !object_neighbor )
	{
		printf("object_neighbor malloc error!\n");
		exit(0);
	}
	int i, j;
	for( i = 1; i <= data_size; i++ )
	{
		object_neighbor[i].objectID = i;
		object_neighbor[i].size_DDR = 0;
		object_neighbor[i].capacity = INITIAL_SIZE;
		object_neighbor[i].directlyDensityReachable_ID = (int*)malloc(sizeof(int) * (INITIAL_SIZE + 1));
		object_neighbor[i].processed = 0;
		object_neighbor[i].coreDistance = UNDEFINE;
		object_neighbor[i].reachabilityDistance = UNDEFINE;
	}

	for( i = 1; i <= data_size; i++ )
	{
		for( j = 1; j <= data_size; j++ )
		{
			if( distanceMatrix[i][j] <= radius && i != j )
			{
				object_neighbor[i].size_DDR++;
				if( object_neighbor[i].size_DDR > object_neighbor[i].capacity )
				{
					object_neighbor[i].directlyDensityReachable_ID = (int*)realloc(object_neighbor[i].directlyDensityReachable_ID, sizeof(int) * (object_neighbor[i].capacity + INCREASEMENT + 1));
						if( !object_neighbor[i].directlyDensityReachable_ID )
						{
							printf("object_neighbor realloc error: %d\n", i);
							exit(0);
						}
					object_neighbor[i].capacity += INCREASEMENT;
				}
				object_neighbor[i].directlyDensityReachable_ID[object_neighbor[i].size_DDR] = j;
			}
		}
	}
}

/****************************************************************************************************
 ****************************************************************************************************
 *                                         OPTICS algorithm
 ****************************************************************************************************
 ****************************************************************************************************/
void OPTICS()
{
	printf("\n\n");
	initialQueue(&orderSeeds);
	int i;
	for( i = 1; i <= data_size; i++ )
	{
		if( isProcessed(i) != 1 )
		{
			printf("\n\n--------------expandClusterOrder: %d------------------\n\n", i);
			ExpandClusterOrder(i);
		}
	}
}

int isProcessed(int objectID)
{
	return object_neighbor[objectID].processed;
}

void ExpandClusterOrder(int objectID)
{
	int currentObjectID;
	object_neighbor[objectID].processed = 1;
	object_neighbor[objectID].reachabilityDistance = UNDEFINE;
	setCoreDistance(objectID);
	saveToClusterOrdering(objectID, cluster_order_counter++);
	if( object_neighbor[objectID].coreDistance != UNDEFINE )
	{
		update(objectID);
		while( !isQueueEmpty(orderSeeds) )
		{
			deleteQueue(&orderSeeds, ¤tObjectID);
			object_neighbor[currentObjectID].processed = 1;
			setCoreDistance(currentObjectID);
			saveToClusterOrdering(currentObjectID, cluster_order_counter++);
			if( object_neighbor[currentObjectID].coreDistance != UNDEFINE )
			{
				update(currentObjectID);
			}
		}
	}
}

void setCoreDistance(int objectID)
{
	double* increase;
	increase = (double*)malloc(sizeof(double) * (object_neighbor[objectID].size_DDR + 1));
	if( !increase )
	{
		printf("in function setCoreDistance malloc error\n");
		exit(0);
	}
	int i, j;
	for( i = 1; i <= object_neighbor[objectID].size_DDR; i++ )
	{
		increase[i] = distanceMatrix[objectID][object_neighbor[objectID].directlyDensityReachable_ID[i]];
	}
	
	int min_index;
	double min_value;
	for( i = 1; i <= object_neighbor[objectID].size_DDR; i++ )
	{
		min_index = i;
		min_value = increase[i];
		for( j = i + 1; j <= object_neighbor[objectID].size_DDR; j++ )
		{
			if( increase[j] < min_value )
			{
				min_index = j;
				min_value = increase[j];
			}
		}
		if( min_index != i )
		{
			increase[0] = increase[min_index];
			increase[min_index] = increase[i];
			increase[i] = increase[0];
		}
	}

	if( object_neighbor[objectID].size_DDR >= MinPts - 1 )
	{
		object_neighbor[objectID].coreDistance = increase[MinPts - 1];
	}else
	{
		object_neighbor[objectID].coreDistance = UNDEFINE;
	}
}

void saveToClusterOrdering(int objectID, int counter)
{
	cluster_ordering[counter].objectID = objectID;
	cluster_ordering[counter].core_distance = object_neighbor[objectID].coreDistance;
	cluster_ordering[counter].reachability_distance = object_neighbor[objectID].reachabilityDistance;
}

/*
 *
 * */
void update(int centerObjectID)
{
	double new_reachabilityDistance = 0.0;
	int i;
	int objectID;
	for( i = 1; i <= object_neighbor[centerObjectID].size_DDR; i++ )
	{
		objectID = object_neighbor[centerObjectID].directlyDensityReachable_ID[i];
		if( object_neighbor[objectID].processed != 1 )
		{
			new_reachabilityDistance = object_neighbor[centerObjectID].coreDistance > distanceMatrix[centerObjectID][objectID] ? object_neighbor[centerObjectID].coreDistance : distanceMatrix[centerObjectID][objectID];
			if( object_neighbor[objectID].reachabilityDistance == UNDEFINE )
			{
				object_neighbor[objectID].reachabilityDistance = new_reachabilityDistance;
				insertQueue(&orderSeeds, object_neighbor[objectID].objectID, new_reachabilityDistance);
			}
			else
			{
				if( new_reachabilityDistance < object_neighbor[objectID].reachabilityDistance )
				{
					object_neighbor[objectID].reachabilityDistance = new_reachabilityDistance;
					decrease(&orderSeeds, objectID ,new_reachabilityDistance);
				}
			}
		}
	}
}

/*
 * write the @cluster_ordering
 * */
void writeClusterOrdering2File()
{
	int i;
	FILE* fwrite;
	if( NULL == (fwrite = fopen(".//OPTICS_ORDERING//cluster_ordering.data", "w")))
	{
		printf("open file(cluster_ordering.data) fail\n");
		exit(0);
	}
	for( i = 1; i <= data_size; i++ )
	{
		fprintf(fwrite, "%d\t%f\t%f\n", cluster_ordering[i].objectID, cluster_ordering[i].core_distance, cluster_ordering[i].reachability_distance);
	}
	fclose(fwrite);
}

/*
 * some operation about queue
 * */
void initialQueue(LinkQueue* L)
{
	L->front = (QueueNode*)malloc(sizeof(QueueNode));
	if( !L->front )
	{
		printf("queue initial malloc error\n");
		exit(0);
	}
	L->rear = L->front;
	L->rear->next = NULL;
}
void insertQueue(LinkQueue* L, int objectID, double distance)
{
	QueueNode* new = (QueueNode*)malloc(sizeof(QueueNode));
	if( !new )
	{
		printf("insert Queue malloc error");
		exit(0);
	}
	new->data = objectID;
	new->reachabilityDistance = distance;

	if( isQueueEmpty(*L) )
	{
		new->next = NULL;
		L->rear->next = new;
		L->rear = new;
	}else	//non-empty
	{
		QueueNode* seek = L->front->next;
		QueueNode* later = L->front;
		while( seek != NULL && seek->reachabilityDistance < distance )
		{
			later = seek;
			seek = seek->next;
		}
		if( seek == NULL )
		{
			new->next = L->rear->next;
			L->rear->next = new;
			L->rear = new;
		}else
		{
			new->next = seek;
			later->next = new;
		}
	}
}
void decrease(LinkQueue* L, int objectID, double distance)
{
	QueueNode* seek = L->front->next;
	QueueNode* follower = L->front;
	while( seek->data != objectID )
	{
		follower = seek;
		seek = seek->next;
	}
	if( seek == L->rear )
	{
		follower->next = NULL;
		L->rear = follower;
	}else
	{
		follower->next = seek->next;
	}
	QueueNode* new = (QueueNode*)malloc(sizeof(QueueNode));
	new->data = objectID;
	new->reachabilityDistance = distance;
	seek = L->front->next;
	follower = L->front;
	//printf("c");
	if( isQueueEmpty(*L) == 1 )
	{
		L->front->next = new;
		L->rear = new;
		L->rear->next = NULL;
		//printf("d");
	}else
	{
		//printf("e");
		while( seek != NULL && seek->reachabilityDistance < distance )
		{
			follower = seek;
			seek = seek->next;
		}
		if( seek == NULL )
		{
			//printf("f");
			follower->next = new;
			new->next = NULL;
			L->rear = new;
		}else
		{
			//printf("g");
			new->next = seek;
			follower->next = new;
		}
	}
}
void deleteQueue(LinkQueue* L, int* objectID)
{
	if( isQueueEmpty(*L) )
	{
		printf("\tQueue is empty\n");
		exit(0);
	}
	QueueNode* f = L->front->next;
	*objectID = f->data;
	L->front->next = f->next;
	if( f == L->rear )
	{
		L->rear = L->front;
	}
	free(f);
}
int isQueueEmpty(LinkQueue L)
{
	return L.rear == L.front ? 1 : 0;
}
void printQueue(LinkQueue L)
{
	printf("\nqueue operation : print\n");
	if( isQueueEmpty(L) )
	{
		printf("\tQueue is empty\n");
	}
	else
	{
		L.front = L.front->next;
		while( L.front != L.rear )
		{
			printf("%d: %f\n", L.front->data, L.front->reachabilityDistance);
			L.front = L.front->next;
		}
		printf("%d: %f \n\n", L.front->data, L.front->reachabilityDistance);
	}
}
void testQueue()
{
	LinkQueue L;
	int x;
	initialQueue(&L);
	insertQueue(&L, 4, 1.254);
	insertQueue(&L, 2, 2.2564);
	insertQueue(&L, 6, 1.0254);
	insertQueue(&L, 1, 0.56);
	insertQueue(&L, 5, 4.15);
	insertQueue(&L, 3, 2.342);
	insertQueue(&L, 7, 2.0214);
	insertQueue(&L, 8, 0.254);
	printQueue(L);

	decrease(&L, 3, 0.50);
	printQueue(L);
	
	decrease(&L, 5, 4.00);
	printQueue(L);
}
程序对于几种二维数据集的聚类的情况， 左边的是原始的数据，右边是程序运行的结果的可视化的图，在程序的运行结果中，为在当前目录下的OPTICS_ORDERING文件夹下生成一个文件，文件中第一列为objectId， 第二列为object的核心距离，第三列为object的可达距离，正是使用该列的数据进行作图，得到以下的图片。


土肥宅娘口三三
关注
专栏目录
条件概率公式 | 乘法公式 | 全概率公式 | 【贝叶斯公式】| 人工智能 面试题：什么是聚类算法？列举一些常见的聚类算法 | K-Means聚类算法，层次聚类算法，DBSCAN 聚类算法
追光者♂：记录、分享、总结、提升，现象级专栏《Python从入门到人工智能》作者，无惧黑暗，坚信曙光
10-30 890
本意是，对于【贝叶斯公式】的回顾。| 条件概率公式 | 乘法公式 | 全概率公式 | 【贝叶斯公式】| 人工智能 面试题：什么是聚类算法？列举一些常见的聚类算法 | K-Means聚类算法，层次聚类算法，DBSCAN 聚类算法
大数据分析案例-基于RFM+KMeas算法探究客户价值分析
m0_64336780的博客
09-25 6089
随着行业竞争越来越激烈，商家将更多的运营思路转向客户。例如，购物时，常常被商家推荐扫码注册会员;各种电商平台也推出注册会员领优惠券等推销政策，而这些做法都是为了积累客户，以便对客户进行分析。 那么，在商家积累的大量的客户交易数据中，如何根据客户历史消费记录分析不同客户群体的特征和价值呢?例如，了解哪些是重要保持客户、哪些是发展客户、哪些是潜在客户，从而针对不同客户群体定制不同的营销策略，实现精准营销、降低营销成本，提高销售业绩，使企业利润最大化。例如，淘宝电商客户繁多，消费行为复杂，客
OPtICS：对象解析以解释C ++结构（OPtICS）
02-20
用于解析C ++结构（OPtICS）的对象解析器 这个python 3.x项目将通过C ++项目递归运行以解释结构并生成numpy数据头文件输出。 ！[image]（ ）
c语言实现的optics算法,基于深度学习的光学系统设计方法
weixin_35606595的博客
05-24 455
AI开发平台ModelArtsModelArts是面向开发者的一站式AI开发平台，为机器学习与深度学习提供海量数据预处理及半自动化标注、大规模分布式Training、自动化模型生成，及端-边-云模型按需部署能力，帮助用户快速创建和部署模型，管理全周期AI工作流。按需/包周期付费可选，最低0.00元/小时导入操作||https://support.huaweicloud.com/engineers-...
OPTICS聚类
weixin_45228198的博客
03-14 1804
OPTICS聚类 Ordering Points To Identify Cluster Structure DBSCAN算法的衍生算法 引入可达距离，解决ε\varepsilonε参数确定的问题 定义 样本点xix_ixi​的核心距离 若样本点xix_ixi​为核心点，则其有核心距离，否则没有核心距离 如下图，在指定ε\varepsilonε距离阈值和MinPts=4时， 样本点xix_ixi​第一近邻点为本身(这里计入本身点)，第二近邻点为样本2，第三近邻点为样本3(x1)(x_1)(x1​)，第
optics聚类算法
03-05
optics是典型的多维聚类方法，在模式分类和机器学些中都有广泛的应用。
Numpy中的数据挖掘与聚类算法
# 第一章：Numpy简介与基础知识 ## 1.1 Numpy介绍与安装 Numpy是Python中一个重要的科学计算库，它提供了高效的多维数组对象（ndarray），以及对这些数组进行操作的函数集合。Numpy不仅提供了快速的数值计算能力，...
各类电气工程源代码
weixin_39965612的博客
03-18 7299
00077.编写的潮流计算方法在处理计及分布式电源的配电网三相潮流的正确性 00083.改进的快速粒子群优化算法计算含DG配电网无功优化和运行费用最优解（） 00084.配电网规划的主程序,根据目标函数中的建设费用,在通过潮流计算得到的运行费用,得到使此两者之和最小的网架 1.5MW风力机的载荷计算：摆振力矩、挥舞力矩、俯仰力矩等.rar 33节点配电网仿真模型，可用于电力系统分析，潮流计算、短路计算.rar 400HZ中频逆变电源三相UPS的MATLAB仿真.rar 5KW三电平Buck-Boost双向
低成本的医用超声扫描仪控制系统的开发和实现
工程科学与技术，国际期刊19（2016）964完整文章用于低成本医用超声扫描仪的微控制器USB接口与MATLAB GUIJean Rossario Raja，*，S.M.K. Rahmana，b，Sneh Ananda，ba印度新德里印度理工学院生物医学工程中心b印度...
java 实现的 Optics 算法.zip
08-09
java 实现的 Optics 算法
改进的OPTICS算法在调制识别中的应用
06-02
改进的OPTICS算法在调制识别中的应用
聚类分析OPTICS算法python实现
11-25
本资源中包括聚类分析OPTICS算法python实现，optics算法是基于DBSCAN聚类算法的改进算法。
层次聚类算法C++
06-22
层次聚类算法C++ VS2010 调试运行成功
optics算法
廖先贵的专栏
11-25 7005
1 简介        随着数据爆发式增长，分析数据从而提取隐藏在数据中的信息变的越来越重要。聚类分析是数据分析的一个主要方法，聚类(clustering)是将数据对象进行分类的过程，使同一类中的对象之间具有很高的相似度，而不同类中的对象高度相异。与分类不同，聚类不依赖预先定义的类和类标号，属于观察式学习。简而言之，在聚类中，分类的标准和类型数量均是未知的。         近来聚类分析算法
聚类算法——OPTICS
qq_28829409的博客
07-04 6445
网上很多关于OPTICS算法步骤的简介，学习了很多博客之后感觉总不合自己口味，因此整理了一篇博文供总结和复习，如能帮助到其他人便是锦上添花。阅读此文需要了解“聚类”，“基于密度聚类”和DBSCAN算法的前置知识。 基于密度聚类的思想源于大名鼎鼎的DBSCAN算法，DBSCAN之所以可以成为基于密度算法的“父类”和基础，是因为提出的概念和扩展簇的方式奠定了这类聚类算法的核心思想，其他适应于不同数据或更自适应的基于密度的聚类算法是在这个核心思想上的改进与扩展。网上关于DBSCAN聚类的步骤讲解十分详细，作为基
密度聚类：OPTICS算法详解
小白tree的博客
07-30 6060
如何理解这张reach_dist—points图并实现分类 样本点3，显然离样本点1的可达距离 < eps，那么归到与样本点0一类是没有问题的。 如果你是这样想就错了！ 上面的例子没有给出噪声点样本。 注意此时eps已不再是inf，而是依据图自定义的。 从结果队列 $order\_list$ 按顺序取出样本点，直到结果队列为空： 若该点的**可达距离 eps**，为噪声点 若该点的**核心距离 < eps**，为新的聚类簇......
算法笔记：OPTICS 聚类
最新发布
qq_40206371的博客
11-24 2873
换句话说，如果x不是核心点，那么cd(x)就没有意义。
聚类算法初探（六）OPTICS
weixin_34416754的博客
08-20 175
        最近由于工作需要，对聚类算法做了一些相关的调研。现将搜集到的资料和自己对算法的一些理解整理如下，供大家参考。 另外在算法代码方面，我也做了一些实现（包括串行和并行），欢迎感兴趣的朋友探讨和交流。     第一章  引言 第二章  预备知识 第三章  直接聚类法 第四章  K-means 第五章  DBSCAN 第六章  OPTICS    ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值