精华内容
下载资源
问答
  • 通过Item-based算法对标签进行匹配推 荐,以缩短系统的推荐时间以及资源占用率。为了验证所构建系统的有效性和可靠性,分别进行了两组对比实验,第一组 实验为添加了Apriori算法的协同过滤算法与传统协同过滤算法在...
  • (字符串匹配算法研究工具)是为字符串匹配研究人员提供标准框架的工具。 它可以帮助用户测试,设计,评估和了解针对精确字符串匹配问题的现有解决方案。 此外,它提供了(几乎)所有字符串匹配算法的实现以及大量...
  • 现有的主流商业信息检索系统大部分采用基于 关键词精确匹配的检索技术 , 取得了一定的成果 但是在实际应用中 , 用户的查询...索根据用户输入的模糊特征来检索匹配内容 , 可处 理精确的关键词匹配所无法解决的这些问题
  • 在现代中文信息检索系统中,用户输入的字符串和实际数据库中的条目往往存在局部偏差,而基于关键词 匹配的检索技术不能很好地解决这一问题。本文参考并改进了Tarhio和Ukkonen提出的过滤算法 ],针对汉字 拼音输入法...
  • GCM:一种基于贪婪的交叉匹配算法,用于跨多个在线社交网络识别用户
  • 提出基于动态模板匹配算法的3D手势识别系统,通过智能穿戴设备收集用户的特定手势来判断手势的含义,从而利用更自然的人机交互技术实现对智能设备的控制。使用智能设备的运动传感器读取相应的3D手势数据,结合优化的...
  • 串的模式匹配算法,通俗地理解,是一种用来判断两个串之间是否具有"主串与子串"关系的算法。 主串与子串:如果串 A(如 "shujujiegou")中包含有串 B(如 "ju"),则称串 A 为主串,串 B 为子串。主串与子串之间的...

    的模式匹配算法,通俗地理解,是一种用来判断两个串之间是否具有"主串与子串"关系的算法。

    主串与子串:如果串 A(如 "shujujiegou")中包含有串 B(如 "ju"),则称串 A 为主串,串 B 为子串。主串与子串之间的关系可简单理解为一个串 "包含" 另一个串的关系。

    实现串的模式匹配的算法主要有以下两种:

    1. 普通的模式匹配算法;
    2. 快速模式匹配算法

    本节,先来学习普通模式匹配(BF)算法的实现。

    BF算法原理

    普通模式匹配算法,其实现过程没有任何技巧,就是简单粗暴地拿一个串同另一个串中的字符一一比对,得到最终结果。

    例如,使用普通模式匹配算法判断串 A("abcac")是否为串 B("ababcabacabab")子串的判断过程如下:

    首先,将串 A 与串 B 的首字符对齐,然后逐个判断相对的字符是否相等,如 1 所示:

    展开全文
  • 一种改进的基于低样本率数据集地图匹配算法,王东,李论,地图匹配算法是将一组有序的用户采集的GPS位置信息映射到电子地图中的路径网络中的方法。现有的基于低样本率数据集的地图匹配算法
  • 针对离散评分不能合理表达用户观点和传统协同过滤算法存在稀疏性等问题,借鉴年龄模糊模型,提出了梯形模糊评分模型。该模型将离散评分模糊化为梯形模糊数,考虑了评分模糊性和信息量,通过梯形模糊数来计算用户...
  • 本文针对低采样率GPS轨迹提出了一种新的全局地图匹配算法ST-Matching.ST-Matching考虑(1)道路网络的空间几何和拓扑结构以及(2)时空轨迹的速度限制。 基于时空分析,构造候选图,从中识别出最佳匹配路径序列。 ...
  • sketch_ui:尝试草图映射匹配算法用户界面
  • 正向最大匹配算法:从左到右将待分词文本中的几个连续字符与词表匹配,如果匹配上,则切分出一个词,并且要做到最大匹配。 反向最大匹配算法:从右到左将待分词文本中的几个连续字符与词表匹配,如果匹配上,则切分...

    正向最大匹配算法:从左到右将待分词文本中的几个连续字符与词表匹配,如果匹配上,则切分出一个词,并且要做到最大匹配。
    反向最大匹配算法:从右到左将待分词文本中的几个连续字符与词表匹配,如果匹配上,则切分出一个词,并且要做到最大匹配。
    这份代码对正向最大匹配算法和反向最大匹配算法进行封装,需要在代码的目录下存放一份词典,词典取名为:chineseDic.txt。
    样例如下:

    ,nr
    劼人,nr
    勍,nr
    喆,nr
    揳入,v
    

    即可以是无headers的csv格式文件,词,词性这样的格式存放。
    代码如下:

    #!/usr/bin/python3
    # -*- coding:utf-8 -*-
    # Author:ChenYuan
    import time
    import os
    
    
    class CSegment(object):
        
        def __init__(self):
            self.question = None
            self.true_index = []
            self.with_user_dict = False
            self.reverse = False
            self.result_reverse = False
            self.MM_result_index = []
            self.RMM_result_index = []
            self.MM_result_list = []
            self.RMM_result_list = []
            self.word_pos_dict = {}
    
        def read_user_dict(self, dict_path):
            """
            :param dict_path: 用户定义的词典文件
            :return:
            """
            tic = time.clock()
            word_pos = {}
            if not os.path.exists(dict_path):
                print('该文件不存在')
                assert os.path.exists(dict_path) is True
            with open(dict_path, 'r')as fp:
                for line in fp:
                    line = line.strip()
                    word = line.split(',')[0]
                    pos = line.split(',')[1]
                    word_pos[word] = pos
            self.word_pos_dict = word_pos
            self.with_user_dict = True
            toc = time.clock()
            time_clock = toc - tic
            print('\033[1;31;47m')
            print('*' * 50)
            print('*Load user dict:\t', dict_path)
            print('*Load time:\t', time_clock)
            print('*' * 50)
            print('\033[0m')
    
        def read_true_sentence(self, true_result):
            """
            :param true_result: 正确的分词结果
            :return: 分词结果的下表元组列表
            """
            if len(true_result) == 0:
                return []
            else:
                true_list = [t.strip() for t in true_result.split('/')]
                true_index = []
                index = 0
                for t in true_list:
                    lth = len(t)
                    if index + lth == len(self.question):
                        break
                    if self.question[index:index + lth] == t:
                        true_index.append(str((index, index + lth)))
                        index += lth
                return true_index
    
        def get_true_index(self, result_list):
            """
            :param result_list: 结果列表
            :return: 结果对应的下表列表
            """
            if self.reverse:
                self.reverse = False
                return self.RMM_result_index
            else:
                return self.MM_result_index
    
        def evaluate(self, true_list, result_list):
            """
            :param true_list: 正确的分词列表
            :param result_list: 算法得到的分词列表
            :return: 三种评价指标:{正确率,召回率,F1-score}
            """
            true_index = self.read_true_sentence(true_list)
            result_index = self.get_true_index(result_list)
            if len(true_index) == 0:
                print('未导入正确结果,不能进行评估')
                assert len(true_index) > 0
            tp = 0
            fp = 0
            fn = 0
            for r, t in zip(result_index, true_index):
                if r in true_index:
                    tp += 1
                if r not in true_index:
                    fp += 1
                if t not in result_index:
                    fn += 1
            precision = tp / (tp + fp)
            recall = tp / (tp + fn)
            F1 = 2 * precision * recall / (precision + recall)
            evaluate_result = {'Precision': precision, 'Recall': recall, 'F1': F1}
    
            return evaluate_result
    
        @staticmethod
        def read_own_dict():
            dict_path = './chineseDic.txt'
            word_pos_dict = {}
            if not os.path.exists(dict_path):
                print('该文件不存在')
                assert os.path.exists(dict_path) is True
    
            with open(dict_path, 'r')as fp:
                for line in fp:
                    line = line.strip()
                    word = line.split(',')[0]
                    w_pos = line.split(',')[1]
                    word_pos_dict[word] = w_pos
    
            return word_pos_dict
    
        def MM(self, sentence, lth, pos=False):
            """
            :param sentence: 待分词句子
            :param lth: 正向匹配的最大长度
            :param pos: 结果是否显示词性标注
            """
            self.reverse = False
            self.result_reverse = False
            if lth <= 1:
                print('max_len 不能小于2')
                assert lth > 1
            if len(sentence) == 0:
                print('原句子不能为空')
                assert len(sentence) > 0
            self.question = sentence
            if self.with_user_dict:
                word_pos_dict = self.word_pos_dict
            else:
    
                word_pos_dict = self.read_own_dict()
    
            result_list = []
            result_index = []
            max_lth = lth
            index = 0
            index_last = index + max_lth
            while index <= len(sentence):
                if sentence[index:index_last] in word_pos_dict.keys():
                    if pos:
                        result_list.append(sentence[index:index_last] + '/' + word_pos_dict[sentence[index:index_last]])
                    else:
                        result_list.append(sentence[index:index_last])
                    result_index.append(str((index, index_last)))
                    index = index_last
                    index_last = index + max_lth
                else:
                    index_last -= 1
    
            self.MM_result_index = result_index
            self.MM_result_list = result_list
    
        def RMM(self, sentence, lth, pos=False):
            """
            :param sentence: 待分词句子
            :param lth: 反向匹配的最大长度
            :param pos: 结果是否显示词性标注
            :return:
            """
            self.reverse = True
            self.result_reverse = True
            if lth <= 1:
                print('max_len 不能小于2')
                assert lth > 1
            if len(sentence) == 0:
                print('原句子不能为空')
                assert len(sentence) > 0
            self.question = sentence
            if self.with_user_dict:
                word_pos_dict = self.word_pos_dict
            else:
                word_pos_dict = self.read_own_dict()
    
            result_list = []
            result_index = []
            max_lth = lth
            index_last = len(sentence)
            index = index_last - max_lth
            while index_last != 0:
                if sentence[index:index_last] in word_pos_dict.keys():
                    if pos:
                        result_list.append(sentence[index:index_last] + '/' + word_pos_dict[sentence[index:index_last]])
                    else:
                        result_list.append(sentence[index:index_last])
                    result_index.append(str((index, index_last)))
                    index_last = index
                    index = index_last - max_lth
                else:
                    index += 1
            result_list.reverse()
            result_index.reverse()
            self.RMM_result_index = result_index
            self.RMM_result_list = result_list
    
        def get_result(self):
            """
            :return: 返回结果
            """
            if self.result_reverse:
                return self.RMM_result_list
            else:
                return self.MM_result_list
    

    由于是课程作业,对方法的调用和定义的变量有要求,所以显得比较笨拙,但是代码简单,可修改性强,没有很复杂的函数调用和第三方模块调用。
    下面是测试方法:

    question = '命名时应考虑的因素:直观、时髦用语、暗示创业模型、有说服力、能吸引顾客的注意力。'
    true = '命名/  时/  应/  考虑/  的/  因素/  :/  直观/  、/  时髦/  用语/  、/  暗示/  创业/  模型/  、/  有/  说服力/  、/  能/  吸引/  顾客/  的/  注意力/  。/  '
    # 这里是指用户词典
    chinese_dict = 'chineseDic.txt'
    max_len = 3
    # 实例化一个对象cut
    cut = CSegment()
    # 加载用户词典
    cut.read_user_dict(chinese_dict)
    # 正向最大匹配
    cut.MM(sentence=question, lth=max_len, pos=True)
    # 获取结果
    MM_result = cut.get_result()
    print(MM_result)
    # 评价分词结果,需要有true(正确答案)
    evaluate = cut.evaluate(true, MM_result)
    print(evaluate)
    # 反向最大匹配
    cut.RMM(sentence=question, lth=max_len, pos=True)
    RMM_result = cut.get_result()
    print(RMM_result)
    evaluate = cut.evaluate(true, RMM_result)
    print(evaluate)
    
    展开全文
  • 是语义匹配算法的框架。 要了解有关 S-Match 的更多信息,请访问: 入门 S-Match 是用 Java 编写的,并在 Java 虚拟机版本 6 或更高版本中运行。 您可以通过 、构建或通过 开始。 命令行 您可以运行 S-Match 命令行...
  • KMP算法:最长字符串匹配算法

    千次阅读 2019-08-30 16:27:02
    KMP算法:最长字符串匹配算法 查找模式串在目标串中的位置 例如:目标串"asdasdaabbccaabsesdf" 模式串:“aabbccaabse” 则返回6,表示从索引下标是6开始匹配。(假设模式串索引为6‘a’的前缀:(a、aa、aab、aabb、...

    KMP算法:最长字符串匹配算法

    查找模式串在目标串中的位置
    例如:目标串"asdasdaabbccaabsesdf" 模式串:“aabbccaabse” 则返回6,表示从索引下标是6开始匹配。(假设模式串索引为6‘a’的前缀:(a、aa、aab、aabb、aabbc、aabbcc、ab、abb、…)
    后缀也是一样,只不过是以索引6‘a’为分割的后面字符串所有字串类型。(a、aa、aab、aabs、aabse、ab、abs、abse、…))
    先讲解下思路:总体官方的话来说每次匹配失败时模式串则回退到n,关键核心思想是n是公共前缀和后缀的匹配个数,定义这个n的算法比较抽象。
    模式串从左向右开始移动遍历:如果遍历到前面有相同的公共字串且当前字符和匹配到的字串下一位也相同则n+1,否则回到上一次匹配的地方,这个地方概念比较抽象,还是上图和代码。

    示例演示:
    设next数组用户保存当前字符公共前缀长度,模式串为pattern。设当前最大匹配前缀为j,向前遍历的索引为i。
    模式字符串
    设第一位的最大匹配为next[0] = -1,标志从头开始。I = 0,j = -1;最长前缀匹配为next[j] = j + 1;所以next[0] = 0;
    I = 1,j = 0;Pattern[i] = a;Pattern[j] = a;最长前缀匹配为next[j] = j + 1;所以next[1] = 1;

    I = 2,j = 1;Pattern[i] = b;Pattern[j] = a;因为:Pattern[i] != Pattern[j]; ①J = next[j] = 1; 回到①递归匹配
    以上方法一次类推得到next数组。得next = {-1, 0, 1, 0, 0, 0, 1};
    求得next数组后就好求了。

    代码片段如下:

    public static int[] next(String pattern){
    
        char[] chars = pattern.toCharArray();
        int i = 0;//当前移动指针,-1可以判断开始点
        int j = -1;//当前前缀和后缀匹配度
        int length = pattern.length();
        int[] next = new int[length];
        next[0] = -1;
    
        while (i < length - 1) {
    
            if (j == -1 || chars[i] == chars[j]) {
                i++;
                j++;
                next[i] = j;
            }else {
                j = next[j];
            }
    
    
        }
    
        return next;
    }
    

    设目标字符串为:
    目标字符串
    模式字符串为上述字符串:
    在目标字符串
    一个一个比较:设i为目标串索引,j为模式串索引。I = 0,j = 0;A = a,I = 1,j = 1;Q != a,则模式串回退到next[1];I = 2,j = 0;判断next[j] == -1表示从头开始。则 i = 2,j = 0;A = a;i = 3,j = 1;
    A = a;I = 4,j = 2;B = b;I = 5,j = 3;B = b;I = 6,j = 4;C = c;I = 7,j = 5;S!=a;则j = next[5] = 0;…以此类推,求完整个字符串,如果匹配成功则返回。

    代码片段如下:

    public static int kmp(String msg,String pattern){
    
    
        char[] msgs = msg.toCharArray();
        char[] patterns = pattern.toCharArray();
        int[] a = next(pattern);
        int i = 0, j = 0;
        while (i < msgs.length && j < patterns.length) {
            if (a[j] == -1 || msgs[i] == patterns[j]) {
                i++;
                j++;
            } else {
                j = a[j];
            }
        }
        if (j == patterns.length) {
            return i - j;
        }
        return -1;
    }
    
    展开全文
  • os指纹匹配算法

    千次阅读 2019-05-14 09:08:00
    Nmap用于检测匹配算法相对简单。它需要一个受试者指纹,并针对nmap-os-db中的每个参考指纹进行测试。 当针对参考指纹进行测试时,Nmap依次查看来自受试者指纹(例如SEQ或T1)的每个探针class行。跳过参考指纹中不...

    1.IPv4 matching
    Nmap用于检测匹配的算法相对简单。它需要一个受试者指纹,并针对nmap-os-db中的每个参考指纹进行测试。

    当针对参考指纹进行测试时,Nmap依次查看来自受试者指纹(例如SEQ或T1)的每个探针class行。跳过参考指纹中不存在的任何探测行。 当参考指纹确实具有匹配行时,将对它们进行比较。

    对于探测行比较,Nmap依次检查主题类别行中的每个单独测试(R,DF,W等)。 跳过参考行中不存在的任何测试。每当找到匹配测试时,Nmap会将PossiblePoints累加器增加分配给此测试的点数。然后比较测试值。 如果参考测试具有空值,则受试者测试仅匹配其值是否为空。如果参考测试只是一个普通的字符串或数字(没有操作符),则受试者测试必须完全匹配。如果引用字符串包含运算符(|, - ,>或<),则受试者必须匹配,如“测试表达式”一节中所述。 如果测试匹配,则NumMatchPoints累加器将增加测试的点值。

    一旦测试了所有探测线的指纹,Nmap就会将NumMatchPoints除以PossiblePoints。结果是描述受试者指纹与该特定参考指纹匹配的概率的置信因子。例如,1.00是完美匹配,而0.95非常接近(95%)。

    测试点值由nmap-os-db中的特殊MatchPoints条目(可能只出现一次)指定。此条目看起来很像普通指纹,但不是为每个测试提供结果,而是为每个测试提供点值(非负整数)。 MatchPoints结构中列出的测试仅在列出的相同测试中找到时才适用。因此,T1中W(窗口大小)测试的值不会影响T3中的W测试。通过为点值指定0可以有效地禁用测试。示例8.10中给出了示例MatchPoints结构。
    在这里插入图片描述
    一旦评估了所有参考指纹,Nmap就会对它们进行排序并打印完美匹配(如果没有太多)。 如果没有完美匹配,但有些非常接近,Nmap可能会打印出来。 如果给出–osscan-guess选项,则更有可能打印猜测。

    IPv6 matching
    IPv6 OS分类使用称为逻辑回归的机器学习技术。 Nmap使用LIBLINEAR库进行此分类。该过程从一大组训练示例开始,这些示例是Nmap用户提交的指纹,并通过其操作系统进行了仔细标记。每个训练示例由特征向量表示,该特征向量可以被认为是多维空间中该OS的“坐标”。 训练算法计算每个OS类的成员与每个其他类的成员之间的最佳边界。然后它将这些边界中的每一个编码为矢量。 每个OS类都有不同的向量。
    匹配时,引擎依次获取这些边界向量中的每一个,并计算它与特征向量之间的点积。 结果是一个实数。 数字越高(越正),匹配的可能性越大。 负数不太可能匹配。 使用逻辑公式100 /(1 + ex)将数字x从范围[-∞,∞]映射到[0,100]。 (这是“逻辑回归”这个名称的来源。)
    通常,具有最高分数的OS类最有可能匹配,但是在前所未有的操作系统的情况下,可能具有非常高的分数但是仍然是不准确的匹配。 因此,第二个“novelty detection”算法检查观察到的指纹是否与该类别的其他代表非常不同。 该算法找到从观察到的特征向量到该类成员的特征向量的平均值的欧几里德距离,在每个维度上通过该特征的方差的倒数进行缩放。与已经看到的特征向量相似的特征向量将具有低novelty,并且那些不同的特征向量将具有高novelty。
    具有最高分数的OS类被报告为匹配,但仅当新颖性低于15时。另外,如果两个最高OS类具有相差小于10%的分数,则分类被认为是不明确的并且不是成功匹配 。 针对Mac OS X 10.6.8的运行的示例逻辑和novelty得分显示在表8.9“OS对Mac OS X的猜测”中。
    在这里插入图片描述
    没有包含IPv6 OS数据库的单独数据文件,他们与IPv4放在一起。 数据库存储在C ++源代码文件FPModel.cc中。 该文件包含缩放常数(用于将特征值大致置于[0,1]范围内)和上述边界向量。

    展开全文
  • 交叉匹配算法

    千次阅读 2017-02-13 13:12:12
    应用场景:常见分销系统,国外3M系统中,业务中包含提供帮助和得到帮助双方交易用户,提供帮助的资金要顺序匹配给得到帮助的用户,在匹配过程中会出现交易双方数据拆分情况,在此业务中如果有一方数据匹配完成,则该...
  • OkCupid匹配算法的快速实现 OkCupid是一个在线约会网站,具有有趣的匹配算法。 随附的PDF中包含OkCupid对算法的描述。 该程序从stdin(以JSON表示;请参见随附的示例输入文件)读取一组用户配置文件,并将每个用户...
  • 地图匹配算法实践

    万次阅读 热门讨论 2017-02-21 19:37:42
    地图匹配算法实践 1 背景 如下图所示,1、2、3 这三个点是汽车的GPS定位结果,尽管汽车是在道路上,但定位结果与道路存在偏差。地图匹配(Map Matching)是指将行车轨迹的经纬度采样序列与数字地图路网...
  • 串的模式匹配算法,通俗地理解,是一种用来判断两个串之间是否具有"主串与子串"关系的算法。 主串与子串:如果串 A(如 "shujujiegou")中包含有串 B(如 "ju"),则称串 A 为主串,串 B 为子串。主串与子串之间的...
  • 在高速以太网中,针对用户行为的特殊性及数据流五元组的特点,提出了一种自适应相似性匹配算法(ASMA-HN)。该算法充分考虑了数据流五元组的随机性分布特点,通过一种改进的XOR-SHIFT算法将数据流分类索引,并提出了...
  • 针对服务发现领域存在的匹配问题,提出了基于匹配算法的服务发现本体模型。研究中,以本体技术为基础,分析服务发现模型所包含的主要元素,定义用户本体与服务本体之间最优匹配规划的命题。构建满足该命题的Web服务...
  • 随着无线技术的迅猛发展...提出一种面向蜂窝—D2D 混合场景的双层博弈匹配算法,建立基于用户体验质量的公平性匹配模型,采用双层的匹配博弈理论加以求解,通过仿真验证所提算法的有效性,结果证明了所提算法的可行性。
  • 最近看了KMP算法算法很巧妙,但觉得讲解中的用前缀后缀法求部分匹配值效率有些低,在网上搜索一下,发现讲解的都是前缀后缀方法,经过我冥思苦想,想出了一个更高效的方法,在这里分享一下。 关于KMP的完整算法,...
  • 算法首先利用层次分析法获得相应权重分配以给出满意度函数,然后将网络侧的一对多匹配转化为一对一匹配问题,在稳定匹配条件下构建多目标优化模型,并求解最优匹配结果。相关性能分析及仿真实验表明,基于稳定匹配的...
  • 这篇将使用Java实现基于规则的中文分词算法,一个中文词典将实现准确率高达85%的分词结果。使用经典算法:正向最大匹配和反向最大匹配算法,然后双剑合璧,双向最大匹配。
  • 为了减少现有的基于特征提取的自动光学检测系统的用户编程时间以及对用户经验的依赖,提出了一种基于统计建模的图像匹配算法.该算法首先对学习训练的焊点图片进行合格或者不合格区分;然后对合格的样本图片进行灰度...
  • 字符串匹配算法(多模式串)

    千次阅读 2019-02-23 22:35:40
    上一篇了解了单模式串匹配算法,现在来学习多模式串匹配算法,首先需要了解Trie树 Trie树的概念 Trie树也叫字典树或者前缀树,它是一个树形的结构。是一种专门用来处理字符串匹配的数据结构,用来解决在一组字符串中...
  • NULL 博文链接:https://xieruilin.iteye.com/blog/780774
  • 中文相似度匹配算法

    万次阅读 多人点赞 2014-11-14 10:39:31
    字符串相似度算法被应用于许多计算场景,在诸如数据清洗,用户输入纠错,推荐系统, 剽窃检测系统,自动评分系统,以及网页搜索和DNA序列匹配这些方向都有着十分广泛的应用。   常见的字符串相似度算法包括编辑...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 232,965
精华内容 93,186
关键字:

用户匹配算法