西南交大互联网搜索引擎课程设计（二）--建立搜索引擎

最新推荐文章于 2024-05-15 14:07:26 发布
最新推荐文章于 2024-05-15 14:07:26 发布
阅读量2.4k 收藏 16
点赞数 4
分类专栏： 大学课程设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mm1030533738/article/details/80871625
版权

1、项目介绍
1.1 项目需求分析
1.2 技术可行性分析
1.2.1 建立并实现搜索引擎功能
1.2.2 比较文档之间的相似度
1.2.3 对下载的文档，利用K-Means聚类算法进行聚类
1.3 项目环境介绍
1.3.1 运行环境
1.3.2 第三方工具包
1.3.3 数据来源

2、 项目实现
2.1 建立索引
2.1.1 新建文件工具类
2.1.2 对中英文预处理文件建立索引
2.2 搜索引擎界面
2.2.1 中英文选择和搜索以及执行查询
2.2.2 查询结果显示
2.2.3 打开目标预处理文件及源文件
2.3 比较文档之间的相似度
2.3.1 余弦距离原理
2.3.2 TF-IDF算法原理
2.3.3 建立文档相似度比较的界面
2.3.4 相似度计算
2.3.5 结果展示
2.4对下载的文档，利用K-Means聚类算法进行聚类
2.4.1 算法原理
2.4.2 中文文档的处理
2.4.3 中文文档的处理结果
2.4.4 英文文档的处理
2.4.5 英文文档的处理结果

3、 附录
3.1 项目总结
3.2 参考文献

java工程链接
工程目录

参考文档1：TF-IDF与余弦相似性的应用（一）：自动提取关键词

参考文档2：TF-IDF与余弦相似性的应用（二）：找出相似文章

根据K-means算法写了java版的多文本聚类算法：

