随机计算TFIDF作为权重，然后利用余弦距离进行聚类，用的是简单k-means算法。

最新推荐文章于 2022-03-06 18:32:09 发布
最新推荐文章于 2022-03-06 18:32:09 发布
阅读量4.3k 收藏 1
点赞数
文章标签： 算法 asp.net distance string input vector
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq120848369/article/details/6821771
版权

#include <iostream>

#include <string>
#include <vector>
#include <map>
#include <utility>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <ctime>
using namespace std;

struct Kmeans
{
    vector< pair<string,map<string,int>> > asAllLines;    //存储所有文本行以及每一行各个单词出现次数，用于计算TF
    vector< vector<double> > aaLinesTf;    //所有文本行对应所有单词的TF*IDF
    map<string,int> mKeyAprLines;    //每个单词在多少行里出现过,用于计算IDF
    vector< vector<double> > aCluCenter;    //聚类中心 
    vector<int> aiLinesInCenter;    //每个中心聚集了多少文本行
    vector<int> aLinesCenter;    //每个文本行属于哪个聚类中心

    int iKeyNum;    //单词种类
    int iLineNum;    //总文本行数
    int iCenterNum;    //中心个数
};

#define MAX_DISTANCE 1e6

void stringToLower(string &key)
{
    for(int i=0;i<(int)key.size();)
    {
        if(key[i]<0)
        {
            i+=2;
        }
        else 
        {
            if('A'<=key[i] && key[i]<='Z')
            {
                key[i]=key[i]-'A'+'a';
            }

            i++;
        }
    }
}

void kMeansCentersRandomInit(Kmeans *pKmeans)
{
    srand((unsigned int)time(NULL));

    for(int i=0;i<pKmeans->iCenterNum;++i)
    {
        bool bContinue=true;

        do
        {
            int iToSelect=rand()%pKmeans->iLineNum;

            if(pKmeans->aLinesCenter[iToSelect]==-1)
            {
                for(int j=0;j<pKmeans->iKeyNum;++j)
                {
                    pKmeans->aCluCenter[i][j]=pKmeans->aaLinesTf[iToSelect][j];
                }

                pKmeans->aLinesCenter[iToSelect]=i;
                cout<<"初始化中心"<<i<<":"<<pKmeans->asAllLines[iToSelect].first<<endl;
                bContinue=false;
            }
        }while(bContinue);
    }
}

int kMeansInit(Kmeans *pKmeans,const vector<string> &asAllLines,int iLineNum,int iCenterNum)
{
    if(pKmeans==NULL)
    {
        return -1;
    }

    pKmeans->asAllLines.assign(iLineNum,pair< string,map<string,int> >());
    pKmeans->aaLinesTf.assign(iLineNum,vector<double>());
    pKmeans->aCluCenter.assign(iCenterNum,vector<double>());
    pKmeans->aiLinesInCenter.assign(iCenterNum,0);
    pKmeans->aLinesCenter.assign(iLineNum,0);

    pKmeans->iLineNum=iLineNum;
    pKmeans->iCenterNum=iCenterNum;

    //拆分单词，统计数据
    for(int i=0;i<(int)asAllLines.size();++i)
    {
        pKmeans->asAllLines[i].first=asAllLines[i];

        istringstream istrm(asAllLines[i]);
        string key;

        while(istrm>>key)
        {
            stringToLower(key);

            if(pKmeans->asAllLines[i].second.find(key)==pKmeans->asAllLines[i].second.end())
            {
                pKmeans->asAllLines[i].second[key]=1;
            }
            else
            {
                pKmeans->asAllLines[i].second[key]++;
            }

            if(pKmeans->asAllLines[i].second[key]==1)
            {
                pKmeans->mKeyAprLines[key]++;
            }
        }
    }

    pKmeans->iKeyNum=pKmeans->mKeyAprLines.size();
    
    for(int i=0;i<pKmeans->iLineNum;++i)
    {
        pKmeans->aaLinesTf[i].assign(pKmeans->iKeyNum,0);
        pKmeans->aLinesCenter[i]=-1;
    }

    for(int i=0;i<pKmeans->iCenterNum;++i)
    {
        pKmeans->aCluCenter[i].assign(pKmeans->iKeyNum,0);
    }
    
    //计算TF-IDF
    int iKeyIndex=0;
    for(map<string,int>::iterator iter=pKmeans->mKeyAprLines.begin();iter!=pKmeans->mKeyAprLines.end();++iter,++iKeyIndex)
    {
        for(int line=0;line<iLineNum;++line)
        {
            if(pKmeans->asAllLines[line].second.find(iter->first)==pKmeans->asAllLines[line].second.end())
            {
                pKmeans->aaLinesTf[line][iKeyIndex]=0;    
            }
            else
            {
                double TF=1.0*pKmeans->asAllLines[line].second[iter->first]/pKmeans->asAllLines[line].second.size();
                double DF=log(1.0*pKmeans->iLineNum/iter->second);
                pKmeans->aaLinesTf[line][iKeyIndex]=TF*DF;
            }
        }
    }

    return 0;
}

