当前位置:   article > 正文

Boost搜索引擎:关键词搜索模块的构建

Boost搜索引擎:关键词搜索模块的构建

        关键词搜索模块是基于索引构建模块编写的。

搜索模块:

搜索模块是在服务器构建索引之后进行的,在构建好的索引的服务器上进行关键词搜索。

首先将用户提供的搜索内容进行,关键词分割,将分割好的关键词存放到一个数组中,再去遍历这个数组,里面的每一个元素都是一个搜索关键词,再调用Index索引构建模块中的查找倒排索引函数,找到与关键词相关的文档,再将这些文档存入tokens_map的map容器中。

如果用户搜索关键词在网页文档中存在的情况下,一个关键词对应一个倒排索引拉链(需要了解倒排索引拉链,以及每个结构体中的成员)。

tokens_map的map容器中存储的是文档ID和struct InvertedElemPrint结构体之间的对应关系。

  1. struct InvertedElemPrint{
  2. uint64_t doc_id;
  3. int weight;
  4. std::vector<std::string> words;
  5. InvertedElemPrint():doc_id(0), weight(0){}
  6. };

该结构体中存放的是这篇文档的文档ID,权值(所有关键词权值的总和),words容器中存的是那些关键词出现在了这篇文档中。我们可以利用这个words容器进行文章摘要的的提取,下面会提到。 

将不同关键词出现在同一文档中的权值进行加和,为了体现这篇文章与搜索内容之间的关系,权值越大表明这篇文章与搜索内容具有很强的相关性。

std::vector<InvertedElemPrint> inverted_list_all;

 将  std::unordered_map<uint64_t, InvertedElemPrint> tokens_map 中的文档全部放到inverted_list_all的vector容器利用总权值中进行排序,为用户呈现出最想要的内容。

  1. std::sort(inverted_list_all.begin(), inverted_list_all.end(),\
  2. [](const InvertedElemPrint &e1, const InvertedElemPrint &e2){
  3. return e1.weight > e2.weight;
  4. });

  排序语句是一条lambda表达式,你也可以写个仿函数传递给sort系统函数

  1. //4.[构建]:根据查找出来的结果,构建json串 -- jsoncpp --通过jsoncpp完成序列化&&反序列化
  2. Json::Value root;
  3. for(auto &item : inverted_list_all){
  4. ns_index::DocInfo * doc = index->GetForwardIndex(item.doc_id);
  5. if(nullptr == doc){
  6. continue;
  7. }
  8. Json::Value elem;
  9. elem["title"] = doc->title;
  10. elem["desc"] = GetDesc(doc->content, item.words[0]); //content是文档的去标签的结果,但是不是我们想要的,我们要的是一部分 TODO
  11. elem["url"] = doc->url;
  12. //for deubg, for delete
  13. elem["id"] = (int)item.doc_id;
  14. elem["weight"] = item.weight; //int->string
  15. root.append(elem);
  16. }
  17. //Json::StyledWriter writer;
  18. Json::FastWriter writer;
  19. *json_string = writer.write(root);

 

 最后将vector排好序的数据进行json串的构建,传递出去。 对于json相关知识不太了解的话,请搜所相关资料简单学习。

