コード例 #1
0
 @Override
 public Collection<Concept> getConcepts(String key) {
   Collection<Concept> concepts = super.getConcepts(key);
   if (BlankUtils.isBlank(concepts)) {
     concepts = autoCombineConcepts(key, null);
   }
   return concepts;
 }
コード例 #2
0
  /**
   * 把未登录词进行概念切分, 形成多个概念的线性链表,并倒排组织, 如“娱乐场”切分完毕后存放成: 【场】 → 【娱乐】
   *
   * @param oov_word 未登录词
   * @return
   */
  private List<String> segmentOOV(String oov_word, int topN) {
    List<String> results = new LinkedList<>();

    String word = oov_word;
    int count = 0;
    while (word != null && !word.equals("")) {
      String token = word;
      while (token.length() > 1 && BlankUtils.isBlank(super.getConcepts(token))) {
        token = token.substring(1);
      }
      results.add(token);
      count++;
      if (count >= topN) break;

      word = word.substring(0, (word.length() - token.length()));
    }

    return results;
  }
コード例 #3
0
  /**
   * 计算未登录词语oov_word自动组合语义
   *
   * @param oov_word 未登录词,此处指知网概念中未出现的词语,需要进行切分,求解组合语义, 组合的语义关系通过参照概念refConcepts进行修正
   * @param refConcepts 简单计算出的oov_word的概念定义,需要通过refConcepts修正义原之间的符号、关系等
   * @return
   */
  public Collection<Concept> autoCombineConcepts(String oov_word, Collection<Concept> refConcepts) {
    ConceptLinkedList oovConcepts = new ConceptLinkedList();

    if (oov_word == null) {
      return oovConcepts;
    }

    // 只获取倒排后的三个未识别词语,如果太多了,一方面会影响运行速度,另一方面组合过多的意义也不是很有用
    for (String concept_word : segmentOOV(oov_word, 3)) {
      Collection<Concept> concepts = super.getConcepts(concept_word);
      if (oovConcepts.size() == 0) {
        oovConcepts.addAll(concepts);
        continue;
      }

      ConceptLinkedList tmpConcepts = new ConceptLinkedList();
      for (Concept head : concepts) {
        for (Concept tail : oovConcepts) {
          if (!BlankUtils.isBlank(refConcepts)) {
            for (Concept ref : refConcepts) {
              tmpConcepts.addByDefine(autoCombineConcept(head, tail, ref));
            }
          } else {
            tmpConcepts.addByDefine(autoCombineConcept(head, tail, null));
          }
        }
      }
      oovConcepts = tmpConcepts;
    }

    /** 如果组合过多,则删除最后的1/3个组合 */
    if ((oovConcepts.size() > MAX_COMBINED_COUNT)) {
      oovConcepts.removeLast(MAX_COMBINED_COUNT / 3);
    }

    return oovConcepts;
  }
コード例 #4
0
  /**
   * 获取两个词语的相似度,如果一个词语对应多个概念,则返回相似度最大的一对
   *
   * @param word1
   * @param word2
   * @return
   */
  @Override
  public double getSimilarity(String word1, String word2) {
    double similarity = 0.0;

    // 如果两个词语相同,则直接返回1.0
    if (word1.equals(word2)) {
      return 1.0;
    }

    Collection<Concept> concepts1 = super.getConcepts(word1);
    Collection<Concept> concepts2 = super.getConcepts(word2);

    // 如果是blank,则说明是未登录词, 需要计算组合概念
    if (BlankUtils.isBlank(concepts1) && !BlankUtils.isBlank(concepts2)) {
      concepts1 = autoCombineConcepts(word1, concepts2);
    } else if (BlankUtils.isBlank(concepts2) && !BlankUtils.isBlank(concepts1)) {
      concepts2 = autoCombineConcepts(word2, concepts1);
    } else if (BlankUtils.isBlank(concepts1) && BlankUtils.isBlank(concepts2)) {
      concepts1 = autoCombineConcepts(word1, concepts2);
      concepts2 = autoCombineConcepts(word2, concepts1);
      // 相互修正
      concepts1 = autoCombineConcepts(word1, concepts2);
      concepts2 = autoCombineConcepts(word2, concepts1);
    }

    // 两个for循环分别计算词语所有可能的概念的相似度
    for (Concept c1 : concepts1) {
      for (Concept c2 : concepts2) {
        double v = getSimilarity(c1, c2);

        if (v > similarity) {
          similarity = v;
        }

        if (similarity == 1.0) {
          break;
        }
      }
    }

    return similarity;
  }