DBSCAN聚集算法改进，可用于车辆GPS经纬度聚集计算

最新推荐文章于 2024-05-04 17:43:18 发布
最新推荐文章于 2024-05-04 17:43:18 发布
阅读量1w 收藏 52
点赞数 4
分类专栏： C++ 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/winnyrain/article/details/52467617
版权

1、DBSCAN简介
DBSCAN（Density-Based Spatial Clustering of Applications with Noise，具有噪声的基于密度的聚类方法）是一种基于密度的空间聚类算法。该算法将具有足够密度的区域划分为簇，并在具有噪声的空间数据库中发现任意形状的簇，它将簇定义为密度相连的点的最大集合。

该算法利用基于密度的聚类的概念，即要求聚类空间中的一定区域内所包含对象（点或其他空间对象）的数目不小于某一给定阈值。

DBSCAN算法的优点：

1. 聚类速度快且能够有效处理噪声点和发现任意形状的空间聚类。
2. 与K-means方法相比，DBSCAN不需要事先知道要形成的簇类的数量。
3. 与K-means方法相比，DBSCAN可以发现任意形状的簇类。
4. 同时，DBSCAN能够识别出噪声点。
5. DBSCAN对于数据库中样本的顺序不敏感，即Pattern的输入顺序对结果的影响不大。但是，对于处于簇类之间边界样本，可能会根据哪个簇类优先被探测到而其归属有所摆动。

DBSCAN算法的弱点：
由于它直接对整个数据库进行操作且进行聚类时使用了一个全局性的表征密度的参数，因此也具有两个比较明显
1. 当数据量增大时，要求较大的内存支持I/O消耗也很大；
2. 当空间聚类的密度不均匀、聚类间距差相差很大时，聚类质量较差。
3. DBScan不能很好反映高尺寸数据。
4. DBScan不能很好反映数据集以变化的密度。


2、算法步骤

DBScan需要二个参数: 扫描半径 (eps)和最小包含点数(minPts)。 任选一个未被访问(unvisited)的点开始，找出与其距离在eps之内(包括eps)的所有附近点。
如果 附近点的数量 ≥ minPts，则当前点与其附近点形成一个簇，并且出发点被标记为已访问(visited)。 然后递归，以相同的方法处理该簇内所有未被标记为已访问(visited)的点，从而对簇进行扩展。
如果 附近点的数量 < minPts，则该点暂时被标记作为噪声点。
如果簇充分地被扩展，即簇内的所有点被标记为已访问，然后用同样的算法去处理未被访问的点。
DBScan需要二个参数: 扫描半径 (eps)和最小包含点数(minPts)。 任选一个未被访问(unvisited)的点开始，找出与其距离在eps之内(包括eps)的所有附近点。
如果 附近点的数量 ≥ minPts，则当前点与其附近点形成一个簇，并且出发点被标记为已访问(visited)。 然后递归，以相同的方法处理该簇内所有未被标记为已访问(visited)的点，从而对簇进行扩展。
如果 附近点的数量 < minPts，则该点暂时被标记作为噪声点。
如果簇充分地被扩展，即簇内的所有点被标记为已访问，然后用同样的算法去处理未被访问的点。


3、代码

在网上找到DBSCAN聚集算法源代码，运行了一下发现结果有些偏差，于是着手修复和改进，并可用于车辆GPS经纬度进行聚集，不多说直接贴代码了：

DataPoint.h文件

#ifndef DataPoint_H
#define DataPoint_H

#pragma once
#include <vector>
#include <set>

 using namespace std;
 
 const int DIME_NUM=2;        //数据维度为2，全局常量
 
 //数据点类型
 class DataPoint
 {
 private:
     unsigned long dpID;                //数据点ID
     double dimension[DIME_NUM];        //维度数据
     long clusterId;                    //所属聚类ID
     bool isKey;                        //是否核心对象
     bool visited;                    //是否已访问
     vector<unsigned long> arrivalPoints;    //领域数据点id列表
 public:
     CString     strDeviceID;//设备ID
	 int		nVehicleID;//车辆ID

 public:
     DataPoint();                                                    //默认构造函数
     DataPoint(unsigned long dpID,double* dimension , bool isKey);    //构造函数
 
     unsigned long GetDpId();                //GetDpId方法
     void SetDpId(unsigned long dpID);        //SetDpId方法
     double* GetDimension();                    //GetDimension方法
     void SetDimension(double* dimension);    //SetDimension方法
	 void SetDimension(double* dimension, const CString deviceID);    //SetDimension方法
	 void SetDimension(double* dimension, const int vehicleID); //SetDimension方法
     bool IsKey();                            //GetIsKey方法
     void SetKey(bool isKey);                //SetKey方法
     bool isVisited();                        //GetIsVisited方法
     void SetVisited(bool visited);            //SetIsVisited方法
     long GetClusterId();                    //GetClusterId方法
     void SetClusterId(long classId);        //SetClusterId方法
     vector<unsigned long>& GetArrivalPoints();    //GetArrivalPoints方法
 };