搜索模块代码:

  1. //query: 搜索关键字
  2. //json_string: 返回给用户浏览器的搜索结果
  3. void Search(const std::string &query, std::string *json_string)
  4. {
  5. //1.[分词]:对我们的query进行按照searcher的要求进行分词
  6. std::vector<std::string> words;
  7. ns_util::JiebaUtil::CutString(query, &words);
  8. //2.[触发]:就是根据分词的各个"词",进行index查找,建立index是忽略大小写,所以搜索,关键字也需要
  9. //ns_index::InvertedList inverted_list_all; //内部InvertedElem
  10. std::vector<InvertedElemPrint> inverted_list_all;
  11. std::unordered_map<uint64_t, InvertedElemPrint> tokens_map;
  12. for(std::string word : words){
  13. boost::to_lower(word);
  14. ns_index::InvertedList *inverted_list = index->GetInvertedList(word);
  15. if(nullptr == inverted_list){
  16. continue;
  17. }
  18. //不完美的地方:暂时可以交给大家 , 你/是/一个/好人 100
  19. //inverted_list_all.insert(inverted_list_all.end(), inverted_list->begin(), inverted_list->end());
  20. for(const auto &elem : *inverted_list){
  21. auto &item = tokens_map[elem.doc_id]; //[]:如果存在直接获取,如果不存在新建
  22. //item一定是doc_id相同的print节点
  23. item.doc_id = elem.doc_id;
  24. item.weight += elem.weight;
  25. item.words.push_back(elem.word);
  26. }
  27. }
  28. for(const auto &item : tokens_map){
  29. inverted_list_all.push_back(std::move(item.second));
  30. }
  31. //3.[合并排序]:汇总查找结果,按照相关性(weight)降序排序
  32. //std::sort(inverted_list_all.begin(), inverted_list_all.end(),\
  33. // [](const ns_index::InvertedElem &e1, const ns_index::InvertedElem &e2){
  34. // return e1.weight > e2.weight;
  35. // });
  36. std::sort(inverted_list_all.begin(), inverted_list_all.end(),\
  37. [](const InvertedElemPrint &e1, const InvertedElemPrint &e2){
  38. return e1.weight > e2.weight;
  39. });
  40. //4.[构建]:根据查找出来的结果,构建json串 -- jsoncpp --通过jsoncpp完成序列化&&反序列化
  41. Json::Value root;
  42. for(auto &item : inverted_list_all){
  43. ns_index::DocInfo * doc = index->GetForwardIndex(item.doc_id);
  44. if(nullptr == doc){
  45. continue;
  46. }
  47. Json::Value elem;
  48. elem["title"] = doc->title;
  49. elem["desc"] = GetDesc(doc->content, item.words[0]); //content是文档的去标签的结果,但是不是我们想要的,我们要的是一部分 TODO
  50. elem["url"] = doc->url;
  51. //for deubg, for delete
  52. elem["id"] = (int)item.doc_id;
  53. elem["weight"] = item.weight; //int->string
  54. root.append(elem);
  55. }
  56. //Json::StyledWriter writer;
  57. Json::FastWriter writer;
  58. *json_string = writer.write(root);
  59. }

文档摘要:

在讲struct InvertedElemPrint结构体时,我就提过摘要的获取.

  1. struct InvertedElemPrint{
  2. uint64_t doc_id;
  3. int weight;
  4. std::vector<std::string> words;
  5. InvertedElemPrint():doc_id(0), weight(0){}
  6. };

这里详细讲一下,对于words容器中存的是用户传上来的搜索关键词,是部分也可能是全部,这不重要。

我们在实现摘要提取时,是以words中第一个关键词为准。这里有人会问,为什么这样做?

原因是:我想这么做,图方便。但是有没有更优的办法,当然有,不然我也不肯提这个问题。

那怎么做呢?

  1. for(std::string word : words){
  2. boost::to_lower(word);
  3. ns_index::InvertedList *inverted_list = index->GetInvertedList(word);
  4. if(nullptr == inverted_list){
  5. continue;
  6. }
  7. //不完美的地方:暂时可以交给大家 , 你/是/一个/好人 100
  8. //inverted_list_all.insert(inverted_list_all.end(), inverted_list->begin(), inverted_list->end());
  9. for(const auto &elem : *inverted_list){
  10. auto &item = tokens_map[elem.doc_id]; //[]:如果存在直接获取,如果不存在新建
  11. //item一定是doc_id相同的print节点
  12. item.doc_id = elem.doc_id;
  13. item.weight += elem.weight;
  14. item.words.push_back(elem.word);
  15. }
  16. }