package com.search;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class KmeansTest {

    static String FileAddr1 = "E:\\eclipse\\java\\IR\\text1\\"; //中文
    static String fileContent1 = ""; //中文文档内容

    static double temp0,temp1,temp2,temp,minV;
    static int CPR[] = new int[500],minI;

    //获取所有文章的各自的向量
    public static double[][]  getVectors() {

        double CV[][] = new double[500][100]; //未初始化，默认为0.0  因为如果取最大的向量数，会导致程序溢出，则只取前100向量

        for(int i = 0;i < 500; i ++) {
            try   
            {       
                File f = new File(FileAddr1 + "school_" + String.valueOf(i+1) + "_C.txt");      
                if(f.isFile()&&f.exists())  
                {       
                    InputStreamReader read = new InputStreamReader(new FileInputStream(f),"utf-8");       
                    BufferedReader reader=new BufferedReader(read);       
                    String line;       
                    while ((line = reader.readLine()) != null)   
                    {        
                        fileContent1 += line + "\n";       
                    }         
                    read.close();      
                }
                Map<String, Integer> fileContent1TfMap=TfIdfAlgorithm.segStr(fileContent1);
                List<Map.Entry<String, Integer>> fileContent1List = new ArrayList<Map.Entry<String, Integer>>(fileContent1TfMap.entrySet());
                //获取每个文章的向量
                for(int j = 0; j < 98; j ++) {
                    CV[i][j] = fileContent1List.get(j).getValue().doubleValue();
                }

                //倒数第二位记录这是哪个文章，即文章的编号
                CV[i][98] = i+1;


            } catch (Exception ee)   
            {         
                ee.printStackTrace();     
            } 
        }
        //返回所有文档的向量
        return CV;
    }

    public static double[][] kmeans(){
        KmeansTest km = new KmeansTest();
        double CV[][] = km.getVectors();
        double CP[][] = new double[20][100];
        double CPM[] = new double[500];  //新中心点的暂时存放
        //1.初始化中心点（取前20个点为中心点）
        for(int i = 0; i < 20; i ++) {
            for(int j = 0; j < 100; j ++ ) {
                CP[i][j] = CV[i][j];
            }
            CP[i][99] = 1.0; //最后一位为1则表示此点为中心点，为0则表示普通点（默认为0）
            CV[i][99] = 1.0; //最后一位为1则表示此点为中心点，为0则表示普通点（默认为0）


        }

        //输出第一次的中心点
        System.out.println("** 第1次初始化的中心点： **");
        for(int i = 0; i < 20; i ++) {
            System.out.print((int)CP[i][98] + " | ");
        }


        //初始化聚类记录
        for(int i = 0; i < 500; i ++) {
            CPR[i] = -1;
        }


        //2.计算剩余文章与中心点的余弦距离最小的，进行聚类
        for(int j = 0; j < 500; j ++) {
            if(CV[j][99] != 1.0) {//非中心点
//          System.out.println("j = "+String.valueOf(j));
            for(int i = 0; i < 20; i ++) { 
                for(int k = 0; k < 98; k ++) {
                    temp0 = temp0 + CV[j][k] * CP[i][k];
                    temp1 = temp1 + CV[j][k] * CV[j][k];
                    temp2 = temp2 + CP[i][k] * CP[i][k];
                }
                temp = temp0/(Math.sqrt(temp1)*Math.sqrt(temp2));
                if(i == 0) {
                    minV = temp;
                    minI = 0;
                }else if(minV > temp) {
                    minV = temp;
                    minI = i;
                }
                if(i == 19) {
                    CPR[j] = minI; //记录剩余的文章与20个中心文章余弦距离最小的序号
//                  System.out.println("minI: "+String.valueOf(minI) + "--"+String.valueOf(j)+"--"+String.valueOf(minV));
                }
                }
            }
        }

        //3.显示第一次聚类的结果
        System.out.println("\n=====第1次聚类的结果:=====");
        for(int i = 0; i < 20; i ++) {
            System.out.print(String.valueOf(i)+" : ");
            for(int j = 0; j < 500; j ++) {
                if(CPR[j] == i) {
                    System.out.print(String.valueOf(j)+" / ");
                }
            }
            System.out.println();
        }



        //4.重新计算中心点
        //4.1计算新的伪中心点
        int dex;
        for(int i = 0; i < 20; i ++) {
            //聚类数目初始化
            dex = 1;
            //CPM初始化
            for(int k = 0; k < 500; k ++) {
                CPM[k] = 0;
            }
            //
            for(int j = 0; j < 500; j ++) { 
                if(CV[j][99] != 1.0) {//如果为普通点
                    if(CPR[j] == i) { 
                        for(int m = 0; m < 98; m ++) {
                            CPM[m] += CP[i][m] + CV[j][m];
                            dex ++;
                        }
                    }
                }
            }
            for(int n = 0; n < 98; n ++) {//获取该类的平均值点，准备计算新的中心点
                if(dex == 1) {
                    CPM[n] = CP[i][n];
                }else {
                    CPM[n] = CPM[n] / dex;
                }
            }
//          System.out.println("\n** 计算得到的伪中心点： **");
//          for(int n = 0; n < 98; n ++) {//获取该类的平均值点，准备计算新的中心点
//              System.out.print(String.valueOf(CPM[n]) + " ");
//          }
//          System.out.println("\n");


            //4.2计算新的实际中心点
            int isfirst = -1;
            for(int j = 0; j < 500; j ++) {//以最靠近新的中心点的点为新的中心点
                if(dex == 1) {
                    //中心点不变，不做操作
                }else if(CV[j][99] != 1.0) { //非中心点
                    for(int m = 0; m < 98; m ++) {
                        temp0 = CV[j][m] * CPM[m];
                        temp1 = CV[j][m] * CV[j][m];
                        temp2 = CPM[m] * CPM[m];
                    }
                    temp = temp0/(Math.sqrt(temp1)*Math.sqrt(temp2));
                    if(isfirst == -1) {
                        isfirst *= -1;
                        minV = temp;
                        minI = j;
                    }else if(temp < minV) {
                        minV = temp;
                        minI = j;
                    }
                    if(j == 499) {
                        //更新中心点
                        for(int m = 0; m < 97; m ++) {
                            CP[i][m] = CV[minI][m];
                        }
                        CP[i][98] = CV[minI][98];
                        //已经变成中心点的改变中心点标志
                        CV[minI][99] = 1;
                    }
                }
            }
        }
        //输出第二次的中心点
        System.out.println("\n\n\n** 第2次初始化的中心点： **");
        for(int i = 0; i < 20; i ++) {
//          for(int j = 0; j < 100; j ++ ) {
//              System.out.print(CP[i][j] + " ");
//          }
            System.out.print((int)CP[i][98] + " | ");
        }



        System.out.println("\n\n\n** 继续聚类： **");

        //接下来进行“重复”聚类工作
        //聚类完成标志
        boolean isStop = false;
        int ndex = 2;
        while(true) {
            //1.初始化
            //初始化CV中非中心点的中心点标志为0,为中心点的标号为1
            for(int i = 0; i < 500; i ++) {
                CV[i][99] = 0;
            }
            for(int j = 0; j < 20; j ++) {
                for(int i = 0; i < 500; i ++) {
                    if(CP[j][98] == CV[i][98]) {
                        CV[i][99] = 1;
                    }
                }
            }
            //初始化聚类记录
            for(int i = 0; i < 500; i ++) {
                CPR[i] = -1;
            } 

            //2.计算剩余文章与中心点的余弦距离最小的，进行聚类
            for(int j = 0; j < 500; j ++) {
                if(CV[j][99] != 1.0) {  //非中心点
//              System.out.println("j = "+String.valueOf(j));
                for(int i = 0; i < 20; i ++) {
                    for(int k = 0; k < 98; k ++) {
                        temp0 = temp0 + CV[j][k] * CP[i][k];
                        temp1 = temp1 + CV[j][k] * CV[j][k];
                        temp2 = temp2 + CP[i][k] * CP[i][k];
                    }
                    temp = temp0/(Math.sqrt(temp1)*Math.sqrt(temp2));
                    if(i == 0) {
                        minV = temp;
                        minI = 0;
                    }else if(minV > temp) {
                        minV = temp;
                        minI = i;
                    }
                    if(i == 19) {
                        CPR[j] = (int)CP[minI][98]; //记录剩余的80个文章中的该文章与20个中心文章余弦距离最小的序号
//                      System.out.println("minI: "+String.valueOf(minI) + "--"+String.valueOf(j)+"--"+String.valueOf(minV));
                    }
                    }
                }
            }

            //3.显示第n次聚类的结果
            System.out.println("\n=====第"+(ndex++)+"次聚类的结果:=====");
            for(int i = 0; i < 20; i ++) {
                System.out.print((int)CP[i][98]+" : ");
                for(int j = 0; j < 500; j ++) {
                    if(CPR[j] == CP[i][98]) {
                        System.out.print(String.valueOf(j)+" / ");
                    }
                }
                System.out.println();
            }

            //4.重新计算中心点
            //4.1计算新的伪中心点
            int dex1;
            for(int i = 0; i < 20; i ++) {
                //聚类数目初始化
                dex = 1;
                //CPM初始化
                for(int k = 0; k < 500; k ++) {
                    CPM[k] = 0;
                }
                //
                for(int j = 0; j < 500; j ++) { 
                    if(CV[j][99] != 1.0) {//如果为普通点
                        if(CPR[j] == i) { 
                            for(int m = 0; m < 98; m ++) {
                                CPM[m] += CP[i][m] + CV[j][m];
                                dex ++;
                            }
                        }
                    }
                }
                for(int n = 0; n < 98; n ++) {//获取该类的平均值点，准备计算新的中心点
                    if(dex == 1) {
                        CPM[n] = CP[i][n];
                    }else {
                        CPM[n] = CPM[n] / dex;
                    }
                }
//              System.out.println("\n** 计算得到的伪中心点： **");
//              for(int n = 0; n < 98; n ++) {//获取该类的平均值点，准备计算新的中心点
//                  System.out.print(String.valueOf(CPM[n]) + " ");
//              }
//              System.out.println("\n");
                //4.2计算新的实际中心点
                int isfirst = -1;
                for(int j = 0; j < 500; j ++) {//以最靠近新的中心点的点为新的中心点
                    if(dex == 1) {
                        //中心点不变，不做操作
                    }else if(CV[j][99] != 1.0) { //非中心点
                        for(int m = 0; m < 98; m ++) {
                            temp0 = CV[j][m] * CPM[m];
                            temp1 = CV[j][m] * CV[j][m];
                            temp2 = CPM[m] * CPM[m];
                        }
                        temp = temp0/(Math.sqrt(temp1)*Math.sqrt(temp2));
                        if(isfirst == -1) {
                            isfirst *= -1;
                            minV = temp;
                            minI = j;
                        }else if(temp < minV) {
                            minV = temp;
                            minI = j;
                        }
                        if(j == 499) {
                            //更新中心点
                            for(int m = 0; m < 98; m ++) {
                                CP[i][m] = CV[minI][m];
                            }
                            CP[i][98] = CV[minI][98];
                            //已经变成中心点的改变中心点标志
                            CV[minI][99] = 1;
                            //标识已参与聚类
                            CV[minI][97] = 1;
                        }

                    }
                }
            }

            if(ndex == 10) {
                System.out.println("\n\n* 聚类结束，共聚类" + ndex + "次*");
                break;
            }
            //输出第n次的中心点
            System.out.println("\n\n\n** 第"+ndex+"次初始化的中心点： **");
            for(int i = 0; i < 20; i ++) {
                System.out.print((int)CP[i][98] + " | ");
            }
        }
        return CP;
    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis(); 
        KmeansTest kk = new KmeansTest();
        double CVV[][] = kk.kmeans();
        long end = System.currentTimeMillis();        
        System.out.println("运行时间："+(end-start)/1000+"秒");
    }
}
阿懵
关注
  • 4
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
搜索引擎设计实用教程(4)-以百度为例
张俊林的博客
11-29 8389
/*版权声明：可以任意转载，转载时请务必标明文章原始出处和作者信息 .*/搜索引擎设计实用教程(4)-以百度为例                           之四:相关提示功能                            中科院软件所 malefactor2005年11月    相关提示也是几乎所有搜索引擎提供的一个附加功能,所谓相关提示,就是对于用户提交的查询进行分析,然后根据
西南交大互联网搜索引擎课设
07-27
【西南交大互联网搜索引擎课设】是一门针对计算机科学与技术专业的学生设计的课程实践项目，旨在让学生深入了解和掌握搜索引擎的工作原理与实现技术。在这个项目中，学生将有机会亲自构建一个简单的搜索引擎，从而...
搜索引擎学习总结
blue0bird的专栏
02-08 4101
1 搜索引擎的发展史 1-1 第一代文本检索 1-2第二代连接分析 1-3 第三代用户中心 2 搜索引擎基本构成 3 网络爬虫 3-1 抓取策略 3-1-1 宽度优先遍历策略 Breath First 3-1-2 非完全PageRank策略 Partial PageRank 3-1-3 OCIP策略 Online Page Importance Computation 3-1-4 大站优先...
西南交通大学 西南交大 互联网搜索引擎 作业\课设\项目
03-15
西南交通大学 西南交大 互联网搜索引擎 作业\课设\项目 仅供学弟学妹们参考 请勿直接抄袭
大数据最全【elasticsearch实战】从零开始设计全站搜索引擎(6)，2024年最新真的醉了
最新发布
m0_74932057的博客
05-15 820
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！该服务包括：搜索门户api、权限控制、搜索能力、搜索混排、搜索热词、联想关键词。由于自主维护的数据和第三方数据源数据都存储在es中，因此可以直接使用评分进行合并，如下
搜索引擎web课程设计
06-28
很详细的课程设计，对你有很大的帮助哦！ 设计一个搜索引擎。 设计要求：能够根据浏览者输入的字符串，在网站中搜索文件或网页的内容、标题、文件名、作者等信息是否与搜索字符相符。
西南交大 搜索引擎的使用方法
05-18
这是西南交大为学生准备的ppt课件，主题是如何高效的使用搜索引擎得到自己需要的资源。里面提供了很多使用技巧。
西南交大互联网搜索引擎期末复习提纲
阿懵
06-30 1279
根据课堂PPT总结：
swjtu西南交大互联网搜索引擎 项目一 报告：搜索引擎文本预处理
04-22
将中文文档进行字符化，即可被搜索引擎索引的字符单元 对于英文文档，经过以上处理之后，将经过处理之后所形成简化文档保存（如:News_1_E.txt），以备以后的索引处理 对于中文文档，经过以上处理之后，将经过处理...
互联网搜索引擎.zip
05-08
本资料包“互联网搜索引擎.zip”围绕这个主题展开，包含了关于搜索引擎技术的深入学习材料，特别是与西南交通大学（SWJTU）相关的研究和实践。 首先，我们关注“互联网搜索引擎.docx”，这很可能是对搜索引擎工作...
【数据结构课程设计】简单搜索引擎系统
m0_74071853的博客
01-18 1774
该程序使用python语言实现利用爬虫代码爬取网站链接信息，将网站中文词语通过结巴分词进行分割，并存储爬取的数据信息，利用结巴分词库处理输入框用户输入的词语，进行搜索，通过链接评价函数，优先显示评分较高的链接；设计简单的html页面，实现可视化搜索功能。爬虫模块spyder.py——爬取给定网页的子链接，存储数据到.db文件中搜索模块searchengine.py——定义搜索引擎类，需要根据用户搜索的字符串分割成多个关键词，再根据三种评判算法综合评价各个链接，查询相关链接，并实现网页的建立。
基于10000网页python搭建搜索引擎课程设计
01-07
10000网页简单上手，代码和配置环境全部写好，傻瓜式操作。 执行文件顺序是 1.Spider.py进行爬取网页并分析 2.index.py生成倒排索引，idf文件 3.app.py运行搜索引擎 4.在默认浏览器输入 http://localhost:8080/ 进行检索 若要使用数据库 1.writeDB.py写倒排索引与idf(时间较长) 2.可以在summary.py切换from DB_search import s使用数据库 注意： 还需要停用词是stopwords.txt
互联网搜索引擎PPT完整版
06-22
本资源包含了本学期所上课程互联网搜索引擎的所有PPT完整版，里面很详细地讲解了聚类、分类、tfidf、倒排表、多媒体搜索等知识点，需要的可以自取！
搜索引擎优化基础
12-04
搜索引擎优化基础，SEO学习者必备学习资料。最新的SEO知识
搜索引擎考试重点
05-13
 数据抓取子系统：是及时、高效的收集数量尽可能多的有用的万维网页面，以及建立他们之间的超链接的关系。  内容索引子系统：网页检索子系统的主要职责就是组织好海量的网页数据，是内容检索子系统能够高效的进行检索。  内容检索子系统：计算用户输入查询词与系统索引页面的内容相关程度，它是决定页面顺序的重要因素之一。  链接结构分析子系统：通过对万维网索引链接结构的挖掘，分析评估万维网数据的质量、扩充万维网数据的描述内容，为提升搜索引擎系统的整体性能服务。