#endif

DataPoint.cpp文件 

#include "stdafx.h"
#include "DataPoint.h"

//默认构造函数
DataPoint::DataPoint()
{
}

//构造函数
DataPoint::DataPoint(unsigned long dpID,double* dimension , bool isKey):isKey(isKey),dpID(dpID)
{
	//传递每维的维度数据
	for(int i=0; i<DIME_NUM;i++)
	{
		this->dimension[i]=dimension[i];
	}
}

//设置维度数据
void DataPoint::SetDimension(double* dimension)
{
	for(int i=0; i<DIME_NUM;i++)
	{
		this->dimension[i]=dimension[i];
	}
}

//设置维度数据
void DataPoint::SetDimension(double* dimension, const CString deviceID)
{
	SetDimension(dimension);
	this->strDeviceID = deviceID;
}

//设置维度数据
void DataPoint::SetDimension(double* dimension, const int vehicleID)
{
	SetDimension(dimension);
	this->nVehicleID = vehicleID;
}

//获取维度数据
double* DataPoint::GetDimension()
{
	return this->dimension;
}

//获取是否为核心对象
bool DataPoint::IsKey()
{
	return this->isKey;
}

//设置核心对象标志
void DataPoint::SetKey(bool isKey)
{
	this->isKey = isKey;
}

//获取DpId方法
unsigned long  DataPoint::GetDpId()
{
	return this->dpID;
}

//设置DpId方法
void DataPoint::SetDpId(unsigned long dpID)
{
	this->dpID = dpID;
}

//GetIsVisited方法
bool DataPoint::isVisited()
{
	return this->visited;
}


//SetIsVisited方法
void DataPoint::SetVisited( bool visited )
{
	this->visited = visited;
}

//GetClusterId方法
long DataPoint::GetClusterId()
{
	return this->clusterId;
}

//GetClusterId方法
void DataPoint::SetClusterId( long clusterId )
{
	this->clusterId = clusterId;
}

//GetArrivalPoints方法
vector<unsigned long>& DataPoint::GetArrivalPoints()
{
	return arrivalPoints;
}

ClusterAnalysis.h文件

#ifndef ClusterAnalysis_H
#define ClusterAnalysis_H

#include <iostream>
#include <cmath>
#include "DataPoint.h"
 
 using namespace std;
 
 //聚类分析类型
 class ClusterAnalysis
 {
 private:
     vector<DataPoint> dadaSets;        //数据集合
     unsigned int dimNum;            //维度
     double radius;                    //半径
     unsigned int dataNum;            //数据数量
     unsigned int minPTs;            //邻域最小数据个数
	 unsigned long m_MaxclusterId;    //最大簇ID;
 
     
     void SetArrivalPoints(DataPoint& dp);                                //设置数据点的领域点列表
     void KeyPointCluster( unsigned long i, unsigned long clusterId );    //对数据点领域内的点执行聚类操作
 public:
 
     ClusterAnalysis(){}                    //默认构造函数
     bool Init(double radius, int minPTs);    //初始化操作
	 bool Init(char* fileName, double radius, int minPTs); //从文件初始化
	 bool AddData(DataPoint &DP) ;       //加载数据
     bool DoDBSCANRecursive();             //DBSCAN递归算法
     bool WriteToFile(char* fileName);    //将聚类结果写入文件

	 double GetDistance(DataPoint dp1, DataPoint dp2, bool isGPS = true);                    //距离函数

	 unsigned long GetMaxClusterId(); //获取最大簇ID
     DataPoint GetDataPoint(unsigned long clusterId, vector<DataPoint> &DpSets);//根据点簇ID，获取对应数据,并返回其中一个核心对象
 };
#endif
ClusterAnalysis.cpp文件 

#include "stdafx.h"
#include "ClusterAnalysis.h"
#include <fstream>
#include <iosfwd>
#include <math.h>
 