void kMeansMainLoop(Kmeans *pKmeans,int iTimes,double iThreshold)
{
    /*
    if(iTimes==0 && iThreshold==0)
    {
        return;    //没有终止条件
    }
    */

    int iLeftTimes=iTimes;
    double lastJ=-1;
    vector<int> aPreLinesCenter;    //之前的聚类

    kMeansCentersRandomInit(pKmeans);

    while(true)
    {
        double J=0;
        pKmeans->aiLinesInCenter.assign(pKmeans->iCenterNum,0);
        aPreLinesCenter=pKmeans->aLinesCenter;    //保存之前的聚类

        //聚类
        for(int i=0;i<pKmeans->iLineNum;++i)
        {
            int iCtrIndex=-1;
            double minDist=MAX_DISTANCE;
            
            for(int j=0;j<pKmeans->iCenterNum;++j)
            {
                double dist,centerSum=0,lineSum=0,crossSum=0;

                for(int k=0;k<pKmeans->iKeyNum;++k)
                {
                    crossSum+=pKmeans->aaLinesTf[i][k]*pKmeans->aCluCenter[j][k];
                    centerSum+=pKmeans->aCluCenter[j][k]*pKmeans->aCluCenter[j][k];
                    lineSum+=pKmeans->aaLinesTf[i][k]*pKmeans->aaLinesTf[i][k];
                }

                dist=crossSum/(sqrt(centerSum)*sqrt(lineSum));
                dist=1-dist;
                
                if(dist<minDist)
                {
                    iCtrIndex=j;
                    minDist=dist;
                }
            }

            pKmeans->aLinesCenter[i]=iCtrIndex;
            pKmeans->aiLinesInCenter[iCtrIndex]++;
            J+=minDist*minDist;
        }

        int iCnt=0;

        for(int i=0;i<pKmeans->iLineNum;++i)
        {
            if(pKmeans->aLinesCenter[i]==aPreLinesCenter[i])
            {
                iCnt++;
            }
        }

        if(iCnt==pKmeans->iLineNum)
        {
            break;
        }

        //重新计算各聚类中心点
        for(int i=0;i<pKmeans->iCenterNum;++i)
        {
            for(int j=0;j<pKmeans->iKeyNum;++j)
            {
                pKmeans->aCluCenter[i][j]=0;
            }
        }

        for(int i=0;i<pKmeans->iLineNum;++i)
        {
            for(int j=0;j<pKmeans->iKeyNum;++j)
            {
                pKmeans->aCluCenter[pKmeans->aLinesCenter[i]][j]+=pKmeans->aaLinesTf[i][j];
            }
        }

        //求均值,更新聚类中心
        for(int i=0;i<pKmeans->iCenterNum;++i)
        {
            if(pKmeans->aLinesCenter[i]!=0)
            {
                for(int j=0;j<pKmeans->iKeyNum;++j)
                {    
                    pKmeans->aCluCenter[i][j]/=pKmeans->aiLinesInCenter[i];
                }
            }
        }

        if(iTimes!=0 && --iLeftTimes==0)
        {
            break;
        }

        if(iThreshold!=0 && lastJ!=-1 && fabs(lastJ-J)<iThreshold)
        {
            break;
        }

        lastJ=J;
    }
}

int main()
{
    Kmeans test;

    string input[]=
    {
        "奥运 拳击 入场券 基本 分罄 邹市明 夺冠 对手 浮出 水面",
        "股民 要 清楚 自己 的 目的",
        "印花税 之 股民 四季",
        "杭州 股民 放 鞭炮 庆祝 印花税 下调",
        "残疾 女 青年 入围 奥运 游泳 比赛 创 奥运 历史 两 项 第一",
        "介绍 一 个 ASP.net MVC 系列 教程",
        "在 asp.net 中 实现 观察者 模式 ，或 有 更 好 的 方法 （续）",
        "输 大钱 的 股民 给 我们 启迪",
        "Asp.Net 页面 执行 流程 分析",
        "运动员 行李 将 “后 上 先 下” 奥运 相关 人员 行李 实名制",
        "asp.net 控件 开发 显示 控件 内容",
        "奥运 票务 网上 成功 订票 后 应 及时 到 银行 代售 网点 付款",
        "某 心理 健康 站 开张 后 首 个 咨询 者 是 位 新 股民",
        "ASP.NET 自定义 控件 复杂 属性 声明 持久性 浅析"
    };
/*
    for(int i=0;i<14;++i)
    {
        stringToLower(input[i]);
        cout<<input[i]<<endl;
    }
*/

    vector<string> allLines(input,input+sizeof(input)/sizeof(string));

    kMeansInit(&test,allLines,sizeof(input)/sizeof(string),3);
    kMeansMainLoop(&test,0,0);

    for(int i=0;i<test.iCenterNum;++i)
    {
        cout<<"Center "<<i<<" : "<<endl;

        for(int j=0;j<test.iLineNum;++j)
        {
            if(test.aLinesCenter[j]==i)
            {
                cout<<test.asAllLines[j].first<<endl;
            }
        }

        cout<<endl;
    }

    return 0;
}