西南交大java课程设计作业.rar
10-06
java编程制作"用鼠标移动滑板来接住随机弹射的小球"的简易游戏。代码齐全，整理好放在了word文档中。
搜索引擎项目
weixin_30301449的博客
08-28 177
对从网络上抓取到的网页进行处理：建立网络库，分词，去重，if-tdf计算权重，归一化，然后根据查询词将文本相似度从高到低的依次返回给客户 第一阶段：python网络爬虫抓取网页，并存盘 第二阶段：对磁盘上的网页文件建立网页库，将全部网页写入网页库，并建立相应网页的偏移量索引文件(1 23 100)-->(dofid, offset, size)，以便读取网页内容...
智能信息检索课程设计
clown0004的博客
03-30 1529
根据自己从网上下载的任意文档集，采用python程序设计语言，进行分词，再去掉停用词和标点符号等，生成文档的词典，接着根据词典和文档内容生成词项的倒排记录表（含位置信息），然后根据搜索关键字（多个词项），对文档集进行短语查询，符合检索条件的文档计算余弦相似度，按从大到小的顺序显示，然后进行查询扩展。
智能科学毕设分享(含算法) 基于python的搜索引擎设计与实现
PEEleeer的博客
01-03 971
今天学长向大家分享一个毕业设计项目毕业设计 基于python的搜索引擎设计与实现毕业设计 基于python的搜索引擎随着互联网和宽带上网的普及， 搜索引擎在中国异军突起， 并日益渗透到人们的日常生活中， 在互联网普及之前， 人们查阅资料首先想到的是拥有大量书籍的资料的图书馆。但是今天很多人都会选择一种更方便、 快捷、 全面、 准确的查阅方式–互联网。而帮助我们在整个互联网上快速地查找到目标信息的就是越来越被重视的搜索引擎。今天学长来向大家介绍如何使用python写一个搜索引擎，该项目常用于毕业设计。
西南交通大学 数据库课程设计 酒店管理系统.pdf
07-03
“西南交通大学 数据库课程设计 酒店管理系统.pdf”是一份关于数据库课程设计的报告，内容涉及酒店管理系统的详细设计过程，包括需求分析、概念设计和逻辑设计阶段。该报告由西南交通大学的学生完成，旨在实践和理解...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值