const double PI = 3.1415926535897932384626433;
const double R = 6.378137*1e6;
 /*
 函数：聚类初始化操作
 说明：将半径，领域最小数据个数信息写入聚类算法类
 参数：
 double radius;    //半径
 int minPTs;        //领域最小数据个数  
 返回值： true;    */
 bool ClusterAnalysis::Init(double radius, int minPTs)
 {
     this->radius = radius;        //设置半径
     this->minPTs = minPTs;        //设置领域最小数据个数
     this->dimNum = DIME_NUM;    //设置数据维度
	 dataNum = 0;
     return true;    //返回
 }

 /* 
 函数：聚类初始化操作 
 说明：将数据文件名，半径，领域最小数据个数信息写入聚类算法类，读取文件，把数据信息读入写进算法类数据集合中 
 参数： 
 char* fileName;    //文件名 
 double radius;    //半径 
 int minPTs;        //领域最小数据个数   
 返回值： true;    */  
 bool ClusterAnalysis::Init(char* fileName, double radius, int minPTs)  
 {  
 
	 this->radius = radius;        //设置半径  
	 this->minPTs = minPTs;        //设置领域最小数据个数  
	 this->dimNum = DIME_NUM;    //设置数据维度  
	 ifstream ifs(fileName);        //打开文件  
	 if (! ifs.is_open())                //若文件已经被打开，报错误信息  
	 {  
		 cout << "Error opening file";    //输出错误信息  
		 exit (-1);                        //程序退出  
	 }  

	 unsigned long i=0;            //数据个数统计  
	 while (! ifs.eof() )                //从文件中读取POI信息，将POI信息写入POI列表中  
	 {  
		 DataPoint tempDP;                //临时数据点对象  
		 double tempDimData[DIME_NUM];    //临时数据点维度信息  
		 for(int j=0; j<DIME_NUM; j++)    //读文件，读取每一维数据  
		 {  
			 ifs>>tempDimData[j];  
		 }  
		 tempDP.SetDimension(tempDimData);    //将维度信息存入数据点对象内  

		 //char date[20]="";  
		 //char time[20]="";  
		 double type;    //无用信息  
		 //ifs >> date;  
		 //ifs >> time;    //无用信息读入  

		 tempDP.SetDpId(i);                    //将数据点对象ID设置为i  
		 tempDP.SetVisited(false);            //数据点对象isVisited设置为false  
		 tempDP.SetClusterId(-1);            //设置默认簇ID为-1  
		 dadaSets.push_back(tempDP);            //将对象压入数据集合容器  
		 i++;        //计数+1  
		 cout<<i<<endl;  
	 }  
	 ifs.close();        //关闭文件流  
	 dataNum =i;            //设置数据对象集合大小为i  
	 return true;    //返回  
 }  


 /*
 函数：聚类加载数据
 说明：点数据写入聚类算法类
 参数：
 DataPoint &pdata    //数据点
 返回值： true;    */
 bool ClusterAnalysis::AddData(DataPoint &DP) 
 {
	 DP.SetDpId(dataNum);                    //将数据点对象ID设置为i
	 DP.SetVisited(false);            //数据点对象isVisited设置为false
	 DP.SetClusterId(-1);            //设置默认簇ID为-1
	 dadaSets.push_back(DP);            //将对象压入数据集合容器
	 dataNum++;            //设置数据对象集合大小

	 return TRUE;
 }
 
 /*
 函数：将已经过聚类算法处理的数据集合写回文件
 说明：将已经过聚类结果写回文件
 参数：
 char* fileName;    //要写入的文件名
 返回值： true    */
 bool ClusterAnalysis::WriteToFile(char* fileName )
 {
     ofstream of1(fileName);                                //初始化文件输出流
     for(unsigned long i=0; i<dataNum;i++)                //对处理过的每个数据点写入文件
     {
         for(int d=0; d<DIME_NUM ; d++)                    //将维度信息写入文件
             of1<<dadaSets[i].GetDimension()[d]<<'\t';
         of1 << dadaSets[i].GetClusterId() <<endl;        //将所属簇ID写入文件
     }
     of1.close();    //关闭输出文件流
     return true;    //返回
 }

 /*
 函数：获取最大簇ID
 说明：获取最大簇ID
 参数：
 返回值： 最大簇ID    */
 unsigned long  ClusterAnalysis::GetMaxClusterId()
 {
	 return m_MaxclusterId;
 }
 /*
 函数：根据点簇ID，获取对应数据,并返回其中一个核心对象
 说明：获取核心点列表
 参数：
 clusterId:所属簇ID
 vector<DataPoint> &DpSets;    //要输出的数据
 返回值： 核心对象    */