上面代码是Search()函数中,提取用户搜索关键词的倒排索引拉链,大家应该不陌生了吧。其实看懂上面的Search()函数,也可以想出来这样的解决方法,就是利用该关键词对应的权值进行排序

我么可以创建一个优先级队列再创建一个结构体,这个结构体成员就是:该关键词 和 该关键词对应的权值再写一个仿函数compare()比较函数(利用权值去比较),将存进去的这些结构体进行排序,优先级队列实则就是一个大堆,第一个元素就是权值最大的,最后再对优先级队列进行遍历,将里面的元素全部插入到words容器中,这样就实现了关键词的排序

我们在传入第一个关键词,给GetDesc()函数,去寻找该关键词周围的摘要。

 

  1. std::string GetDesc(const std::string &html_content, const std::string &word)
  2. {
  3. //找到word在html_content中的首次出现,然后往前找50字节(如果没有,从begin开始),往后找100字节(如果没有,到end就可以的)
  4. //截取出这部分内容
  5. const int prev_step = 50;
  6. const int next_step = 100;
  7. //1. 找到首次出现
  8. auto iter = std::search(html_content.begin(), html_content.end(), word.begin(), word.end(), [](int x, int y){
  9. return (std::tolower(x) == std::tolower(y));
  10. });
  11. if(iter == html_content.end()){
  12. return "None1";
  13. }
  14. int pos = std::distance(html_content.begin(), iter);
  15. //2. 获取start,end , std::size_t 无符号整数
  16. int start = 0;
  17. int end = html_content.size() - 1;
  18. //如果之前有50+字符,就更新开始位置
  19. if(pos > start + prev_step) start = pos - prev_step;
  20. if(pos < end - next_step) end = pos + next_step;
  21. //3. 截取子串,return
  22. if(start >= end) return "None2";
  23. std::string desc = html_content.substr(start, end - start);
  24. desc += "...";
  25. return desc;

 GetDesc()函数这个函数没什么技术难度,就是在简单的字符串查找,以及字符串截取,至于截取多少,因人而异,同时也要切合实际。将截取的摘要放到json串中。 

以上就是用户搜素内容和文档内容之间建立联系的过程,如有不懂尽可留言,你的留言是我最大的收获。

 

搜索模块的整体代码search.hpp:

  1. #pragma once
  2. #include "index.hpp"
  3. #include "util.hpp"
  4. #include "log.hpp"
  5. #include <algorithm>
  6. #include <unordered_map>
  7. #include <jsoncpp/json/json.h>
  8. namespace ns_searcher{
  9. struct InvertedElemPrint{
  10. uint64_t doc_id;
  11. int weight;
  12. std::vector<std::string> words;
  13. InvertedElemPrint():doc_id(0), weight(0){}
  14. };
  15. class Searcher{
  16. private:
  17. ns_index::Index *index; //供系统进行查找的索引
  18. public:
  19. Searcher(){}
  20. ~Searcher(){}
  21. public:
  22. void InitSearcher(const std::string &input)
  23. {
  24. //1. 获取或者创建index对象
  25. index = ns_index::Index::GetInstance();
  26. //std::cout << "获取index单例成功..." << std::endl;
  27. LOG(NORMAL, "获取index单例成功...");
  28. //2. 根据index对象建立索引
  29. index->BuildIndex(input);
  30. //std::cout << "建立正排和倒排索引成功..." << std::endl;
  31. LOG(NORMAL, "建立正排和倒排索引成功...");
  32. }
  33. //query: 搜索关键字
  34. //json_string: 返回给用户浏览器的搜索结果
  35. void Search(const std::string &query, std::string *json_string)
  36. {
  37. //1.[分词]:对我们的query进行按照searcher的要求进行分词
  38. std::vector<std::string> words;
  39. ns_util::JiebaUtil::CutString(query, &words);
  40. //2.[触发]:就是根据分词的各个"词",进行index查找,建立index是忽略大小写,所以搜索,关键字也需要
  41. //ns_index::InvertedList inverted_list_all; //内部InvertedElem
  42. std::vector<InvertedElemPrint> inverted_list_all;
  43. std::unordered_map<uint64_t, InvertedElemPrint> tokens_map;
  44. for(std::string word : words){
  45. boost::to_lower(word);
  46. ns_index::InvertedList *inverted_list = index->GetInvertedList(word);
  47. if(nullptr == inverted_list){
  48. continue;
  49. }
  50. //不完美的地方:暂时可以交给大家 , 你/是/一个/好人 100
  51. //inverted_list_all.insert(inverted_list_all.end(), inverted_list->begin(), inverted_list->end());
  52. for(const auto &elem : *inverted_list){
  53. auto &item = tokens_map[elem.doc_id]; //[]:如果存在直接获取,如果不存在新建
  54. //item一定是doc_id相同的print节点
  55. item.doc_id = elem.doc_id;
  56. item.weight += elem.weight;
  57. item.words.push_back(elem.word);
  58. }
  59. }
  60. for(const auto &item : tokens_map){
  61. inverted_list_all.push_back(std::move(item.second));
  62. }
  63. //3.[合并排序]:汇总查找结果,按照相关性(weight)降序排序
  64. //std::sort(inverted_list_all.begin(), inverted_list_all.end(),\
  65. // [](const ns_index::InvertedElem &e1, const ns_index::InvertedElem &e2){
  66. // return e1.weight > e2.weight;
  67. // });
  68. std::sort(inverted_list_all.begin(), inverted_list_all.end(),\
  69. [](const InvertedElemPrint &e1, const InvertedElemPrint &e2){
  70. return e1.weight > e2.weight;
  71. });
  72. //4.[构建]:根据查找出来的结果,构建json串 -- jsoncpp --通过jsoncpp完成序列化&&反序列化
  73. Json::Value root;
  74. for(auto &item : inverted_list_all){
  75. ns_index::DocInfo * doc = index->GetForwardIndex(item.doc_id);
  76. if(nullptr == doc){
  77. continue;
  78. }
  79. Json::Value elem;
  80. elem["title"] = doc->title;
  81. elem["desc"] = GetDesc(doc->content, item.words[0]); //content是文档的去标签的结果,但是不是我们想要的,我们要的是一部分 TODO
  82. elem["url"] = doc->url;
  83. //for deubg, for delete
  84. elem["id"] = (int)item.doc_id;
  85. elem["weight"] = item.weight; //int->string
  86. root.append(elem);
  87. }
  88. //Json::StyledWriter writer;
  89. Json::FastWriter writer;
  90. *json_string = writer.write(root);
  91. }
  92. std::string GetDesc(const std::string &html_content, const std::string &word)
  93. {
  94. //找到word在html_content中的首次出现,然后往前找50字节(如果没有,从begin开始),往后找100字节(如果没有,到end就可以的)
  95. //截取出这部分内容
  96. const int prev_step = 50;
  97. const int next_step = 100;
  98. //1. 找到首次出现
  99. auto iter = std::search(html_content.begin(), html_content.end(), word.begin(), word.end(), [](int x, int y){
  100. return (std::tolower(x) == std::tolower(y));
  101. });
  102. if(iter == html_content.end()){
  103. return "None1";
  104. }
  105. int pos = std::distance(html_content.begin(), iter);
  106. //2. 获取start,end , std::size_t 无符号整数
  107. int start = 0;
  108. int end = html_content.size() - 1;
  109. //如果之前有50+字符,就更新开始位置
  110. if(pos > start + prev_step) start = pos - prev_step;
  111. if(pos < end - next_step) end = pos + next_step;
  112. //3. 截取子串,return
  113. if(start >= end) return "None2";
  114. std::string desc = html_content.substr(start, end - start);
  115. desc += "...";
  116. return desc;
  117. }
  118. };
  119. }

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/我家自动化/article/detail/895821
推荐阅读
相关标签
  

闽ICP备14008679号