http://topic.csdn.net/u/20110906/11/89e01a81-923d-4cfb-b0ed-3dd295c1fd98.html

初始化

qq120848369
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
k-means算法的matlab代码-KmeansPCA:KmeansPCA
05-28
k-means 算法的matlab代码 KmeansPCA matrix.h: 自己手写的Matrix类的定义 matrix.cpp: 自己手写的Matrix类 datapoint.h: 自己手写的DataPoint类定义，用途是标示数据点元素 datapoint.cpp: 自己手写的DataPoint类 ...
python——k-means聚类（余弦距离，用轮廓系数确定聚类系数K）
热门推荐
chenxjhit的博客
05-14 2万+
    用scikit-learn进行k-means聚类，默认使用欧式距离，为了用余弦距离作为度量，找了一个在生物信息学里比较常用的库：Biopython。Biopython为k-means聚类提供了各种距离函数，包括余弦距离、皮尔逊相似度量、欧式距离等。    另外，为了确定一个合理的聚类系数，采用轮廓系数作为衡量标准：    轮廓系数取值为[-1, 1]，其值越大越好。from sklearn...
K-means笔记与实现
liu_ziyue的博客
02-29 554
k均值聚类算法（k-means clustering algorithm）是一种迭代求解的聚类分析算法，其步骤是： 预将数据分为K组，则随机选取K个对象作为初始的聚类中心 计算每个对象与各个种子聚类中心之间的距离，把每个对象分配给距离它最近的聚类中心。 聚类中心以及分配给它们的对象就代表一个聚类。 每分配一个样本，聚类的聚类中心会根据聚类中现有的对象被重新计算。这个过程将不断重复直到满足某个终止...
K-means聚类自定义距离计算
平平淡淡，戒急用忍，一生学闭嘴。
05-11 7431
如果你想自己定义一个距离的function的话，scikit-learn是不行的，只支持Euclidean distance 如果你觉得spark可以的话，实际上sprk的k-means也是不行的，好一点的是支持Euclidean distance，还支持cosine distance 如果你想自己定义function处理的话，二个方法： 1、自己实现算法，可参考的文档： 一个简单的讲解 https://medium.com/machine-learning-algorithms-from-scratch/
k-means优化 & k-means距离的选择 &k-medoids对比
lujiandong1的专栏
05-05 2万+
一、k-means：在大数据的条件下，会耗费大量的时间和内存。 优化k-means的建议： 1、减少聚类的数目K。因为，每个样本都要跟类中心计算距离。 2、减少样本的特征维度。比如说，通过PCA等进行降维。 3、考察其他的聚类算法，通过选取toy数据，去测试不同聚类算法的性能。 4、hadoop集群，K-means算法是很容易进行并行计算的。 二、K-means距离的定义：
tf-idf kmeans文本聚类
be_humble的博客
11-09 3748
文本聚类 数据集 THUnews中文新闻文本分类 方法 jieba分词后，使用tf-idf提取特征，提取时使用停用词表删除停用词，最后使用kmeans进行聚类。 优化 优化停用词表，增加max_feature特征，使用minibatchkmeans增加聚类速度 评价标准 外在（已知标签） 兰德基数RI ，调整兰德基数 ARI 内在 轮廓系数 from sklearn.feature_extraction.text import TfidfVectorizer import paddlenlp from
K-Means文本聚类python实现
05-04
本主题主要介绍如何使用Python实现K-Means算法对文本数据进行聚类。K-Means算法是一种简单而有效的聚类算法，适用于大数据集的处理，它通过迭代找到最佳的类别中心（质心）来划分数据。 首先，我们需要对文本数据...
使用Python和TF-IDF算法进行关键词提取
最新发布
09-13
在这个例子中，`TfidfVectorizer`首先创建了一个TF-IDF向量化器，然后使用`fit_transform`方法对语料库中的文本进行向量化处理，最后输出每个文档的关键词及其对应的TF-IDF值。 TF-IDF算法在文本挖掘、信息检索、...
Python-Moviebox基于内容的机器学习推荐系统利用tfidf和余弦相似性算法
08-11
Moviebox：基于内容的机器学习推荐系统利用tf-idf和余弦相似性算法
（python）使用余弦相似度算法计算两个文本的相似度的简单实现
05-08
在Python编程环境中，余弦相似度算法是一种常用于计算文本相似度的方法，尤其适用于文档向量化处理后的场景。本文将详细介绍如何使用Python实现余弦相似度，并探讨其背后的概念、步骤以及具体源码分析。 余弦相似度...
基于余弦距离的OPTICS聚类算法
11-20
改进后的OPTICS聚类算法matlab代码，将原来的欧氏距离改为余弦距离的倒数，适用于文本聚类。
基于TF-IDF与k-means的情感聚类
m0_52488320的博客
03-06 2891
目前很多情感聚类都是细分到逐词分析，而对于逐句的情感分析可以通过将文本转化为数字矩阵从而采用传统的聚类方法来实现，这里以K均值为例进行演示： import pandas as pd import codecs import matplotlib.pyplot as plt from sklearn.feature_extraction.text import TfidfTransformer from sklearn.feature_extraction.text impor...
[python] 基于k-means和tfidf的文本聚类代码简单实现
weixin_34124939的博客
01-08 4111
俗话说“外行看热闹，内行看门道“，作为一个机器学习的门外汉，刚研究python机器学习scikit-learn两周时间，虽然下面这段程序可能对于那些专研算法或机器学习的人来说非常简单，但对于一些入门的同学和我自己还是非常有帮助的。如果文章中有错误或不足之处，还请你微微一笑，原谅之；当然也非常欢迎你提出建议或指正~基本步骤包括： 1.使用...
基于余弦（欧式距离）的聚类
yahuuuwjl的博客
07-19 3753
参考这篇文章考虑质心问题：https://blog.csdn.net/xiaokang123456kao/article/details/74840843 欧式距离和余弦相似度的关系 欧氏距离能够体现个体数值特征的绝对差异，所以更多的用于需要从维度的数值大小中体现差异的分析，如使用用户行为指标分析用户价值的相似度或差异。 余弦距离更多的是从方向上区分差异，而对绝对的数值不敏感，更多的用于使用...
TF-IDF算法和余弦相似度算法计算文本相似度（纯手撕）
余俊晖，NLP炼丹师，目前专注自然语言处理领域研究。曾获得国内外自然语言处理算法竞赛TOP奖项近二十项。
09-06 9557
一、TF-IDF算法   TF-IDF（term frequency–inverse document frequency，词频-逆向文件频率）是一种用于信息检索（information retrieval）与文本挖掘（text mining）的常用加权技术。   TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。   TF-IDF的主要思想是：如果某个单词在一篇文章中
计算两篇文档的余弦相似度（tfidf）
kelly131313的博客
06-29 5014
# -*- coding:utf-8 -*- """ @author: Linlifang """ import os import jieba import sys import re import string from sklearn.feature_extraction.text import TfidfTransformer from sklearn.feature_extract
sklearn tfidf求余弦相似度_推荐算法原理（二）欧几里得距离计算物品间相似度...
weixin_39637386的博客
12-16 317
在上篇文章中介绍了如何利用余弦定理计算两个物品间的相似度：KiKlaus：推荐算法原理（一）余弦定理计算物品间相似度​zhuanlan.zhihu.com这种计算方法虽然简单，但是在衡量空间两个向量间值的大小差异时，会有明显的缺陷。例如，向量A（1，1，1），向量B（5，5，5），如果用余弦定理计算，那么这两个向量的夹角大小为0°，即在方向上是完全一致的，所以算法会认为这两个向量极相似。但是我们仔...
[文本语义相似] 基于tf-idf的余弦距离(gensim实现)
MachineLP的专栏
05-04 670
文本相似在问答系统中有很重要的应用，如基于知识的问答系统（Knowledge-based QA），基于文档的问答系统（Documen-based QA），以及基于FAQ的问答系统（Community-QA）等。像对于问题的内容，需要进行相似度匹配，从而选择出与问题最接近，同时最合理的答案。本节介绍基于bow的余弦距离计算相似度。 基于gensim的方式如下： import os i...
文本聚类分析k-means的整个过程代码，包括分词，tf-idf的计算
05-27
好的，下面是一个简单的文本聚类分析的 k-means 算法的代码，包括分词和 TF-IDF 的计算： ```python import jieba import numpy as np from sklearn.feature_extraction.text import TfidfVectorizer from sklearn....
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值