DataPoint ClusterAnalysis::GetDataPoint(unsigned long clusterId, vector<DataPoint> &DpSets)
 {
	 DataPoint KeyDP;
	 for(unsigned long i=0; i<dataNum; i++)                //对每个数据点执行
	 {
		 if(clusterId != dadaSets[i].GetClusterId())
		 {
			 continue;
		 }

		 DpSets.push_back(dadaSets[i]);

         
		 if (dadaSets[i].IsKey())
		 {
			 KeyDP = dadaSets[i];
		 }
	}
	 
	return KeyDP;
 }

 /*
 函数：设置数据点的领域点列表
 说明：设置数据点的领域点列表
 参数：
 返回值： true;    */
 void ClusterAnalysis::SetArrivalPoints(DataPoint& dp)
 {
     for(unsigned long i=0; i<dataNum; i++)                //对每个数据点执行
     {
         double distance =GetDistance(dadaSets[i], dp);    //获取与特定点之间的距离
         if(distance <= radius && i!=dp.GetDpId())        //若距离小于半径，并且特定点的id与dp的id不同执行
             dp.GetArrivalPoints().push_back(i);            //将特定点id压力dp的领域列表中
     }
     if(dp.GetArrivalPoints().size()+1 >= minPTs)            //若dp领域内数据点数据量> minPTs执行.包括该点
     {
         dp.SetKey(true);    //将dp核心对象标志位设为true
         return;                //返回
     }
     dp.SetKey(false);    //若非核心对象，则将dp核心对象标志位设为false
 }
 
 
 /*
 函数：执行聚类操作
 说明：执行聚类操作
 参数：
 返回值： true;    */
 bool ClusterAnalysis::DoDBSCANRecursive()
 {    
	 for(unsigned long i=0; i<dataNum;i++)
	 {
		 SetArrivalPoints(dadaSets[i]);            //计算数据点领域内对象
	 }

	 m_MaxclusterId = 0; //聚类id计数，初始化为01
     for(unsigned long i=0; i<dataNum;i++)            //对每一个数据点执行
     {
         DataPoint& dp=dadaSets[i];                    //取到第i个数据点对象
         if(!dp.isVisited() && dp.IsKey())            //若对象没被访问过，并且是核心对象执行
         {
			 
             dp.SetClusterId(m_MaxclusterId);                //设置该对象所属簇ID为clusterId
             dp.SetVisited(true);                    //设置该对象已被访问过
             KeyPointCluster(i,m_MaxclusterId);            //对该对象领域内点进行聚类
             m_MaxclusterId++;                          //clusterId自增1
         }
         //cout << "孤立点\T" << i << endl;
     }
 
    // cout <<"共聚类" <<clusterId<<"个"<< endl;        //算法完成后，输出聚类个数
     return true;    //返回
 }
 
 /*
 函数：对数据点领域内的点执行聚类操作
 说明：采用递归的方法，深度优先聚类数据
 参数：
 unsigned long dpID;            //数据点id
 unsigned long clusterId;    //数据点所属簇id
 返回值： void;    */
 void ClusterAnalysis::KeyPointCluster(unsigned long dpID, unsigned long clusterId )
{
	 if (dpID >= dataNum)       //防止访问出错
		 return;
     DataPoint& srcDp = dadaSets[dpID];        //获取数据点对象
     if(!srcDp.IsKey())    return;
     vector<unsigned long>& arrvalPoints = srcDp.GetArrivalPoints();        //获取对象领域内点ID列表
     for(unsigned long i=0; i<arrvalPoints.size(); i++)
     {
         DataPoint& desDp = dadaSets[arrvalPoints[i]];    //获取领域内点数据点
         if(!desDp.isVisited())                            //若该对象没有被访问过执行
         {
             //cout << "数据点\t"<< desDp.GetDpId()<<"聚类ID为\t" <<clusterId << endl;
             desDp.SetClusterId(clusterId);        //设置该对象所属簇的ID为clusterId，即将该对象吸入簇中
             desDp.SetVisited(true);                //设置该对象已被访问
             if(desDp.IsKey())                    //若该对象是核心对象
             {
                 KeyPointCluster(desDp.GetDpId(),clusterId);    //递归地对该领域点数据的领域内的点执行聚类操作，采用深度优先方法
             }
         }
     }
 }
 
 //两数据点之间距离
 /*
 函数：获取两数据点之间距离
 说明：获取两数据点之间的欧式距离和GPS距离
 参数：
 DataPoint& dp1;        //数据点1
 DataPoint& dp2;        //数据点2
 bool isGPS;			//是否GPS经纬度
 返回值： double;    //两点之间的距离，GPS距离单位米      */
 double ClusterAnalysis::GetDistance(DataPoint dp1, DataPoint dp2)
 {
	double distance =0;        //初始化距离为0
	if(!isGPS)
	{
		for(int i=0; i<DIME_NUM;i++)    //对数据每一维数据执行
		{
			distance += pow(dp1.GetDimension()[i] - dp2.GetDimension()[i],2);    //距离+每一维差的平方
		}

		return pow(distance,0.5);        //开方并返回距离
	 }
	 else//经纬度计算距离 
	 {
		 double x,y;

		 x=(dp2.GetDimension()[0]-dp1.GetDimension()[0])*PI*R*cos( ((dp1.GetDimension()[1] + dp2.GetDimension()[1])/2) *PI/180)/180;
		 y=(dp2.GetDimension()[1]-dp1.GetDimension()[1])*PI*R/180;
		 return hypot(x,y);
	 }
 }
使用方法： 

	//直接输入输出数据
	ClusterAnalysis cs;
	cs.Init(2.5, 3, false);//点之间距离设定为2.5，最小聚集数量为3，false为不使用GPS计算距离
	DataPoint point;
	double tempPoint[19][2] ={2,2,3,1,3,4,5,3,3,14,8,3,8,6,9,8,10,4,10,7,10,10,10,14,11,13,12,8,12,15,14,7,14,9,14,15,15,8};

	for(int i =0 ;i <19; i++)
	{
		point.SetDimension(tempPoint[i]);
		cs.AddData(point);
	}

	cs.DoDBSCANRecursive();//执行聚类计算

	std::vector<DataPoint> dp;
	DataPoint dp2;//返回其中一个点（最后一个点）
	unsigned long nClusterCount = cs.GetMaxClusterId();//获取聚簇ID最大值（数量）
	for(int i = 0; i < nClusterCount; i++)
	{
		dp2 = cs.GetDataPoint(i, dp);//获取聚集簇
		for(auto itr = dp.begin(); itr != dp.end(); itr++)
		{
			TRACE("聚集簇ID：%d，坐标：%f,%f\r\n", itr->GetClusterId() , itr->GetDimension()[0], itr->GetDimension()[1]);
		}
		dp.clear();
	}
	cs.GetDataPoint(-1, dp);//获取噪声簇
	for(auto itr = dp.begin(); itr != dp.end(); itr++)
	{
		TRACE("噪声点ID：%d，坐标：%f,%f\r\n", itr->GetClusterId() , itr->GetDimension()[0], itr->GetDimension()[1]);
	}

	//使用文件输入输出数据
	ClusterAnalysis csFile;
	csFile.Init("d:\\In.txt", 2.5, 3, false);//点之间距离设定为2.5，最小聚集数量为3，false为不使用GPS计算距离
	csFile.DoDBSCANRecursive();//执行聚类计算
	csFile.WriteToFile("d:\\Out.txt");//输出到文件


结果：

聚集簇ID：0，坐标：2.000000,2.000000
聚集簇ID：0，坐标：3.000000,1.000000
聚集簇ID：0，坐标：3.000000,4.000000
聚集簇ID：0，坐标：5.000000,3.000000
聚集簇ID：1，坐标：8.000000,6.000000
聚集簇ID：1，坐标：9.000000,8.000000
聚集簇ID：1，坐标：10.000000,7.000000
聚集簇ID：1，坐标：10.000000,10.000000
聚集簇ID：1，坐标：12.000000,8.000000
聚集簇ID：1，坐标：14.000000,7.000000
聚集簇ID：1，坐标：14.000000,9.000000
聚集簇ID：1，坐标：15.000000,8.000000
聚集簇ID：2，坐标：10.000000,14.000000
聚集簇ID：2，坐标：11.000000,13.000000
聚集簇ID：2，坐标：12.000000,15.000000
聚集簇ID：2，坐标：14.000000,15.000000
噪声点ID：-1，坐标：3.000000,14.000000
噪声点ID：-1，坐标：8.000000,3.000000
噪声点ID：-1，坐标：10.000000,4.000000



输入输出文件：

In.txt文件

2
2
3
1
3
4
5
3
3
14
8
3
8
6
9
8
10
4
10
7
10
10
10
14
11
13
12
8
12
15
14
7
14
9
14
15
15
8

输出结果Out.txt 

2	2	0
3	1	0
3	4	0
5	3	0
3	14	-1
8	3	-1
8	6	1
9	8	1
10	4	-1
10	7	1
10	10	1
10	14	2
11	13	2
12	8	1
12	15	2
14	7	1
14	9	1
14	15	2
15	8	1

附图：



如果用于GPS车辆的聚集，可能会形成如下图形：



本文章提及的代码和数据DEMO下载地址：
http://download.csdn.net/download/winnyrain/10241173
Leckun
关注
  • 4
    点赞
  • 踩
  • 52
    收藏
    觉得还不错? 一键收藏
  • 51
    评论
专栏目录
2011年东北三省自主命题-用出租车 GPS 数据分析深圳道路交通情况
getusushu的博客
05-29 673
一、问题的提出摘要随着我国城市化进程的加快，城市交通量不断增大，这给交通规划带来了巨大的挑战。如何合理布局交通小区、如何得到 OD 时空分布、怎样预测 OD 时空分布和怎样预测交通拥堵时段等都是交通规划亟需解决的问题。针对以上的问题，本文利用深圳市出租车 GPS 数据提出了如下解决方案：对于第一个问题，由于交通小区是指交通相似的地区所组成的紧密区域，故提出了以出租车起讫点的密集程度划分交通小区的方法：在以 Eps(给定的半径)
用DBSCAN聚类经纬度坐标
rover
03-26 8932
用基于密度的聚类算法，计算坐标点聚集地，很好用。 import pandas as pd import numpy as np from sklearn.cluster import DBSCAN from sklearn import metrics import os def dbscan(input_file): columns=['lon','lat'] in_df ...
DBSCAN处理不精确经纬度坐标问题及其解决方案
D0126_的博客
02-20 432
DBSCAN算法常被应用于对地理标记照片进行聚类，根据经纬度将照片分组。然而，当经纬度数据并不精确时，使用DBSCAN可能会出现一些问题。例如，在某次研究中，研究人员发现有两组照片，它们被用户标记为在中央公园拍摄，但它们的经纬度坐标却并没有被聚类在一起。通过检查照片本身，研究人员确认这两组照片的确都是在中央公园拍攝的，但它们的经纬度坐标之间却相距数百米。经过调查，研究人员发现导致这种现象的原因是经纬度地理标记并不精确。手机的GPS系统存在一定误差，因此生成的经纬度坐标可能并不准确。
经纬度聚类：聚类算法比较
最新发布
weixin_51389291的博客
05-04 1166
K均值（K-means）聚类是一种常用的无监督学习算法，用于将数据集中的样本分成K个不同的簇（cluster）。其基本思想是将数据集划分为K个簇，使得每个样本点都属于距离最近的簇的中心点，同时最小化簇内样本点之间的距离平方和。初始化: 随机选择K个样本点作为初始的簇中心点。分配: 对于每个样本点，计算其与K个簇中心点的距离，并将其分配到距离最近的簇中心点所在的簇。更新: 对于每个簇，计算其所有样本点的均值，将该均值作为新的簇中心点。重复迭代。
python聚类dbscan案例经纬度_用DBSCAN聚类经纬度坐标
weixin_39667080的博客
12-24 2293
用基于密度的聚类算法，计算坐标点聚集地，很好用。import pandas as pdimport numpy as npfrom sklearn.cluster import DBSCANfrom sklearn import metricsfrom sklearn.cluster import KMeansimport osdef dbscan(input_file):columns=['lo...
Python实现经纬度空间点DBSCAN聚类
热门推荐
黄钢的博客
09-22 7万+
写在前面 博主前期科研工作中，涉及到要对某个地区的一些空间点进行聚类分析，想到读研期间，曾经用DBSCAN聚类算法实现了四线激光雷达扫描的三维点云数据聚类（论文题目：基于改进DBSCAN算法的激光雷达目标物检测方法），当初用matlab实现的，虽说是改进的算法，但改进方法非常原始。DBSCAN是一种非常实用的密度聚类算法，而地理空间的经纬度点聚类，没有其他维度的信息的话，毫无疑问可以用密度聚类。于是博主重新熟悉了一下算法，并做了一些改进，用Python实现，记录在博客里面。 编译环境：Python3.7
java地理坐标-聚类算法 实现DBScan聚类算法
tiger_Angle
07-12 2179
最近有一个需求，在地图上，将客户按照距离进行聚合。比如，a客户到b客户5km，b客户到c客户5km，那么abc就可以聚合成一个集合。首先想到的就是找一个根据坐标来聚合的算法，这里找了一些后来选择了较为简单也符合要求的DBScan聚类算法。 　　它是一种基于密度的聚类算法，简单来说就是根据样本的紧密程度和数量将其分成多个集合。这个样本一般来说是一堆坐标点。参数可以为欧式距离和邻域密度阈值（就是每次寻找相邻的点的最低数量）。最终返回多个样本集合。 java实现 　　坐标点：这个类如果测试的话，只用到里面的
Flink流数据api实战之实现机器学习密度峰值聚类算法
weixin_45781143的博客
07-22 837
最近好几天没更新了，并没有偷懒玩哈，短学期前立的flag依旧记在心中。没更新的这几天我可是在每天加班加点的学习呢，为了今天这篇博客我这几天没少掉头发啊，呜呜呜呜！！！ 案例背景 此案例的数据源为通过GPS定位产生的经纬度信息返回到服务器，然后通过调用特定的定位接口来变成一片特定区域的平面图的x和y坐标。同一个人收集到的坐标集加上特定的id作为标签。 此案例的数据源的类型为实时流式数据，其中最大的特点就是有头无尾，只要开启收集程序，就会收集到源源不断的流式数据 此案例的算法思想为：每隔极短的时间收集一次每个
怎么让汽车自个跑起来
一群专业码农的笔记本
09-06 1185
给文章取了个口语化的标题，怎么让汽车自个跑起来，其实我是想谈谈无人驾驶的那些事。第一次看到汽车这样一个庞然大物，在完全没有人为干预的情况下，自己动起来，完成路径规划，避障，超车，重规划等任务，到达指定目的地的时候，我有觉得无人驾驶是件非常炫酷的事。曾经有过一段时间参与到无人驾驶技术的研究和学习，我就把我对无人驾驶的一些浅薄见解做个分享罢，咱主要就聊聊无人车的核心系统架构。 无人驾驶系统的核心可以简单的概述为三个部分：感知，规划以及控制。感知主要是通过各类传感器获取环境信息，用于指导无人车行驶。规划则是利用
DBSCAN聚类C++算法，可用于GPS车辆聚集计算
02-05
在GPS车辆聚集计算中，DBSCAN可以有效地找出车辆在某一区域内的聚集现象，比如交通堵塞、停车场等。 DBSCAN的核心思想是通过两个关键参数来定义聚类：最小样本数（MinPts）和邻域半径（Eps）。一个点如果在其Eps...
用C++实现DBSCAN聚类算法
09-05
DBSCAN（Density-Based Spatial Clustering of Applications with Noise）是一种基于密度的空间聚类算法，它能发现任意形状的聚类，并且对噪声不敏感。在C++中实现DBSCAN，我们需要理解算法的基本步骤和数据结构。...
基于信息熵的蚁群聚类DBSCAN改进算法
01-15
针对DBSCAN算法对数据分布不均匀和大规模数据处理问题上的不足，提出了一种新的整合算法，算法使用信息熵和蚁群聚类技术对聚类数据集进行代表性子集选择，在子集基础上进行DBSCAN聚类，实验证明这一算法能显著降低I/...
DBSCAN改进算法
12-18
标题与描述均提到了“DBSCAN改进算法”，这暗示了文章的核心内容是关于对DBSCAN算法的优化与改进。DBSCAN（Density-Based Spatial Clustering of Applications with Noise）是一种基于密度的空间聚类算法，它能够...
关于CString初始化时提示字符串太大的解决
Leckun的专栏
04-21 8166
问题代码： CString str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567
C++将无结束符字符串（ASCII）转为数字数值的快速方法（支持16进制）
Leckun的专栏
10-25 6799
通常情况下的字符串转为数字，可以使用C的atoi，或者C++的sstream来转换，但是这要求待转换源字符串要有\0结束符，如果只想转换字符串中一部分，或者转换char*中不带结束符的字符串的时候，以上的方式均需要将字符拷贝出来并且给出结束符才能进行下一步转换，有了拷贝的动作转换的速度就慢了，以下的方法是根据ASCII字符对应数值的特点循环将字符转换为数字数值的函数，并支持16进制。
“CObject::CObject”: 无法访问 private 成员(在“CObject”类中声明)
Leckun的专栏
10-30 5301
例子： typedef struct tagMyStruct { CArray strMyArray; }MyStruct; 这样子写会报“CObject::CObject”: 无法访问 private 成员(在“CObject”类中声明)错误， 解决方法： 从CObject派生的类,传参时请用指针！并在构造函数里new一个新实例。 typedef struc
使用find_if的自定义条件查找vector或map
Leckun的专栏
08-26 3147
vectortestStructVector; void CtestDlg::OnBnClickedButton1() { testStruct struct1; for(int i = 0; i < 5; i++) { struct1.a = i; struct1.b = i + i; testStructVector.push_back(struct1); } au
使用set_union对vector结构体进行去除重复值并合并
Leckun的专栏
08-26 2987
set_union对vector结构体进行去除重复值并合并 vectortestStructVector1; vectortestStructVector2; vectorunionVector; void CtestDlg::OnBnClickedButton2() { testStruct struct1; for(int i = 0; i < 5; i++) { st
dbscan聚类算法改进python
06-28
### 回答1： DBSCAN聚类算法是一种基于密度的聚类算法，它可以有效地处理噪声和非凸形状的数据集。在Python中，可以使用scikit-learn库中的DBSCAN类来实现该算法。 为了改进DBSCAN聚类算法，可以考虑以下几点： 1. 调整参数：DBSCAN算法中的两个重要参数是eps和min_samples。eps表示邻域的半径大小，min_samples表示一个簇中最少需要的样本数。可以通过调整这两个参数来改进算法的聚类效果。 2. 数据预处理：在进行聚类之前，可以对数据进行预处理，例如去除异常值、归一化等操作，以提高聚类的准确性。 3. 使用其他聚类算法：除了DBSCAN算法，还有许多其他的聚类算法，例如K-Means、层次聚类等。可以尝试使用其他算法来进行比较，以找到最适合数据集的聚类算法。 4. 结合其他技术：可以将DBSCAN算法与其他技术结合使用，例如PCA降维、特征选择等，以提高聚类效果。 总之，改进DBSCAN聚类算法需要综合考虑数据集的特点、算法参数、数据预处理等多个方面，以达到最优的聚类效果。 ### 回答2： DBSCAN聚类算法是一种基于密度的聚类算法，其优点在于可以自动识别任意形状的簇，并且能够对噪声数据进行有效过滤，因此在实际应用中得到了广泛的应用。不过，该算法的性能表现并不是很好，尤其是在处理大规模数据时，需要耗费大量的时间和内存。因此，针对DBSCAN算法的性能问题，我们可以进行以下改进： 1. 改进数据结构：通常情况下，我们使用的是基于数组的数据结构来实现DBSCAN算法，但是，这种数据结构并不适合处理大规模数据，并且需要耗费大量的时间和内存。因此，我们可以改用基于树形结构的数据结构，如k-d tree，来存储数据，这样可以大大提高算法的性能表现。 2. 基于分布式计算：在面对大规模数据聚类时，可以将数据分配到多个节点上进行并行计算，这样可以加速聚类过程。同时，分布式计算还可以提高算法的可扩展性，并且可以有效降低内存消耗。 3. 引入采样方法：在处理大规模数据时，可以采用一些采样方法，如随机采样、均匀采样等等，来减少数据量，从而降低算法的计算复杂度。通过采用合适的采样策略，可以在保证聚类结果精度的同时，提高算法的性能表现。 4. 调整参数：DBSCAN算法中有两个重要参数，即Eps和MinPts，这两个参数直接影响聚类结果和算法性能。因此，在实际使用中需要根据数据集的特性和应用需求，合理设置这两个参数。 以上四种方法是针对DBSCAN算法的常用改进方法，可以有效提高算法的性能表现，从而更好地应用于实际应用中。同时，我们可以将这些改进方法与python编程语言结合起来，通过使用python编写高效、可扩展的DBSCAN聚类算法，为不同领域的研究者和实践者提供更好的数据挖掘和分析工具。 ### 回答3： DBSCAN（Density-Based Spatial Clustering of Applications with Noise）是一种聚类算法，可以对不同形状和密度的数据进行聚类，也能够识别出离群点。在聚类算法中，DBSCAN非常实用，能够有效地将空间上紧密相连的点聚集为一类。 Python是一种方便易用的编程语言，有很多常用的聚类包可以用于DBSCAN聚类算法，如scikit-learn、hdbscan等。在这些包中，DBSCAN的使用非常简单，仅需要一些基本的输入参数即可，如eps（邻域半径）和min_samples（核心点所需的最小样本数）。 然而，DBSCAN聚类算法也有一些注意事项。首先，需要选择适当的参数才能获得较好的聚类效果。例如，eps参数对于DBSCAN的聚类输出结果至关重要，因为它控制着聚类的紧密度和数量。其次，DBSCAN对于数据的分布类型有一定的限制，例如，它很难区分球形分布和环状分布的数据。最后，DBSCAN算法的时间复杂度较高，处理大数据集时会出现计算效率低下的问题。 为了解决这些问题，我们可以对DBSCAN聚类算法进行改进。在改进DBSCAN算法时，我们可以考虑以下几点： 1.使用高斯混合模型（Gaussian Mixture Model）结合DBSCAN。高斯混合模型可以对数据的分布类型做出更加精细的判断，从而更好地对数据进行聚类。 2.使用K-D Tree等树形结构对数据进行优化处理。这可以减少计算时间，并提高算法的效率。 3.对核心点的半径进行自适应调整。可以根据数据分布的情况，自动调整核心点的半径，从而更好地适应不同的数据形态。 总之，针对DBSCAN聚类算法，我们可以通过各种手段进行优化和改进，从而更好地适应数据分析的需求。不论是在Python中使用DBSCAN还是对其进行改进，了解DBSCAN算法的优劣点和特点是非常重要的。
评论 51
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值