精华内容
下载资源
问答
  • 原标题:自然语言处理中的情感分析 情感分析是一种常见的自然语言处理(NLP)方法的应用,特别是在以提取文本的情感内容为目标的分类方法中。通过这种方式,情感分析可以被视为利用一些情感得分指标来量化定性数据的...

    原标题:自然语言处理中的情感分析

    8a1a834c8b9048f81c4f2e4f15a4ae5c.png

    情感分析是一种常见的自然语言处理(NLP)方法的应用,特别是在以提取文本的情感内容为目标的分类方法中。通过这种方式,情感分析可以被视为利用一些情感得分指标来量化定性数据的方法。尽管情绪在很大程度上是主观的,但是情感量化分析已经有很多有用的实践,比如企业分析消费者对产品的反馈信息,或者检测在线评论中的差评信息。

    有两种主流思想运用到情感分析,第一种为基于情感词典的情感分析,是指根据已构建的情感词典,计算该文本的情感倾向,即根据语义和依存关系来量化文本的情感色彩。最终分类效果取决于情感词库的完善性,另外需要很好的语言学基础,也就是说需要知道一个句子通常在什么情况为表现为积极或消极。第二种是基于机器学习,是指选取情感词作为特征词,将文本矩阵化,利用logistic Regression, 朴素贝叶斯(Naive Bayes),支持向量机(SVM)等方法进行分类。最终分类效果取决于训练文本的选择以及正确的情感标注。

    下文列举两种基于机器学习的情感分析主流算法。

    KNN分类算法:思路是为如果一个样本在特征空间中的k个最相似的样本中的大多数属于某一个类别,则该样本也属于这个类别。

    优点:

    (1)简单、易实现、易理解、无需参数估计及训练;

    (2)适用于对稀有时间进行分类;

    (3)特别适用于多分类问题(multi-modal,分类对象具有多个类别标签),比SVM表现要好。

    缺点:

    (1)输出的可解释性不强且类别的评分不是规则化的。

    (2)计算量较大。目前常用的改进方法,事先对已知样本点进行剪辑,去除对分类作用不大的样本。该改进算法比较适用于容量大的类域,而容量较小的类域容易产生误分。

    (3)当样本不平衡时,有可能导致当输入一个新样本时,该样本的K个邻居中大容量类的样本占多数。

    朴素贝叶斯:朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法

    优点:

    (1)朴素贝叶斯模型发源于古典数学理论,有稳定的分类效率。

    (2)对小规模的数据表现很好,能个处理多分类任务,适合增量式训练,尤其是数据量超出内存时,我们可以一批批的去增量训练。

    (3)对缺失数据不太敏感,算法也比较简单,常用于文本分类。

    缺点:

    (1) 理论上,朴素贝叶斯模型与其他分类方法相比具有最小的误差率。但是实际上并非总是如此,这是因为朴素贝叶斯模型假设属性之间相互独立,这个假设在实际应用中往往是不成立的,在属性个数比较多或者属性之间相关性较大时,分类效果不好。而在属性相关性较小时,朴素贝叶斯性能最为良好。对于这一点,有半朴素贝叶斯之类的算法通过考虑部分关联性适度改进。

    (2)需要知道先验概率,且先验概率很多时候取决于假设,假设的模型可以有很多种,因此在某些时候会由于假设的先验模型的原因导致预测效果不佳。

    (3)分类决策存在一定的错误率,且对输入数据的表达形式很敏感。

    文章来源:www.xixi.ai(息息人工智能)返回搜狐,查看更多

    责任编辑:

    展开全文
  • matlab的egde源代码MatlabNLP是高效的算法,数据结构和经过良好测试的功能的集合,用于在Matlab环境中进行自然语言处理。 我们正在不断加快基础算法和功能的速度。 您可以使用整个库,也可以仅获取所需的函数和方法...
  • Matlab实现的用于自然语言处理的深度卷积神经网络(又名CNN)。 DeepLearnNLP学习单词之间的关系(无需人工指导),以便预测句子中的下一个单词。 从杰弗里·欣顿(Geoffrey Hinton)的Coursera课程中学习,涉及神经...
  • matlab炫酷代码言语与自然语言处理 精选的语音和自然语言处理资源列表。 在此可以找到其他列表。 如果您想对此列表做出贡献(请这样做),请向我发送请求请求。 所有子类别均按字母顺序列出 有限状态工具包和正则...
  • 自然语言处理实战视频教程,自然语言处理中重要的算法,词向量模型。本课程从语言模型入手,详解词向量构造原理与求解算法。理论与实战结合, 基于深度学习主流框架Tensorflow实例演示如何用深度学习来进行文本分类...
  • 自然语言处理工程师实战系列主要包括三大核心模块:1.自然语言处理核心算法原理解读及其案例实战、2.NLP必备实战模块-BERT模型、3.知识图谱实战系列。整体风格通俗易懂,全程实战解读NLP领域各大核心算法及其应用...
  • 随着对于深度学习研究的逐渐深入,在自然语言处理领域,出现了很多深度学习的模型,这些模型相比于传统的机器学习方法,在准确率等指标上面有了很大的提高。本课程拟就深度学习在自然语言处理领域的应用,从基础开始...
  • 基于matlab语言采集及处理

    千次阅读 2018-07-03 23:34:00
    原 基于matlab的语音采集及处理 2018年02月08日 17:50:20 阅读数:2702 ...




    基于matlab的语音采集及处理








    一.课程设计的目的

    通过数字信号处理的课程设计,使学生对信号的采集,处理,传输,显示,存储和分析等有一个系统的掌握和理解。巩固和运用数字信号处理课程中的理论知识和实验技能,掌握最基本的数字信号处理的理论和方法,培养学生发现问题,分析问题和解决问题的能力。

    二.课程设计的题目

    语音信号的采集、分析与处理。

    三.设计内容 (主要技术关键的分析、解决思路和方案比较等)

    对一段语音信号进行采样;画出采样后语音信号的时域波形和频谱图;给定滤波器的性能指标,采用窗函数法和双线性变换设计滤波器,并画出滤波器的频率响应;然后用自己设计的滤波器对采集的信号进行滤波,画出滤波后信号的时域波形和频谱,并对滤波前后的信号进行对比,分析信号的变化;回放语音信号;最后,设计一个信号处理系统界面。

    设计内容:采样一段语音信号;画出语音信号的时域波形和频谱图;给定滤波器的性能指标,设计数字滤波器,并画出滤波器的频率响应;然后用设计的滤波器对采集的信号进行滤波,画出滤波后信号的时域波形和频谱。

    关键技术:频谱图的理解;设计数字滤波器;数字滤波的方法;

    解决思路:对语音号进行快速傅里叶变换,得到信号的频谱特性;在MATLAB环境中可以利用函数fir设计FIR滤波器,可以利用函数butter设计IIR滤波器;利用MATLAB中的函数freqz画出各滤波器的频率响应。

     

    四、设计原理及步骤

    原理:

    1.语音信号的采集 

    语音信号是一种模拟信号,首先须经过采样将其转换为数字信号,实质是把连续信号变为脉冲或数字序列。  我们可以用录音软件先录一段wav格式的音频。然后用matlab的audioread函数采集,记住采样频率和采样点。然后用sound函数来使用。

     2.语音信号的频谱特性 

    在MATLAB中,可以利用函数fft对信号进行快速傅里叶变换,得到信号的频谱特性。

    快速傅氏变换(FFT),是离散傅氏变换的快速算法,它是根据离散傅氏变换的奇、偶、虚、实等特性,对离散傅立叶变换的算法进行改进获得的。

    3.语音信号的时域分析    

         语音信号的时域分析就是分析和提取语音信号的时域参数。进行语  音分析时,最先接触到并且也是最直观的是它的时域波形。语音信号本身就是时域信号,因而时域分析是最早使用,也是应用最广泛的一种分析方法,这种方法直接利用语音信号的时域波形。时域分析通常用于最基本的参数分析及应用,如语音的分割、预处理、大分类等。这种分析方法的特点是: 

    ①表示语音信号比较直观、物理意义明确。

    ②实现起来比较简单、运算且少。

    ③可以得到语音的一些重要的参数。 

    ④只使用示波器等通用设备,使用较为简单等。  

    语音信号的时域参数有短时能量、短时过零率、短时白相关函数和短时平均幅度差函数等,这是语音信号的一组最基本的短时参数,在各种语音信号数字处理技术中都要应用。在计算这些参数时使用的一般是方窗或汉明窗。对语音信号进行分析,发现发浊音时,尽管声道有若干个共振峰,但由于声门波引起谱的高频跌落,所以其话音能量约集中在3kHz以下。而发清音时,多数能量出现在较高频率上。高频就意味着高的平均过零率,低频意味着低的平均过零率,所以可以认为浊音时具有较低的过零率,而清音时具有较高的过零率。当然,这种高低仅是相对而言,并没方精确的数值关系。

    4.语音信号的频域分析  

    语音信号的频域分析就是分析语音信号的频域持征。从广义上讲,语音信号的频域分析包括语音信号的频谱、功率谱、倒频谱、频谱包络分析等,而常用的频域分析方法有带通滤波器组法、傅里叶变换法、线件预测法等几种。因为语音波是一个非平稳过程,因此适用于周期、瞬变或平稳随机信号的标准傅里叶变换不能用来直接表示语音信号,而应该用短时傅里叶变换对语音信号的频谱进行分析,相应的频谱称为“短时谱”。

    5.采样定理

    在进行模拟与数字信号的转换过程中,当采样大于最高频率的2倍时,则采样之后的数字信号完整的保留了原始信号中的信息,一般实际应用中保证采样频率为信号最高频率的5~10倍。

    6.采样频率

    采样频率是指计算机每秒钟采样多少个声音样本,是描述声音文件的音质、音频、衡量声卡、声音文件的质量标准。采样频率越高,即采样的时间间隔越短,则在单位时间内计算机得到的声音样本数据越多,对声音波形的表示也越准确。

    7.采样位数

    采样位数即采样值或取样值,用来衡量声音波动变化的参数,是指声卡在采集和播放声音文件时所使用数字声音信号的二进制位数。采样频率是指录音设备在一秒钟内对声音信号的采样次数,采样频率越高声音的还原就越真实越自然。采样位数和采样率对于音频接口来说是最为重要的两个指标。无论采样频率如何,理论上来说采样的位数决定了音频数据最大的力度范围。采样位数越多则捕捉到的信号越精确。

    步骤:

    1、语音信号的采集  选取一段2秒左右的音频,以文件名“1”保存在桌面上,文件存储器的后缀默认为.wav;  在Matlab软件平台下可以利用函数audioread对语音信号进行采样,得到了声音数据变量 .

    2、2语音信号的频谱分析  画出语音信号的时域波形;  对语音信号进行频谱分析,在Matlab中,我们利用函数fft对信号进行快速傅里叶变换,得到信号的频谱特性。

    五、设计过程

    5.1信号采集

    我们利用函数对语音信号进行采集,原始语音信号及其频谱如下图,信号采集程序见附录。

    5.2加噪后的波形


    5.3根据性能指标进行数字滤波器设计

    IIR低通滤波器的设计:

    IIR低通滤波器的幅频特性如下图,设计程序见附录。


    5.4用滤波器对信号进行滤波



    5.5回放语音信号

    经过加噪声处理后,可在Matlab中用函数sound对声音进行回放。其调用格式:sound(y,Fs)。

    六、课程设计总结                                                             

        通过这次课程设计,让我对matlab有了深入的了解。知道了函数audioread

    和sound的用法。由于电脑安不起matlab其他版本的,只能用matlab 2016a 版本的。像wavread和wavread函数都用不着。所以去查了许多的资料,才完成了这次的实验。

    这次设计主要参考的网上的一些前辈们做的设计,看了他们无数的代码,自己才慢慢的懂得了如何去写一些代码,和一些代码的作用。直到现在有些函数都还没有弄懂,这次设计就用了自己会的一些函数,由于是第一次设计,所以还向学霸们请教了一些问题。在设计过程中有不懂的,在他们的帮助下也完成了。

    这次设计让我懂得了,要完成一件事需要很多很多的努力。努力就会有收获。

    附件:

     Matlab实验代码:

    clear

    clc

    [pyr,fs]=audioread(‘pyr.wav’);%声音读取

    sound(pyr,fs);   %声音回放

     

    n=length(pyr);

    pyr1=fft(pyr,n);                            %快速傅里叶变换

    figure(1)

    subplot(2,1,1);

    plot(pyr);  

    xlabel(’时间’);

    ylabel(’幅度’);

    title(’初始信号波形’);   %绘出时域波

    gridon

    subplot(2,1,2);                         %绘出频域频谱

    plot(abs(fftshift(pyr1)));

    title(’初始信号频谱’);

    xlabel(’频率’);

    ylabel(’幅度’);

    gridon

     

    noise=0.01*randn(n,1);%加噪声

    s=pyr+noise;

     

    pause;

    sound(s,fs);  %播放加噪的语音

     

    n=length(s);   %画出加噪之后,其时域频域

    S=fft(s,n);

    figure(2)

    subplot(2,1,1)

    plot(s);

    title(’加噪声后信号波形’)

    xlabel(’时间’);

    ylabel(’幅度’);

    grid;

    subplot(2,1,2)

    plot(abs(fftshift(S)));

    xlabel(’频率’);

    ylabel(’幅度’);

    title(’加噪声后信号信号频谱’);

    grid;

    pause

     

     

    %设计IIR低通滤波器

    rp=2,rs=80;

    Ft=8000;

    Fp=1000;

    Fs=2000;                                       

    wp=2*pi*Fp/Ft;

    ws=2*pi*Fs/Ft    %求出待设计的模拟滤波器的边界频率

    [n,wn]=buttord(wp,ws,rp,rs,’s’);    %低通滤波器的阶数和截止频率

    [b,a]=butter(n,wn,’s’);             %S域频率响应的参数即:滤波器的传输函数

    [bz,az]=bilinear(b,a,0.5);          %利用双线性变换实现频率响应S域到Z域的变换

     

    %低通滤波器特性

    figure(3);

    [h,w]=freqz(bz,az);

    title(‘IIR低通滤波器’);

    plot(w*fs/(2*pi),abs(h));

    gridon

     

    %滤波

    z=filter(bz,az,s);

     

    %回放滤波后的信号

    pause;

    sound(z,fs);                   

     

    %滤波后画出其频谱,波形

    Z=fft(z);                           %滤波后的信号频谱

    figure(4)

    subplot(2,2,1);

    plot(z);

    title(’低通滤波后的信号波形’);

    xlabel(’时间’);

    ylabel(’幅度’);

    grid;

    subplot(2,2,2)

    plot(s)

    title(’加噪声后信号波形’);

    xlabel(’时间’);

    ylabel(’幅度’);

    grid;

    subplot(2,2,3);

    plot(abs(fftshift(S)));

    title(’加噪声后信号频谱’);

    xlabel(’频率’);

    ylabel(’幅度’);

    grid;

    subplot(2,2,4);

    plot(abs(fftshift(Z)));

    title(’低通滤波后信号的频谱’);

    xlabel(’频率’);

    ylabel(’幅度’);

    grid;



    function analyzevoice()
    clc;
    clear;
    [pyr,fs]=audioread('leisheng.wav');
    %sound(pyr,fs);     %声音回放
    n=length(pyr);
    pyr1=fft(pyr,n);     %快速傅里叶变换
    figure(1)
    subplot(2,1,1);
    plot(pyr);  
    xlabel('时间');
    ylabel('幅度');
    title('初始信号波形');   %绘出时域波
    grid on;
    subplot(2,1,2);                         %绘出频域频谱
    plot(abs(fftshift(pyr1)));
    title('初始信号频谱');
    xlabel('频率');
    ylabel('幅度');
    grid on;
    noise=0.1*randn(n,1);%加噪声
    s=pyr+noise;
    pause
    %sound(s,fs);  %播放加噪的语音
    n=length(s);   %画出加噪之后,其时域频域
    S=fft(s,n);
    figure(2)
    subplot(2,1,1)
    plot(s);
    title('加噪声后信号波形')
    xlabel('时间');
    ylabel('幅度');
    grid on;
    subplot(2,1,2)
    plot(abs(fftshift(S)));
    xlabel('频率');
    ylabel('幅度');
    title('加噪声后信号信号频谱');
    grid;
    pause;
    %设计IIR低通滤波器
    rp=2;
    rs=80;
    Ft=8000;
    Fp=1000;
    Fs=2000;                                       
    wp=2*pi*Fp/Ft;
    ws=2*pi*Fs/Ft;    %求出待设计的模拟滤波器的边界频率
    [n,wn]=buttord(wp,ws,rp,rs,'s');    %低通滤波器的阶数和截止频率
    [b,a]=butter(n,wn,'s');             %S域频率响应的参数即:滤波器的传输函数
    [bz,az]=bilinear(b,a,0.5);%利用双线性变换实现频率响应S域到Z域的变换
    %低通滤波器特性
    figure(3);
    [h,w]=freqz(bz,az);
    title('IIR低通滤波器');
    plot(w*fs/(2*pi),abs(h));
    grid on;
    %滤波
    z=filter(bz,az,s);
    %回放滤波后的信号
    pause;
    %sound(z,fs); 
    %滤波后画出其频谱,波形
    Z=fft(z);                           %滤波后的信号频谱
    figure(4)
    subplot(2,2,1);
    plot(z);
    title('低通滤波后的信号波形');
    xlabel('时间');
    ylabel('幅度');
    grid;
    subplot(2,2,2)
    plot(s)
    title('加噪声后信号波形');
    xlabel('时间');
    ylabel('幅度');
    grid;
    subplot(2,2,3);
    plot(abs(fftshift(S)));
    title('加噪声后信号频谱');
    xlabel('频率');
    ylabel('幅度');
    grid;
    subplot(2,2,4);
    plot(abs(fftshift(Z)));
    title('低通滤波后信号的频谱');
    xlabel('频率');
    ylabel('幅度');
    grid;
    end
    展开全文
  • 自然语言处理实战入门

    千人学习 2019-03-15 15:21:29
    随着人工智能的快速发展,自然语言处理和机器学习技术的应用愈加广泛。 目前自然语言处理相关专业人才属于供不应求的状态,这种状态是因为过去很长一段时间,高校NLP人才的培养是跟不上业界需求的。毕竟目前国内高校...
  • 自然语言处理

    2020-08-26 16:23:29
  • 自然语言处理的深度学习直播课是使用深度学习模型处理自然语言数据的直观介绍。是使用深度学习处理自然语言的简介。这些课程通过互动的、实际操作的Jupyter notbokke示例对基本理论进行生动直观的解释。示例使用...
  • 计算和矩阵处理是在Matlab中完成的(Python确实具有类似Matlab的库numpy,但由于偏好我们使用了Matlab)。 步骤1:下载Python集成开发环境(IDE)。 出于说明目的,我们使用了Anaconda。 第2步:获取情感词列表,并...
  • 从零开始自然语言处理

    千人学习 2019-08-07 14:38:22
    本课程隶属于自然语言处理(NLP)实战系列。自然语言处理(NLP)是数据科学里的一个分支,它的主要覆盖的内容是:以一种智能与高效的方式,对文本数据进行系统化分析、理解与信息提取的过程。通过使用NLP以及它的组件,...
  • 自然语言处理-中文分词程序

    热门讨论 2012-12-01 12:32:55
    北邮 计算机院 自然语言处理 中文分词程序
  • 有一种简单但功能强大的自然语言处理方法,称为基于 n-gram 的语言模型,您可以在使用 MATLAB 时从中获得很多乐趣,我在 2015 年 9 月发表于“Loren关于 MATLAB 的艺术”,早在引入文本分析工具箱之前。 新工具箱极...
  • 07 规则式自然语言处理系统7.1 规则式系统7.2 规则式系统的目的7.2.1 为何需要规则式系统7.2.2 使用规则式系统的应用7.2.3 练习7.2.4 开发规则式系统需要的资源7.3 规则式系统的架构7.3.1 从专家系统的角度...


    NLP应用程序的算法(实现技术或方法)可分为两部分。在本章中,我们将重点介绍基于规则的系统。我们将接触到以下主题:

    了解RB系统
    安装RB系统的目的
    RB系统的体系结构
    了解RB系统开发生命周期
    应用
    使用RB系统开发NLP应用程序
    比较RB方法和其他方法
    优势
    缺点
    挑战
    RB系统的最新趋势

    7.1 规则式系统

    RB系统也被称为基于知识的系统。但首先,我们将看到RB系统的含义和它对我们有什么作用?使用这种方法可以实现哪种NLP应用程序?为了更好地理解,我将在应用程序的帮助下解释这些概念。基于规则的系统是利用现有的知识或规则来定义的,我们开发了一个使用规则的系统,将现有的系统规则应用到语料库上,并尝试生成或推理结果。请参阅图7.3,它将向您介绍RB系统:
    Alt
    简而言之,你可以说RB系统就是将现实生活中的规则或经验应用到一个可用的语料库中,根据规则操纵信息,并得出某些决定或结果。在这里,规则是由人类产生或创造的。RB系统用于以有用的方式解释可用的语料库(信息)。在这里,规则作为RB系统的核心逻辑。语料库是根据规则或知识来解释的,所以我们的最终结果取决于这两个因素,一个是规则,另一个是语料库。现在将解释一个人工智能应用程序,以获得RB系统的核心本质。

    作为人类,我们每天都要做非常复杂的工作来完成一些任务。为了完成任务,我们使用我们以前的经验或遵循规则来成功完成任务。

    举个例子:如果你在开车,你会遵守一些规则。你事先知道这些规则。现在,如果你想到自动驾驶的汽车,那么这辆车应该做出反应或者完成人类以前做的全部任务。但是汽车不知道如何在没有司机的情况下自动驾驶。开发这种无人驾驶汽车既复杂又具有挑战性。

    不管怎样,你想创造一辆自动驾驶的汽车。你知道,有这么多的规则,汽车需要学习,以执行作为一个人类司机。这里有几个主要挑战:

    • 这是一种复杂的应用程序
    • 汽车需要学习很多规则和情况
    • 自动驾驶汽车的准确度应该足够高,以便向消费者投放市场。

    因此,为了解决这些挑战,我们采取了各种步骤:
    1、我们首先尝试将问题语句简化为问题的小部分,这是原始问题语句的一个子集。
    2、我们先解决一小部分问题。
    3、为了解决这个问题,我们试图提出一个通用的规则来帮助我们解决我们的问题,同时帮助我们实现我们的最终目标。

    对于我们版本的无驾驶员(自动驾驶)汽车,我们需要从软件的角度进行思考。那么,汽车应该学习的第一步是什么?想想!

    汽车应该学会看到和识别道路上的物体。这是我们汽车的第一步,我们定义了一些通用规则,汽车将使用这些规则来学习和决定道路上是否有物体?然后,以此为基础开车。当看到路况时,汽车的速度应该是多少?等等。

    对于我们任务的每一个小部分,我们都试图定义规则并将该规则逻辑输入到RB系统中。然后,我们检查在给定的输入数据上该规则是否正确地工作。我们还将在获得输出后测量系统的性能。

    现在,你一定认为这是一本关于NLP的书,那么为什么我要给出一个通用人工智能应用的例子呢?其背后的原因是,自动驾驶汽车的例子很容易联系起来,并且每个人都能理解。我想强调一些要点,它们也有助于我们理解建立基于规则的系统的目的。

    让我们举一个一般的例子,并理解其目的:

    • 这个自动驾驶汽车的例子有助于你认识到,有时人类很容易完成的任务对于机器自己来说要复杂得多。
    • 这些复杂的任务需要高精度!我的意思是非常高!
    • 我们不希望我们的系统覆盖并了解所有情况,但是无论我们输入系统的规则是什么,它都应该以最好的方式了解这些情况。
    • 在RB系统中,各种场景的覆盖率较低,但系统的精度较高。这就是我们需要的
    • 我们的规则来源于现实生活中的人类经验或利用人类的知识。
    • 规则的制定和实施是由人类完成的

    所有这些点帮助我们决定何时何地使用基于规则的系统。这让我们定义了拥有一个基于规则的系统的目的。那么让我们进入下一节,在这里我们定义一个经验法则,用基于规则的方法来处理任何NLP或相关的应用。

    7.2 规则式系统的目的

    通常,基于规则的系统用于开发NLP应用程序和通用人工智能应用程序。我们需要回答的问题有很多,才能清楚地了解基于规则的系统。

    7.2.1 为何需要规则式系统

    基于规则的系统试图为NLP应用程序模拟人类专家知识。这里,我们将讨论有助于您理解RB系统目的的因素:

    • 可用的语料库大小很小

    • 输出过于主观

    • 对于特定领域的人来说,很容易生成一些专门的规则

    • 机器很难通过观察少量数据生成专门的规则

    • 系统输出应高度准确如果您想使用RB系统开发NLP应用程序,那么前面的所有因素都非常关键。上述因素如何帮助您决定是否应选择RB方法?您需要问以下问题:

    • 您有大量的数据还是少量的数据?如果你有少量的数据,那么问下一个问题,如果你有大量的数据,那么你还有很多其他的选择。

    • 对于您要开发的NLP应用程序,其输出是主观的还是广义的?
      如果你有少量的数据,并且你想开发的应用程序的输出过于主观,你知道,如果有少量的数据,机器就不能归纳出模式,那么就选择RB系统。

    • 您要开发的NLP应用程序应该具有非常高的准确性:
      如果您要开发的应用程序应该具有高精度,几乎与使用小数据集的人相同,那么选择RB系统。
      在这里,您还应该记住,人类专家为系统创建规则。根据该系统,生成输出,因此RB系统是高度精确的,但不涵盖所有场景。

    前面的问题定义了为什么以及在什么情况下我们可以使用RB系统。如果需要总结前面的问题,我会这样描述:如果您有少量的数据,并且您知道您需要一个高度精确的系统,在这个系统中,人类专家很容易识别出各种场景来制定规则及其输出,但是机器很难自己识别出一般化的规则,而且精确,那么RB系统就是为你准备的!RB系统的输出应模仿人类专家的经验。这是选择RB系统的经验法则。

    7.2.2 使用规则式系统的应用

    正如我们前面定义的,RB系统是在人类领域专家的帮助下开发的。让我们在本节中举几个例子来证明我们的经验法则:比如说,我们想建立一个从英语到印度语料库的机器翻译系统,但是它们太小了。翻译系统应足够精确,以便开发。我们需要既懂古吉拉特语又懂英语的人类专家。我们不想一次处理所有不同级别的翻译,因此我们需要先处理小部分的问题,然后在开发的原型之上,我们将构建其他部分。所以,在这里,我还想选择RB系统。你怎么认为?假设我们想为英语开发一个语法修正系统。假设我们有少量的平行语料库(有语法错误的文档和没有语法错误的相同文档),通过使用现有的语料库,我们需要做出一个准确的语法更正应用程序,来识别和更正语法错误。那么,在这种应用程序中,您会采用哪种方法呢?想一想,然后提出你的答案!这里,我想按照我们的经验法则使用RB系统。

    7.2.3 练习

    如果你想开发一个基本的聊天机器人系统,你会采用哪种方法?
    1.RB法
    2.ML方法

    如果你想预测给定句子的情感,你会采取哪种方法?
    1.RB法
    2.ML方法
    3.混合方法
    4.他们中没有一个

    7.2.4 开发规则式系统需要的资源

    现在您已经了解了我们为什么要使用RB系统,以及我们将它用于哪种应用程序。第三个重要方面是,如果我们想为任何NLP或AI应用程序开发RB系统,我们需要什么?

    目前我们需要考虑三种主要资源。参见图7.4:现在,让我们看看每个资源的详细信息,这些资源帮助我们定义RB系统组件:
    领域专家(人类专家/知识专家):为了使用RB系统开发应用程序,首先,我们需要一个领域专家,一个对该领域几乎无所不知的人。
    假设您想要构建一个机器翻译系统,那么您的领域专家可能是一个对源语言和目标语言有深入语言学知识的人。他可以利用自己的专长和经验制定规则。

    RB系统的系统架构师(系统工程师):为了定义RB系统的体系结构,您需要一个具有以下专业知识的团队或人员:
    领域基础知识
    在设计系统架构方面有丰富的知识或经验
    体系结构是RB系统最重要的部分,因为您的体系结构是决定整个系统效率的组件之一。RB系统的良好架构设计将提供良好的用户体验、准确和高效的输出,除此之外,它还将使编码人员和其他技术团队(如支持或测试团队)的合作变得容易,这些团队将能够轻松地在系统上工作。系统架构由系统工程师或系统管理员负责。

    实现规则的编码人员(开发人员或知识工程师):一旦领域专家开发了规则,并且系统架构得到了正确的设计,那么编码人员或开发人员就会出现在图中。编码员是我们真正的忍者!它们通过使用编程语言来实现规则,并帮助完成应用程序。他们的编码技能是RB系统中非常需要的部分。编程可以使用任何编程或脚本语言(如C、C++、Java、Python、Perl、shell脚本等)来完成。您可以根据体系结构使用它们中的任何一个,但不能在没有流线型体系结构的单个系统中使用所有这些。

    7.3 规则式系统的架构

    我将通过将RB系统分为三个部分来解释其体系结构:

    作为专家系统的RB系统的一般体系结构

    用于NLP应用的RB系统的实用架构

    自定义体系结构-用于NLP应用程序的RB系统

    Apache UIMA(非结构化信息管理体系结构)用于NLP应用程序的RB系统

    7.3.1 从专家系统的角度来看规则式系统的通用架构

    如果我们将基于规则的系统描述为一个专家系统,那么这种基于规则的系统的体系结构将与图7.5所示相同:
    Alt
    让我们详细看看体系结构的每个组件:

    领域专家:
    正如我们在前一节中看到的,领域专家是那些对特定领域有专门知识的人,他们可以帮助我们生成规则来解决我们的问题。

    开发人员或知识工程师:
    开发人员使用领域专家创建的规则并转换
    利用他们的编码技巧将它们转换成机器可理解的格式
    开发人员对专家创建的规则进行编码
    大多数情况下,这种编码是以伪码的形式进行的。知识库:

    知识库是专家们制定规则的地方。
    域专家可以添加、更新或删除规则

    数据库或工作存储:
    所有与元信息相关的规则都可以放在工作存储器中
    在这里,我们可以存储规则以及特殊的场景,如果有的话,还可以存储一些列表,例如,等等
    我们还保存了要应用规则的数据

    推理机:
    推理机是系统的核心部分。
    在这里,我们为我们的规则输入了实际的代码
    当预先定义的规则和条件满足用户时,将触发规则。
    查询或对我们作为输入提供给系统的数据集

    用户推断:
    有时,我们的最终用户还提供一些条件来缩小结果,所以当我们的系统生成输出

    用户界面:

    用户界面帮助我们的用户提交他们的输入,作为回报,他们将得到输出。这为我们的最终用户提供了一个交互式环境

    系统架构师:
    系统架构师负责系统的整个体系结构
    系统架构师还决定RB系统

    7.3.2 NLP应用中的规则式系统的实用架构

    现在我们将看到用于NLP应用程序的RB系统的实际体系结构。参见图7.6:
    Alt
    一些部分,如领域专家、用户界面和系统工程师,我们在前一节中已经看到。因此,在这里,我们将重点放在新组件上:

    基于知识的编辑器:
    领域专家可能不知道如何编码。因此,我们为他们提供了一个基于知识的编辑器,他们可以使用人类语言编写或创建规则。假设我们正在为英语开发一个语法修正系统,我们有一个语言学家,他知道如何创建规则,但不知道如何编写规则。在这种情况下,他们可以使用基于知识的编辑器添加、更新或删除规则。所有创建的规则都以正常人类语言的形式指定。

    规则转换器:
    正如我们所知,所有规则都是以人类语言的形式存在的,所以我们需要将它们翻译或转换成机器可理解的形式。所以,规则转换器是一个部分,在这里用例子定义了规则的伪逻辑。让我们考虑一下我们的语法修正系统示例。这里是我们的专家,如果句子中有单数主语和复数动词,则定义规则,然后将动词更改为单数动词格式。在规则转换器中,定义的规则已转换为句子s的单数主语带有pos标记prp$,np带有pos标记的动词vbp,然后将动词改为vbz格式。还指定了一些示例来理解这些规则

    规则对象类:
    此规则对象类用作支持库的容器。它包含各种先决条件库,它有时还包含一个可选的对象类,用于库优化整个系统。对于语法纠正系统,我们可以将诸如解析器、pos标记器、命名实体识别(ner)等工具放在规则引擎要使用的容器中。

    数据库或知识库:
    数据库具有用于规则的元数据,例如:规则对象类中使用了哪些支持库?规则的类别是什么?规则的优先级是什么?

    规则引擎:
    这是核心部分,是RB系统的大脑。通过使用规则转换器、规则对象类和知识库,我们需要开发在用户查询或输入数据集上实际运行的核心代码,并生成输出。您可以使用任何最适合您的应用程序及其体系结构的编程语言进行编码。对于我们的语法修正系统,我们将在这个阶段对规则进行编码,最终的代码将被放入规则引擎存储库中。

    7.3.3 NLP应用中的规则式系统的定制架构

    根据不同的NLP应用程序的需要,您可以更改体系结构或组件。在这种方法中,定制是可能的。如果您正在设计一个定制的RB系统架构,那么需要注意一些要点。提出以下问题:

    您是否分析和研究了问题以及已经存在的架构?在进行定制之前,您需要对应用程序进行分析。如果存在任何现有的系统,那么就花足够的时间进行分析,研究它的体系结构,并从中剔除坏的和好的。

    你真的需要定制架构吗?如果在研究之后,您觉得您的应用程序架构需要定制,然后写下你真正需要它的原因。说明列出的原因,并通过问一系列问题来帮助系统改进。如果是,那你就走对了

    它是否有助于简化开发过程?
    新的体系结构真的能更好地帮助您的开发过程吗?如果是这样,那么您可以考虑该体系结构
    大多数时候,为开发RB系统定义一个流线型的过程是很有挑战性的,但是如果您的新的定制架构可以帮助您,那么这真的是一件好事。这个简化的过程实际上稳定了你的RB系统吗?

    是否可维护?
    如果您可以将这个特性添加到您的定制架构中,然后竖起大拇指,那么定制的架构可以帮助您轻松高效地维护系统!

    它是模块化的吗?
    如果它将在RB系统中提供模块化,那么它将非常有用,因为这样您就可以轻松地添加、删除或更新某些模块。

    它是可扩展的吗?
    在新体系结构的帮助下,您可以扩展系统。你也应该考虑这个

    迁移容易吗?
    如果它具有定义的体系结构,那么团队应该很容易将系统从一个平台迁移到另一个平台。如果我们想将一个模块从一个系统迁移到另一个系统,技术团队和基础架构团队都应该很容易做到。

    它安全吗?
    系统安全是一个主要问题。如果需要的话,新的体系结构应该具有安全性和用户隐私性这一特性。

    部署方便吗?
    如果您希望在将来部署一些更改,那么部署应该很容易
    如果您想销售最终产品,那么部署过程应该足够简单,这将减少您的工作和时间。

    在开发时间上节省时间吗?
    RB系统的实现与开发
    架构应该节省时间
    体系结构本身不应该花太多时间来实现

    我们的用户容易使用吗?
    体系结构可能很复杂,但对于最终用户来说,它必须是用户友好且易于使用的

    如果您可以采用前面所有的点或其中大多数点,那么尝试使用您认为最适合系统的体系结构来实现一组小问题,然后,在最后,再次询问前面所有的问题并评估输出。

    如果你仍然得到肯定的答案,那么你就可以开干了!在这里,设计既不是对的也不是错的;它是最适合您的NLP应用程序的。
    问答系统可以使用如图所示的体系结构。

    Alt
    您可以看到一种非常不同的体系结构。Q/A系统的方法是基于本体的RB系统。问题处理和文档处理是我们的主要规则引擎。在这里,我们不考虑一个高层次的问答系统。我们希望开发一个针对儿童的问答系统,这些儿童可以就故事提出问题,系统将根据规则和可用的故事数据返回答案。

    让我们详细了解每个组件:
    当用户提交问题时,解析器解析该问题。
    使用解释器解析与知识库、本体和关键字同义词库匹配的问题。
    在这里,我们也应用推理和事实。
    我们从问题中得到一些事实,并使用查询分类和重新编制对用户问题进行分类。
    然后,将已经生成的事实和分类查询发送到文档处理部分,在该部分将事实提供给搜索引擎。
    答案提取是Q/A系统的核心RB引擎,因为它使用事实并应用推理技术(如前链或后链)来提取所有可能的答案。现在您将要了解向后链接和向前链接。所以,在这里,我给你一个简短的概述。在前向链接中,我们从可用的数据开始,并使用推理规则从数据中提取更多的事实,直到实现一个目标。该技术用于专家系统,以了解接下来会发生什么。在向后链接中,我们从一个目标列表开始,然后向后工作,找出在过去可能发生的当前结果的条件。这些技术帮助我们理解为什么会发生这种情况。
    一旦所有可能的答案都生成了,那么它将被发送回用户。我想问你一个问题。

    如果开发Q/A系统,您希望选择哪种数据库?在你开始之前先想一想!

    我想选择NoSQL数据库而不是SQL数据库,这背后有几个原因。系统应可供用户24\7使用。在这里,我们关心我们的用户。用户可以随时访问系统,可用性是关键部分。所以,我愿意选择nosql数据库,如果以后我们想对用户的问题和答案进行分析,就需要把用户的问题和系统的答案保存在数据库中。

    7.3.4 练习

    假设您正在开发一个语法修正系统,那么您设计的是哪种系统架构?试着在纸上设计它!让你的思想表达出来。

    7.3.5 Apache UIMA架构

    ApacheUIMA基本上是由IBM开发的,用于处理非结构化数据。
    以下是UIMA的特点:
    UIMA将为我们提供基础设施、组件和框架
    UMIA有一个内置的RB引擎和gate库,用于对文本进行预处理。
    以下工具作为组件的一部分提供。它们是:
    语言识别工具
    句子分割工具
    NER工具
    我们可以用Java、Ruta和C++编写代码。它是一个灵活、模块化和易于使用的框架,C/C++注释器也支持Python和Perl。

    UIMA的应用/用途包括:
    IBM Watson使用UIMA分析非结构化数据
    临床文本分析和知识提取系统(apache ctakes)使用基于uima的系统从病历中提取信息。

    使用UIMA的挑战包括:
    您需要在Java、Ruta或C++中对规则进行编码。虽然,为了优化,许多RB系统使用C++,为RUTA获得最好的人力资源是一项具有挑战性的任务。
    如果你是新来的,你需要一些时间熟悉它。

    7.4 规则式系统的开发周期

    在本节中,我们将介绍RB系统的开发生命周期,如果您想开发自己的系统,这将在将来帮助您。图7.8描述了RB系统的开发生命周期。这个数字很容易解释,所以不需要额外的描述。

    如果我们遵循RB开发生命周期的各个阶段,那么我们的生命将很容易:
    Alt

    7.5 规则式系统的应用

    在这一部分中,我将应用程序分为两个部分:一个是NLP应用程序,另一个是广义人工智能应用程序。

    7.5.1 使用规则式系统的NLP应用

    句子边界检测:

    句子边界检测对于一般的英语写作来说很容易,但是当你处理研究论文或其他科学文献时会很复杂。因此,手工制作的后处理规则将有助于我们准确识别句子边界。这种方法已被Grammarly公司用于语法纠正系统。机器翻译:

    当我们想到机器翻译系统时,在我们的脑海中,我们想到的是谷歌神经机器翻译(GNMT)系统。对于许多印度语言来说,谷歌使用一个复杂的基于规则的系统和一个统计预测系统,因此他们有一个混合系统。2016年,谷歌推出了基于神经网络的机器翻译系统。许多研究项目仍然使用机器翻译的RB系统,其中大多数尝试开发尚未开发的语言。基于模板的聊天机器人:

    聊天机器人是当今市场的新潮流和潮流。它们的基本版本是基于模板的方法,其中,定义了一组问题或关键字,我们已经将答案映射到每个关键字。
    这个系统的好部分是匹配关键字。因此,如果您使用任何其他语言,但您的聊天信息包含我们定义的关键字,则系统可以向您发送适当的消息作为响应。
    不好的部分是,如果你犯了任何拼写错误,系统将无法以正确的方式响应。我们将从头开始开发这个应用程序。我将在下一节中解释编码部分,所以继续阅读并启动您的计算机!语法校正系统:

    对语法校正系统也进行了使用。在本发明的应用中,我们可以提供一些简单的规则,非常复杂的规则。在下一节,我们将看到一些基本的语法校正规则。问答系统:

    问答系统也使用RB系统,但这里有一件不同的事情正在发生。Q/A系统使用语义获取提交问题的答案,并将语义放入图片中,我们使用基于本体的RB方法。

    7.5.2 使用规则式系统的通用AI应用

    您已经看到了使用RB方法的NLP应用程序。现在,进入通用人工智能应用程序,它使用RB方法和其他技术:自动驾驶汽车或无驾驶汽车:

    在本章开头,我将自动驾驶汽车的例子突出使用RB系统的目的。自动驾驶汽车也采用混合动力方式。许多大公司,从谷歌到特斯拉,都在试图制造自动驾驶汽车,他们的试验是为了开发最值得信赖的自动驾驶汽车。这个应用程序是在最初几天使用复杂的RB系统开发的。然后,实验转向了ML技术的方向。如今,公司正在实施深度学习技术,使系统变得更好。机器人应用:

    人工智能社区的长期目标是开发与人类技能互补的机器人。我们有一个目标,我们要发展机器人,帮助人类完成他们的工作,这些任务基本上是耗时的。假设有一个机器人帮助你做家务。这种任务可以由机器人在所有可能情况下的规则的帮助下执行。NASA专家系统:

    美国航天局利用通用编程语言CLIPS(C语言集成生产系统)开发了专家系统。现在,我认为理论已经足够了。现在我们应该尝试从头开始开发一些RB应用程序。准备好编码。我们将在下一节开始编码之旅。

    7.6 使用规则式系统来开发NLP应用

    pip install NLTK
    pip install beautifulsoup44.6.0
    pip install requests
    2.18.1
    pip install pycorenlp
    pip install Flask0.12.2
    pip install Flask-Cors
    3.0.2
    pip install Flask-PyMongo0.5.1
    pip install pytz
    2017.2

    安装MongoDB
    1、 官方下载monodb:http://www.mongodb.org/downloads 现在最新版本mongodb-win32-x86_64-2008plus-ssl-4.0.5-signed.msi
    2、 直接安装,其中中介有默认安装和自定义路径安装

    7.6.1 编写规则的思维过程

    我们讨论了很多规则,但是这些规则实际上是如何派生出来的呢?语言学家在推导NLP应用程序规则时的思维过程是什么?那么,让我们从这个思考过程开始。

    你需要像一个语言学家一样思考一会儿。记住你在这本书中学到的所有概念,成为一名语言学家。

    假设您正在开发语法更正系统的规则,特别是针对英语的规则。所以,我描述的是语言学家的思维过程,这个思维过程可以帮助你制定规则:

    • 我需要知道什么?

    你应该知道你所创造的语言的语法规则,这里的语言是英语
    你应该知道结构、词序和其他与语言相关的概念。
    前两点是前提条件

    • 从哪里开始?

    如果你知道所有与语言有关的事情,那么你就需要观察和学习不正确的句子。
    现在,当你学习不正确的句子时,你需要知道句子中有什么错误。
    在那之后,你需要考虑错误的类别,错误是否与语法相关,或者它们是否由于语义上的歧义而引起。
    在所有这些之后,你可以将你的语言相关知识映射到句子中的错误上。

    • 规则如何派生?

    一旦你发现句子中的错误,那就把注意力集中在你的思考过程上。当你发现错误时,你的大脑会怎么想?
    想想你的大脑对你所发现的每一个错误的反应。
    您可以捕获错误,因为您知道语言或其他与语言相关的技术资料(句子语法结构、语义知识等)的语法事实。你的大脑实际上帮助你
    你的大脑知道正确的方式来解释给定的文本使用给定的语言
    这就是你能抓住错误的原因。同时,你也有一些确凿的理由,基于此,你已经发现了错误。
    一旦你识别出错误,根据错误的不同类别,你可以通过使用某些逻辑规则改变句子的某些部分来纠正错误。
    你可以改变词序,或者改变主语动词的一致性,或者你可以一起改变一些短语或者全部短语。
    答对了!在这一点上,你将得到你的规则。你知道错误是什么,你也知道把不正确的句子转换成正确的句子的步骤是什么
    你的规则逻辑只不过是把不正确的句子转换成正确的句子的步骤。

    • 我需要注意哪些要素?
      首先,你需要考虑一个非常简单的方法来纠正错误或错误的句子。
      尝试制定基于模式的规则
      如果无法派生基于模式的规则,请检查是否可以使用
      分析和/或形态分析器结果,然后检查其他工具和库
      顺便说一下,这里有一个陷阱。定义规则时,还需要考虑规则逻辑对于实现的可行性。
      工具是否可用?如果工具可用,则可以编写规则代码,或者开发人员可以编写规则代码。
      如果工具不可用,则需要放弃规则
      当您定义一个规则,然后检查是否有任何工具可供编码人员用于编码定义的规则逻辑时,需要进行研究。
      所选工具应能够对规则的异常情况进行编码。
      如果您的团队中有一些语言学家,那么定义规则和研究工具可能是语言学家的基本任务。如果不是,那么作为编码人员,您需要搜索可用于编码规则逻辑的工具。

    7.6.2 从简单规则开始

    下面脚本,它获取了维基百科上题为编程语言的页面。https://en.wikipedia.org/wiki/Programming_language
    从给定页面的文本中提取编程语言的名称是我们的目标。举个例子:页面有C、C++、JAVA、JavaScript等编程语言。我想提取它们。这些词可以是句子的一部分,也可以单独出现在文本数据内容中。

    在这里,我们的任务可以分为三部分:
    清除文本数据
    为我们的目标定义规则
    编码我们的规则并生成原型和结果
    清除文本数据

    from bs4 import BeautifulSoup
    import requests
    
    def scrapdata():
        url = 'https://en.wikipedia.org/wiki/Programming_language'
        content = requests.get(url).content
        soup = BeautifulSoup(content, 'lxml')
        tag = soup.find('div', {'class': 'mw-content-ltr'})
        paragraphs = tag.findAll('p')
        for para in paragraphs:
            paraexport = para.text.encode('utf-8')
            print(paraexport)
            savedatainfile(paraexport)
    
    
    def savedatainfile(filecontent):
        file = open("simpleruledata.txt", "a+")
        file.write(str(filecontent.strip()+b"\n"))  
        file.close()
    
    scrapdata()
    
    b'\n'
    b'A programming language is a formal language, which comprises a set of instructions used to produce various kinds of output. Programming languages are used in computer programming to create programs that implement specific algorithms.\n'
    b"Most programming languages consist of instructions for computers, although there are programmable machines that use a limited set of specific instructions, rather than the general programming languages of modern computers. Early ones preceded the invention of the digital computer, the first probably being the automatic flute player described in the 9th century by the brothers Musa in Baghdad, during the Islamic Golden Age.[1] From the early 1800s, programs were used to direct the behavior of machines such as Jacquard looms, music boxes and player pianos.[2] However, their programs (such as a player piano's scrolls) could not produce different behavior in response to some input or condition.\n"
    b'Thousands of different programming languages have been created, mainly in the computer field, and many more still are being created every year. Many programming languages require computation to be specified in an imperative form (i.e., as a sequence of operations to perform) while other languages use other forms of program specification such as the declarative form (i.e. the desired result is specified, not how to achieve it).\n'
    b'The description of a programming language is usually split into the two components of syntax (form) and semantics (meaning). Some languages are defined by a specification document (for example, the C programming language is specified by an ISO Standard) while other languages (such as Perl) have a dominant implementation that is treated as a reference. Some languages have both, with the basic language defined by a standard and extensions taken from the dominant implementation being common.\n'
    b'A programming language is a notation for writing programs, which are specifications of a computation or algorithm.[3] Some, but not all, authors restrict the term "programming language" to those languages that can express all possible algorithms.[3][4] Traits often considered important for what constitutes a programming language include:\n'
    b'Markup languages like XML, HTML, or troff, which define structured data, are not usually considered programming languages.[13][14][15] Programming languages may, however, share the syntax with markup languages if a computational semantics is defined. XSLT, for example, is a Turing complete language entirely using XML syntax.[16][17][18] Moreover, LaTeX, which is mostly used for structuring documents, also contains a Turing complete subset.[19][20]\n'
    b'The term computer language is sometimes used interchangeably with programming language.[21] However, the usage of both terms varies among authors, including the exact scope of each. One usage describes programming languages as a subset of computer languages.[22] In this vein, languages used in computing that have a different goal than expressing computer programs are generically designated computer languages. For instance, markup languages are sometimes referred to as computer languages to emphasize that they are not meant to be used for programming.[23]\n'
    b'Another usage regards programming languages as theoretical constructs for programming abstract machines, and computer languages as the subset thereof that runs on physical computers, which have finite hardware resources.[24] John C. Reynolds emphasizes that formal specification languages are just as much programming languages as are the languages intended for execution. He also argues that textual and even graphical input formats that affect the behavior of a computer are programming languages, despite the fact they are commonly not Turing-complete, and remarks that ignorance of programming language concepts is the reason for many flaws in input formats.[25]\n'
    b'Very early computers, such as Colossus, were programmed without the help of a stored program, by modifying their circuitry or setting banks of physical controls.\n'
    b'Slightly later, programs could be written in machine language, where the programmer writes each instruction in a numeric form the hardware can execute directly. For example, the instruction to add the value in two memory location might consist of 3 numbers: an "opcode" that selects the "add" operation, and two memory locations. The programs, in decimal or binary form, were read in from punched cards or paper tape or magnetic tape or toggled in on switches on the front panel of the computer.  Machine languages were later termed first-generation programming languages (1GL).\n'
    b'The next step was development of so-called second-generation programming languages (2GL) or assembly languages, which were still closely tied to the instruction set architecture of the specific computer. These served to make the program much more human-readable and relieved the programmer of tedious and error-prone address calculations.\n'
    b'The first high-level programming languages, or third-generation programming languages (3GL), were written in the 1950s. An early high-level programming language to be designed for a computer was Plankalk\xc3\xbcl, developed for the German Z3 by Konrad Zuse between 1943 and 1945. However, it was not implemented until 1998 and 2000.[26]\n'
    b"John Mauchly's Short Code, proposed in 1949, was one of the first high-level languages ever developed for an electronic computer.[27] Unlike machine code, Short Code statements represented mathematical expressions in understandable form. However, the program had to be translated into machine code every time it ran, making the process much slower than running the equivalent machine code.\n"
    b'At the University of Manchester, Alick Glennie developed Autocode in the early 1950s. A programming language, it used a compiler to automatically convert the language into machine code. The first code and compiler was developed in 1952 for the Mark 1 computer at the University of Manchester and is considered to be the first compiled high-level programming language.[28][29]\n'
    b'The second autocode was developed for the Mark 1 by R. A. Brooker in 1954 and was called the "Mark 1 Autocode". Brooker also developed an autocode for the Ferranti Mercury in the 1950s in conjunction with the University of Manchester. The version for the EDSAC 2 was devised by D. F. Hartley of  University of Cambridge Mathematical Laboratory in 1961. Known as EDSAC 2 Autocode, it was a straight development from Mercury Autocode adapted for local circumstances and was noted for its object code optimisation and source-language diagnostics which were advanced for the time. A contemporary but separate thread of development, Atlas Autocode was developed for the University of Manchester Atlas 1 machine.\n'
    b"In 1954, FORTRAN was invented at IBM by John Backus. It was the first widely used high-level general purpose programming language to have a functional implementation, as opposed to just a design on paper.[30][31] It is still a popular language for high-performance computing[32] and is used for programs that benchmark and rank the world's fastest supercomputers.[33]\n"
    b'Another early programming language was devised by Grace Hopper in the US, called FLOW-MATIC. It was developed for the UNIVAC I at Remington Rand during the period from 1955 until 1959. Hopper found that business data processing customers were uncomfortable with mathematical notation, and in early 1955, she and her team wrote a specification for an English programming language and implemented a prototype.[34] The FLOW-MATIC compiler became publicly available in early 1958 and was substantially complete in 1959.[35] FLOW-MATIC was a major influence in the design of COBOL, since only it and its direct descendant AIMACO were in actual use at the time.[36]\n'
    b'The increased use of high-level languages introduced a requirement for low-level programming languages or system programming languages. These languages, to varying degrees, provide facilities between assembly languages and high-level languages and can be used to perform tasks which require direct access to hardware facilities but still provide higher-level control structures and error-checking.\n'
    b'The period from the 1960s to the late 1970s brought the development of the major language paradigms now in use:\n'
    b'Each of these languages spawned descendants, and most modern programming languages count at least one of them in their ancestry.\n'
    b'The 1960s and 1970s also saw considerable debate over the merits of structured programming, and whether programming languages should be designed to support it.[39] Edsger Dijkstra, in a famous 1968 letter published in the Communications of the ACM, argued that GOTO statements should be eliminated from all "higher level" programming languages.[40]\n'
    b'The 1980s were years of relative consolidation. C++ combined object-oriented and systems programming. The United States government standardized Ada, a systems programming language derived from Pascal and intended for use by defense contractors. In Japan and elsewhere, vast sums were spent investigating so-called "fifth generation" languages that incorporated logic programming constructs.[41] The functional languages community moved to standardize ML and Lisp. Rather than inventing new paradigms, all of these movements elaborated upon the ideas invented in the previous decades.\n'
    b'One important trend in language design for programming large-scale systems during the 1980s was an increased focus on the use of modules or large-scale organizational units of code. Modula-2, Ada, and ML all developed notable module systems in the 1980s, which were often wedded to generic programming constructs.[42]\n'
    b'The rapid growth of the Internet in the mid-1990s created opportunities for new languages. Perl, originally a Unix scripting tool first released in 1987, became common in dynamic websites. Java came to be used for server-side programming, and bytecode virtual machines became popular again in commercial settings with their promise of "Write once, run anywhere" (UCSD Pascal had been popular for a time in the early 1980s). These developments were not fundamentally novel, rather they were refinements of many existing languages and paradigms (although their syntax was often based on the C family of programming languages).\n'
    b"Programming language evolution continues, in both industry and research. Current directions include security and reliability verification, new kinds of modularity (mixins, delegates, aspects), and database integration such as Microsoft's LINQ.\n"
    b'Fourth-generation programming languages (4GL) are computer programming languages which aim to provide a higher level of abstraction of the internal computer hardware details than 3GLs. Fifth generation programming languages (5GL) are programming languages based on solving problems using constraints given to the program, rather than using an algorithm written by a programmer.\n'
    b'All programming languages have some primitive building blocks for the description of data and the processes or transformations applied to them (like the addition of two numbers or the selection of an item from a collection). These primitives are defined by syntactic and semantic rules which describe their structure and meaning respectively.\n'
    b"A programming language's surface form is known as its syntax. Most programming languages are purely textual; they use sequences of text including words, numbers, and punctuation, much like written natural languages. On the other hand, there are some programming languages which are more graphical in nature, using visual relationships between symbols to specify a program.\n"
    b'The syntax of a language describes the possible combinations of symbols that form a syntactically correct program. The meaning given to a combination of symbols is handled by semantics (either formal or hard-coded in a reference implementation). Since most languages are textual, this article discusses textual syntax.\n'
    b'Programming language syntax is usually defined using a combination of regular expressions (for lexical structure) and Backus\xe2\x80\x93Naur form (for grammatical structure). Below is a simple grammar, based on Lisp:\n'
    b'This grammar specifies the following:\n'
    b'The following are examples of well-formed token sequences in this grammar: 12345, () and (a b c232 (1)).\n'
    b"Not all syntactically correct programs are semantically correct. Many syntactically correct programs are nonetheless ill-formed, per the language's rules; and may (depending on the language specification and the soundness of the implementation) result in an error on translation or execution. In some cases, such programs may exhibit undefined behavior. Even when a program is well-defined within a language, it may still have a meaning that is not intended by the person who wrote it.\n"
    b'Using natural language as an example, it may not be possible to assign a meaning to a grammatically correct sentence or the sentence may be false:\n'
    b'The following C language fragment is syntactically correct, but performs operations that are not semantically defined (the operation *p >> 4 has no meaning for a value having a complex type and p->im is not defined because the value of p is the null pointer):\n'
    b'If the type declaration on the first line were omitted, the program would trigger an error on undefined variable "p" during compilation. However, the program would still be syntactically correct since type declarations provide only semantic information.\n'
    b"The grammar needed to specify a programming language can be classified by its position in the Chomsky hierarchy. The syntax of most programming languages can be specified using a Type-2 grammar, i.e., they are context-free grammars.[43] Some languages, including Perl and Lisp, contain constructs that allow execution during the parsing phase. Languages that have constructs that allow the programmer to alter the behavior of the parser make syntax analysis an undecidable problem, and generally blur the distinction between parsing and execution.[44] In contrast to Lisp's macro system and Perl's BEGIN blocks, which may contain general computations, C macros are merely string replacements and do not require code execution.[45]\n"
    b'The term semantics refers to the meaning of languages, as opposed to their form (syntax).\n'
    b'The static semantics defines restrictions on the structure of valid texts that are hard or impossible to express in standard syntactic formalisms.[3] For compiled languages, static semantics essentially include those semantic rules that can be checked at compile time. Examples include checking that every identifier is declared before it is used (in languages that require such declarations) or that the labels on the arms of a case statement are distinct.[46] Many important restrictions of this type, like checking that identifiers are used in the appropriate context (e.g. not adding an integer to a function name), or that subroutine calls have the appropriate number and type of arguments, can be enforced by defining them as rules in a logic called a type system. Other forms of static analyses like data flow analysis may also be part of static semantics. Newer programming languages like Java and C# have definite assignment analysis, a form of data flow analysis, as part of their static semantics.\n'
    b'Once data has been specified, the machine must be instructed to perform operations on the data. For example, the semantics may define the strategy by which expressions are evaluated to values, or the manner in which control structures conditionally execute statements. The dynamic semantics (also known as execution semantics) of a language defines how and when the various constructs of a language should produce a program behavior. There are many ways of defining execution semantics. Natural language is often used to specify the execution semantics of languages commonly used in practice. A significant amount of academic research went into formal semantics of programming languages, which allow execution semantics to be specified in a formal manner. Results from this field of research have seen limited application to programming language design and implementation outside academia.\n'
    b'A type system defines how a programming language classifies values and expressions into types, how it can manipulate those types and how they interact. The goal of a type system is to verify and usually enforce a certain level of correctness in programs written in that language by detecting certain incorrect operations. Any decidable type system involves a trade-off: while it rejects many incorrect programs, it can also prohibit some correct, albeit unusual programs. In order to bypass this downside, a number of languages have type loopholes, usually unchecked casts that may be used by the programmer to explicitly allow a normally disallowed operation between different types. In most typed languages, the type system is used only to type check programs, but a number of languages, usually functional ones, infer types, relieving the programmer from the need to write type annotations. The formal design and study of type systems is known as type theory.\n'
    b'A language is typed if the specification of every operation defines types of data to which the operation is applicable, with the implication that it is not applicable to other types.[47] For example, the data represented by "this text between the quotes" is a string, and in many programming languages dividing a number by a string has no meaning and will be rejected by the compilers. The invalid operation may be detected when the program is compiled ("static" type checking) and will be rejected by the compiler with a compilation error message, or it may be detected when the program is run ("dynamic" type checking), resulting in a run-time exception. Many languages allow a function called an exception handler to be written to handle this exception and, for example, always return "-1" as the result.\n'
    b'A special case of typed languages are the single-type languages. These are often scripting or markup languages, such as REXX or SGML, and have only one data type[dubious  \xe2\x80\x93 discuss]-\xe2\x80\x94most commonly character strings which are used for both symbolic and numeric data.\n'
    b'In contrast, an untyped language, such as most assembly languages, allows any operation to be performed on any data, which are generally considered to be sequences of bits of various lengths.[47] High-level languages which are untyped include BCPL, Tcl, and some varieties of Forth.\n'
    b"In practice, while few languages are considered typed from the point of view of type theory (verifying or rejecting all operations), most modern languages offer a degree of typing.[47] Many production languages provide means to bypass or subvert the type system, trading type-safety for finer control over the program's execution (see casting).\n"
    b'In static typing, all expressions have their types determined prior to when the program is executed, typically at compile-time. For example, 1 and (2+2) are integer expressions; they cannot be passed to a function that expects a string, or stored in a variable that is defined to hold dates.[47]\n'
    b'Statically typed languages can be either manifestly typed or type-inferred. In the first case, the programmer must explicitly write types at certain textual positions (for example, at variable declarations). In the second case, the compiler infers the types of expressions and declarations based on context. Most mainstream statically typed languages, such as C++, C# and Java, are manifestly typed. Complete type inference has traditionally been associated with less mainstream languages, such as Haskell and ML. However, many manifestly typed languages support partial type inference; for example, C++, Java and C# all infer types in certain limited cases.[48] Additionally, some programming languages allow for some types to be automatically converted to other types; for example, an int can be used where the program expects a float.\n'
    b'Dynamic typing, also called latent typing, determines the type-safety of operations at run time; in other words, types are associated with run-time values rather than textual expressions.[47] As with type-inferred languages, dynamically typed languages do not require the programmer to write explicit type annotations on expressions. Among other things, this may permit a single variable to refer to values of different types at different points in the program execution. However, type errors cannot be automatically detected until a piece of code is actually executed, potentially making debugging more difficult. Lisp, Smalltalk, Perl, Python, JavaScript, and Ruby are all examples of dynamically typed languages.\n'
    b'Weak typing allows a value of one type to be treated as another, for example treating a string as a number.[47] This can occasionally be useful, but it can also allow some kinds of program faults to go undetected at compile time and even at run time.\n'
    b'Strong typing prevents the above. An attempt to perform an operation on the wrong type of value raises an error.[47] Strongly typed languages are often termed type-safe or safe.\n'
    b'An alternative definition for "weakly typed" refers to languages, such as Perl and JavaScript, which permit a large number of implicit type conversions. In JavaScript, for example, the expression 2 * x implicitly converts x to a number, and this conversion succeeds even if x is null, undefined, an Array, or a string of letters. Such implicit conversions are often useful, but they can mask programming errors.\nStrong and static are now generally considered orthogonal concepts, but usage in the literature differs. Some use the term strongly typed to mean strongly, statically typed, or, even more confusingly, to mean simply statically typed. Thus C has been called both strongly typed and weakly, statically typed.[49][50]\n'
    b'It may seem odd to some professional programmers that C could be "weakly, statically typed". However, notice that the use of the generic pointer, the void* pointer, does allow for casting of pointers to other pointers without needing to do an explicit cast. This is extremely similar to somehow casting an array of bytes to any kind of datatype in C without using an explicit cast, such as (int) or (char).\n'
    b"Most programming languages have an associated core library (sometimes known as the 'standard library', especially if it is included as part of the published language standard), which is conventionally made available by all implementations of the language. Core libraries typically include definitions for commonly used algorithms, data structures, and mechanisms for input and output.\n"
    b'The line between a language and its core library differs from language to language. In some cases, the language designers may treat the library as a separate entity from the language. However, a language\'s core library is often treated as part of the language by its users, and some language specifications even require that this library be made available in all implementations. Indeed, some languages are designed so that the meanings of certain syntactic constructs cannot even be described without referring to the core library. For example, in Java, a string literal is defined as an instance of the java.lang.String class; similarly, in Smalltalk, an anonymous function expression (a "block") constructs an instance of the library\'s BlockContext class. Conversely, Scheme contains multiple coherent subsets that suffice to construct the rest of the language as library macros, and so the language designers do not even bother to say which portions of the language must be implemented as language constructs, and which must be implemented as parts of a library.\n'
    b'Programming languages share properties with natural languages related to their purpose as vehicles for communication, having a syntactic form separate from its semantics, and showing language families of related languages branching one from another.[51][52] But as artificial constructs, they also differ in fundamental ways from languages that have evolved through usage. A significant difference is that a programming language can be fully described and studied in its entirety, since it has a precise and finite definition.[53] By contrast, natural languages have changing meanings given by their users in different communities. While constructed languages are also artificial languages designed from the ground up with a specific purpose, they lack the precise and complete semantic definition that a programming language has.\n'
    b'Many programming languages have been designed from scratch, altered to meet new needs, and combined with other languages. Many have eventually fallen into disuse. Although there have been attempts to design one "universal" programming language that serves all purposes, all of them have failed to be generally accepted as filling this role.[54] The need for diverse programming languages arises from the diversity of contexts in which languages are used:\n'
    b'One common trend in the development of programming languages has been to add more ability to solve problems using a higher level of abstraction. The earliest programming languages were tied very closely to the underlying hardware of the computer. As new programming languages have developed, features have been added that let programmers express ideas that are more remote from simple translation into underlying hardware instructions. Because programmers are less tied to the complexity of the computer, their programs can do more computing with less effort from the programmer. This lets them write more functionality per time unit.[55]\n'
    b'\nNatural language programming has been proposed as a way to eliminate the need for a specialized language for programming. However, this goal remains distant and its benefits are open to debate. Edsger W. Dijkstra took the position that the use of a formal language is essential to prevent the introduction of meaningless constructs, and dismissed natural language programming as "foolish".[56] Alan Perlis was similarly dismissive of the idea.[57] Hybrid approaches have been taken in Structured English and SQL.\n'
    b"A language's designers and users must construct a number of artifacts that govern and enable the practice of programming. The most important of these artifacts are the language specification and implementation.\n"
    b'The specification of a programming language is an artifact that the language users and the implementors can use to agree upon whether a piece of source code is a valid program in that language, and if so what its behavior shall be.\n'
    b'A programming language specification can take several forms, including the following:\n'
    b'An implementation of a programming language provides a way to write programs in that language and execute them on one or more configurations of hardware and software. There are, broadly, two approaches to programming language implementation: compilation and interpretation. It is generally possible to implement a language using either technique.\n'
    b'The output of a compiler may be executed by hardware or a program called an interpreter. In some implementations that make use of the interpreter approach there is no distinct boundary between compiling and interpreting. For instance, some implementations of BASIC compile and then execute the source a line at a time.\n'
    b'Programs that are executed directly on the hardware usually run several orders of magnitude faster than those that are interpreted in software.[citation needed]\n'
    b'One technique for improving the performance of interpreted programs is just-in-time compilation. Here the virtual machine, just before execution, translates the blocks of bytecode which are going to be used to machine code, for direct execution on the hardware.\n'
    b'Although most of the most commonly used programming languages have fully open specifications and implementations, many programming languages exist only as proprietary programming languages with the implementation available only from a single vendor, which may claim that such a proprietary language is their intellectual property. Proprietary programming languages are commonly domain specific languages or internal scripting languages for a single product; some proprietary languages are used only internally within a vendor, while others are available to external users.\n'
    b"Some programming languages exist on the border between proprietary and open; for example, Oracle Corporation asserts proprietary rights to some aspects of the Java programming language,[61] and Microsoft's C# programming language, which has open implementations of most parts of the system, also has Common Language Runtime (CLR) as a closed environment.[62]\n"
    b"Many proprietary languages are widely used, in spite of their proprietary nature; examples include MATLAB, VBScript, and Wolfram Language.  Some languages may make the transition from closed to open; for example, Erlang was originally an Ericsson's internal programming language.[63]\n"
    b'Thousands of different programming languages have been created, mainly in the computing field.[64]\nSoftware is commonly built with 5 programming languages or more.[65]\n'
    b'Programming languages differ from most other forms of human expression in that they require a greater degree of precision and completeness. When using a natural language to communicate with other people, human authors and speakers can be ambiguous and make small errors, and still expect their intent to be understood. However, figuratively speaking, computers "do exactly what they are told to do", and cannot "understand" what code the programmer intended to write. The combination of the language definition, a program, and the program\'s inputs must fully specify the external behavior that occurs when the program is executed, within the domain of control of that program. On the other hand, ideas about an algorithm can be communicated to humans without the precision required for execution by using pseudocode, which interleaves natural language with code written in a programming language.\n'
    b'A programming language provides a structured mechanism for defining pieces of data, and the operations or transformations that may be carried out automatically on that data. A programmer uses the abstractions present in the language to represent the concepts involved in a computation. These concepts are represented as a collection of the simplest elements available (called primitives).[66] Programming is the process by which programmers combine these primitives to compose new programs, or adapt existing ones to new uses or a changing environment.\n'
    b'Programs for a computer might be executed in a batch process without human interaction, or a user might type commands in an interactive session of an interpreter. In this case the "commands" are simply programs, whose execution is chained together. When a language can run its commands through an interpreter (such as a Unix shell or other command-line interface), without compiling, it is called a scripting language.[67]\n'
    b'Determining which is the most widely used programming language is difficult since the definition of usage varies by context. One language may occupy the greater number of programmer hours, a different one has more lines of code, and a third may consume the most CPU time. Some languages are very popular for particular kinds of applications. For example, COBOL is still strong in the corporate data center, often on large mainframes;[68][69] Fortran in scientific and engineering applications; Ada in aerospace, transportation, military, real-time and embedded applications; and C in embedded applications and operating systems. Other languages are regularly used to write many different kinds of applications.\n'
    b'Various methods of measuring language popularity, each subject to a different bias over what is measured, have been proposed:\n'
    b'Combining and averaging information from various internet sites, stackify.com reported the ten most popular programming languages as (in descending order by overall popularity): Java, C, C++, Python, C#, JavaScript, VB .NET, R, PHP, and MATLAB.[73]\n'
    b'A dialect of a programming language or a data exchange language is a (relatively small) variation or extension of the language that does not change its intrinsic nature. With languages such as Scheme and Forth, standards may be considered insufficient, inadequate or illegitimate by implementors, so often they will deviate from the standard, making a new dialect. In other cases, a dialect is created for use in a domain-specific language, often a subset. In the Lisp world, most languages that use basic S-expression syntax and Lisp-like semantics are considered Lisp dialects, although they vary wildly, as do, say, Racket and Clojure. As it is common for one language to have several dialects, it can become quite difficult for an inexperienced programmer to find the right documentation. The BASIC programming language has many dialects.\n'
    b'The explosion of Forth dialects led to the saying "If you\'ve seen one Forth... you\'ve seen one Forth."\n'
    b'There is no overarching classification scheme for programming languages. A given programming language does not usually have a single ancestor language. Languages commonly arise by combining the elements of several predecessor languages with new ideas in circulation at the time. Ideas that originate in one language will diffuse throughout a family of related languages, and then leap suddenly across familial gaps to appear in an entirely different family.\n'
    b'The task is further complicated by the fact that languages can be classified along multiple axes. For example, Java is both an object-oriented language (because it encourages object-oriented organization) and a concurrent language (because it contains built-in constructs for running multiple threads in parallel). Python is an object-oriented scripting language.\n'
    b'In broad strokes, programming languages divide into programming paradigms and a classification by intended domain of use, with general-purpose programming languages distinguished from domain-specific programming languages. Traditionally, programming languages have been regarded as describing computation in terms of imperative sentences, i.e. issuing commands. These are generally called imperative programming languages. A great deal of research in programming languages has been aimed at blurring the distinction between a program as a set of instructions and a program as an assertion about the desired answer, which is the main feature of declarative programming.[74] More refined paradigms include procedural programming, object-oriented programming, functional programming, and logic programming; some languages are hybrids of paradigms or multi-paradigmatic. An assembly language is not so much a paradigm as a direct model of an underlying machine architecture. By purpose, programming languages might be considered general purpose, system programming languages, scripting languages, domain-specific languages, or concurrent/distributed languages (or a combination of these).[75] Some general purpose languages were designed largely with educational goals.[76]\n'
    b'A programming language may also be classified by factors unrelated to programming paradigm. For instance, most programming languages use English language keywords, while a minority do not. Other languages may be classified as being deliberately esoteric or not.\n'
    

    为我们的目标定义规则
    现在,如果你看看我们收集的数据,你可以找到句子。现在,在分析文本之后,您需要定义一个规则,用于仅提取编程语言名称,例如Java、JavaScript、Matlab等等。然后,思考一下什么样的简单规则或逻辑可以帮助你实现你的目标。好好想想,慢慢来!试着专注于你的思考过程,并试着找出模式。如果我想定义一个规则,那么我将在给定数据的上下文中概括我的问题。在我的分析过程中,我注意到大多数编程语言关键字都是与单词语言一起出现的。我注意到,当语言作为一个词出现在句子中时,实际编程的可能性很高语言名称也出现在那个句子中。例如,C编程语言由ISO标准指定。在给定的例子中,C编程语言出现,单词语言也出现在句子中。因此,我将执行以下过程。首先,我需要提取包含语言的句子作为一个词。现在作为第二步,我将开始处理提取的句子,并检查句子中是否有大写单词或驼色大小写单词。然后,如果我找到任何大写的单词或驼色大小写的单词,我需要提取它们,并将它们放入列表中,因为大多数编程语言都显示为大写的单词或驼色大小写的单词格式。参见实例:C、C++、Java、JavaScript等。在某些情况下,一个句子包含多个编程语言的名称。
    前面的过程是我们的规则,规则的逻辑形式如下:

    以语言为词提取句子
    然后试着找出句子中驼色或大写的单词
    把这些单词列成一个单子
    打印列表
    编码规则并生成原型和结果
    这个例子给出了规则制定过程的实际本质。这是我们的第一步,所以我们不太注重准确性。我知道,这不是解决这个问题的唯一方法,也不是最有效的方法。还有其他有效的方法来实现同一个问题,但是我使用这个方法是因为我觉得这个解决方案是最简单和最容易理解的。
    这个例子可以帮助您理解如何对规则进行编码,以及在获得第一个原型的结果之后,您可以采取哪些后续步骤来改进输出。

    def rulelogic(filecontent):
        programminglanguagelist = []
        with open(filecontent,encoding='UTF-8')as file:
            for line in file:
                if 'languages' in line or 'language' in line:
                    # print line
                    words = line.split()
                    for word in words:
                        if word[0].isupper():
                            programminglanguagelist.append(word)
                            # print programminglanguagelist
            print(programminglanguagelist) 
    
    rulelogic("simpleruledata.txt")
    
    ['A', 'Programming', 'Programming', 'The', 'Musa', 'Baghdad,', 'Islamic', 'Golden', 'Age".[1]', 'From', 'Jacquard', 'Thousands', 'Many', 'The', 'Some', 'C', 'ISO', 'Standard)', 'Perl)', 'Some', 'A', 'Some,', 'Traits', 'Markup', 'XML,', 'HTML,', 'Programming', 'XSLT,', 'Turing', 'XML', 'Moreover,', 'LaTeX,', 'Turing', 'The', 'However,', 'One', 'In', 'For', 'Another', 'John', 'C.', 'Reynolds', 'He', 'Turing-complete,', 'The', 'The', 'Absolute', 'The', 'These', 'The', 'An', 'Plankalkül,', 'German', 'Z3', 'Konrad', 'Zuse', 'However,', 'John', "Mauchly's", 'Short', 'Code,', 'Unlike', 'Short', 'Code', 'However,', 'At', 'University', 'Manchester,', 'Alick', 'Glennie', 'Autocode', 'A', 'The', 'Mark', 'University', 'Manchester', 'The', 'Mark', 'R.', 'A.', 'Brooker', 'Autocode".', 'Brooker', 'Ferranti', 'Mercury', 'University', 'Manchester.', 'The', 'EDSAC', 'D.', 'F.', 'Hartley', 'University', 'Cambridge', 'Mathematical', 'Laboratory', 'Known', 'EDSAC', 'Autocode,', 'Mercury', 'Autocode', 'A', 'Atlas', 'Autocode', 'University', 'Manchester', 'Atlas', 'In', 'FORTRAN', 'IBM', 'John', 'Backus.', 'It', 'It', 'Another', 'Grace', 'Hopper', 'US,', 'FLOW-MATIC.', 'It', 'UNIVAC', 'I', 'Remington', 'Rand', 'Hopper', 'English', 'The', 'FLOW-MATIC', 'Flow-Matic', 'COBOL,', 'AIMACO', 'The', 'These', 'The', 'Each', 'The', 'Edsger', 'Dijkstra,', 'Communications', 'ACM,', 'GOTO', 'The', 'C++', 'The', 'United', 'States', 'Ada,', 'Pascal', 'In', 'Japan', 'The', 'ML', 'Lisp.', 'Rather', 'One', 'Modula-2,', 'Ada,', 'ML', 'The', 'Internet', 'Perl,', 'Unix', 'Java', 'Pascal', 'These', 'C', 'Programming', 'Current', "Microsoft's", 'LINQ.', 'Fourth-generation', 'Fifth', 'All', 'These', 'A', 'Most', 'On', 'The', 'The', 'Since', 'Programming', 'Backus–Naur', 'Below', 'Lisp:', 'Not', 'Many', 'In', 'Even', 'Using', 'The', 'C', 'The', 'Chomsky', 'The', 'Type-2', 'Some', 'Perl', 'Lisp,', 'Languages', 'In', "Lisp's", "Perl's", 'BEGIN', 'C', 'The', 'The', 'For', 'Examples', 'Many', 'Other', 'Newer', 'Java', 'C#', 'Once', 'For', 'The', 'There', 'Natural', 'A', 'Results', 'A', 'The', 'Any', 'In', 'In', 'The', 'A', 'For', 'The', 'Many', 'A', 'These', 'REXX', 'SGML,', 'In', 'High-level', 'BCPL,', 'Tcl,', 'Forth.', 'In', 'Many', 'Statically', 'In', 'In', 'Most', 'C++,', 'C#', 'Java,', 'Complete', 'Haskell', 'ML.', 'However,', 'Java', 'C#', 'Additionally,', 'Dynamic', 'As', 'Among', 'However,', 'Lisp,', 'Smalltalk,', 'Perl,', 'Python,', 'JavaScript,', 'Ruby', 'Strong', 'An', 'Strongly', 'An', 'Perl', 'JavaScript,', 'In', 'JavaScript,', 'Array,', 'Such', 'Strong', 'Some', 'Thus', 'C', 'Most', 'Core', 'The', 'In', 'However,', 'Indeed,', 'For', 'Java,', 'Smalltalk,', 'BlockContext', 'Conversely,', 'Scheme', 'Programming', 'But', 'A', 'By', 'While', 'Many', 'Many', 'Although', 'The', 'One', 'The', 'As', 'Because', 'This', 'Natural', 'However,', 'Edsger', 'W.', 'Dijkstra', 'Alan', 'Perlis', 'Hybrid', 'Structured', 'English', 'SQL.', 'A', 'The', 'The', 'A', 'An', 'There', 'It', 'Although', 'Proprietary', 'Some', 'Oracle', 'Corporation', 'Java', "Microsoft's", 'C#', 'Common', 'Language', 'Runtime', 'Many', 'MATLAB', 'VBScript.', 'Some', 'Erlang', "Ericsson's", 'Thousands', 'Software', 'Programming', 'When', 'However,', 'The', 'On', 'A', 'A', 'These', 'Programming', 'Programs', 'In', 'When', 'Unix', 'It', 'One', 'CPU', 'Some', 'For', 'COBOL', 'Fortran', 'Ada', 'C', 'Other', 'Various', 'Combining', 'C,', 'Java,', 'PHP,', 'JavaScript,', 'C++,', 'Python,', 'Shell,', 'Ruby,', 'Objective-C', 'C#.[70]', 'There', 'A', 'Languages', 'Ideas', 'The', 'For', 'Java', 'Python', 'In', 'Traditionally,', 'These', 'A', 'More', 'An', 'By', 'Some', 'A', 'For', 'English', 'Other', 'A', 'Programming', 'Most', 'Early', 'Musa', 'Baghdad,', 'Islamic', 'Golden', 'Age.[1]', 'From', 'Jacquard', 'However,', 'Thousands', 'Many', 'The', 'Some', 'C', 'ISO', 'Standard)', 'Perl)', 'Some', 'A', 'Some,', 'Traits', 'Markup', 'XML,', 'HTML,', 'Programming', 'XSLT,', 'Turing', 'XML', 'Moreover,', 'LaTeX,', 'Turing', 'The', 'However,', 'One', 'In', 'For', 'Another', 'John', 'C.', 'Reynolds', 'He', 'Turing-complete,', 'Slightly', 'For', 'The', 'Machine', 'The', 'These', 'The', 'An', 'Plankalkül,', 'German', 'Z3', 'Konrad', 'Zuse', 'However,', 'John', "Mauchly's", 'Short', 'Code,', 'Unlike', 'Short', 'Code', 'However,', 'At', 'University', 'Manchester,', 'Alick', 'Glennie', 'Autocode', 'A', 'The', 'Mark', 'University', 'Manchester', 'The', 'Mark', 'R.', 'A.', 'Brooker', 'Autocode".', 'Brooker', 'Ferranti', 'Mercury', 'University', 'Manchester.', 'The', 'EDSAC', 'D.', 'F.', 'Hartley', 'University', 'Cambridge', 'Mathematical', 'Laboratory', 'Known', 'EDSAC', 'Autocode,', 'Mercury', 'Autocode', 'A', 'Atlas', 'Autocode', 'University', 'Manchester', 'Atlas', 'In', 'FORTRAN', 'IBM', 'John', 'Backus.', 'It', 'It', 'Another', 'Grace', 'Hopper', 'US,', 'FLOW-MATIC.', 'It', 'UNIVAC', 'I', 'Remington', 'Rand', 'Hopper', 'English', 'The', 'FLOW-MATIC', 'FLOW-MATIC', 'COBOL,', 'AIMACO', 'The', 'These', 'The', 'Each', 'The', 'Edsger', 'Dijkstra,', 'Communications', 'ACM,', 'GOTO', 'The', 'C++', 'The', 'United', 'States', 'Ada,', 'Pascal', 'In', 'Japan', 'The', 'ML', 'Lisp.', 'Rather', 'One', 'Modula-2,', 'Ada,', 'ML', 'The', 'Internet', 'Perl,', 'Unix', 'Java', 'Pascal', 'These', 'C', 'Programming', 'Current', "Microsoft's", 'LINQ.', 'Fourth-generation', 'Fifth', 'All', 'These', 'A', 'Most', 'On', 'The', 'The', 'Since', 'Programming', 'Backus–Naur', 'Below', 'Lisp:', 'Not', 'Many', 'In', 'Even', 'Using', 'The', 'C', 'The', 'Chomsky', 'The', 'Type-2', 'Some', 'Perl', 'Lisp,', 'Languages', 'In', "Lisp's", "Perl's", 'BEGIN', 'C', 'The', 'The', 'For', 'Examples', 'Many', 'Other', 'Newer', 'Java', 'C#', 'Once', 'For', 'The', 'There', 'Natural', 'A', 'Results', 'A', 'The', 'Any', 'In', 'In', 'The', 'A', 'For', 'The', 'Many', 'A', 'These', 'REXX', 'SGML,', 'In', 'High-level', 'BCPL,', 'Tcl,', 'Forth.', 'In', 'Many', 'Statically', 'In', 'In', 'Most', 'C++,', 'C#', 'Java,', 'Complete', 'Haskell', 'ML.', 'However,', 'C++,', 'Java', 'C#', 'Additionally,', 'Dynamic', 'As', 'Among', 'However,', 'Lisp,', 'Smalltalk,', 'Perl,', 'Python,', 'JavaScript,', 'Ruby', 'Strong', 'An', 'Strongly', 'An', 'Perl', 'JavaScript,', 'In', 'JavaScript,', 'Array,', 'Such', 'Most', 'Core', 'The', 'In', 'However,', 'Indeed,', 'For', 'Java,', 'Smalltalk,', 'BlockContext', 'Conversely,', 'Scheme', 'Programming', 'But', 'A', 'By', 'While', 'Many', 'Many', 'Although', 'The', 'One', 'The', 'As', 'Because', 'This', 'Natural', 'However,', 'Edsger', 'W.', 'Dijkstra', 'Alan', 'Perlis', 'Hybrid', 'Structured', 'English', 'SQL.', 'A', 'The', 'The', 'A', 'An', 'There', 'It', 'Although', 'Proprietary', 'Some', 'Oracle', 'Corporation', 'Java', "Microsoft's", 'C#', 'Common', 'Language', 'Runtime', 'Many', 'MATLAB,', 'VBScript,', 'Wolfram', 'Language.', 'Some', 'Erlang', "Ericsson's", 'Thousands', 'Software', 'Programming', 'When', 'However,', 'The', 'On', 'A', 'A', 'These', 'Programming', 'Programs', 'In', 'When', 'Unix', 'Determining', 'One', 'CPU', 'Some', 'For', 'COBOL', 'Fortran', 'Ada', 'C', 'Other', 'Various', 'Combining', 'Java,', 'C,', 'C++,', 'Python,', 'C#,', 'JavaScript,', 'VB', 'R,', 'PHP,', 'MATLAB.[73]', 'A', 'With', 'Scheme', 'Forth,', 'In', 'In', 'Lisp', 'S-expression', 'Lisp-like', 'Lisp', 'Racket', 'Clojure.', 'As', 'The', 'BASIC', 'There', 'A', 'Languages', 'Ideas', 'The', 'For', 'Java', 'Python', 'In', 'Traditionally,', 'These', 'A', 'More', 'An', 'By', 'Some', 'A', 'For', 'English', 'Other', 'Programming', 'Early', 'Musa', 'Baghdad,', 'Islamic', 'Golden', 'Age.[1]', 'From', 'Jacquard', 'However,', 'Many', 'Some', 'C', 'ISO', 'Standard)', 'Perl)', 'Some', 'Some,', 'Traits', 'XML,', 'HTML,', 'Programming', 'XSLT,', 'Turing', 'XML', 'Moreover,', 'LaTeX,', 'Turing', 'However,', 'One', 'In', 'For', 'John', 'C.', 'Reynolds', 'He', 'Turing-complete,', 'Colossus,', 'For', 'The', 'Machine', 'These', 'An', 'Plankalk\\xc3\\xbcl,', 'German', 'Z3', 'Konrad', 'Zuse', 'However,', "Mauchly's", 'Short', 'Code,', 'Unlike', 'Short', 'Code', 'However,', 'University', 'Manchester,', 'Alick', 'Glennie', 'Autocode', 'A', 'The', 'Mark', 'University', 'Manchester', 'Mark', 'R.', 'A.', 'Brooker', 'Autocode".', 'Brooker', 'Ferranti', 'Mercury', 'University', 'Manchester.', 'The', 'EDSAC', 'D.', 'F.', 'Hartley', 'University', 'Cambridge', 'Mathematical', 'Laboratory', 'Known', 'EDSAC', 'Autocode,', 'Mercury', 'Autocode', 'A', 'Atlas', 'Autocode', 'University', 'Manchester', 'Atlas', 'FORTRAN', 'IBM', 'John', 'Backus.', 'It', 'It', 'Grace', 'Hopper', 'US,', 'FLOW-MATIC.', 'It', 'UNIVAC', 'I', 'Remington', 'Rand', 'Hopper', 'English', 'The', 'FLOW-MATIC', 'FLOW-MATIC', 'COBOL,', 'AIMACO', 'These', 'Edsger', 'Dijkstra,', 'Communications', 'ACM,', 'GOTO', 'C++', 'The', 'United', 'States', 'Ada,', 'Pascal', 'In', 'Japan', 'The', 'ML', 'Lisp.', 'Rather', 'Modula-2,', 'Ada,', 'ML', 'Internet', 'Perl,', 'Unix', 'Java', 'Pascal', 'These', 'C', 'Current', "Microsoft's", 'LINQ.\\n"b\'Fourth-generation', 'Fifth', 'These', 'Most', 'On', 'The', 'Since', 'Backus\\xe2\\x80\\x93Naur', 'Below', "Lisp:\\n'b'This", 'Many', 'In', 'Even', 'C', 'However,', 'Chomsky', 'The', 'Type-2', 'Some', 'Perl', 'Lisp,', 'Languages', 'In', "Lisp's", "Perl's", 'BEGIN', 'C', 'For', 'Examples', 'Many', 'Other', 'Newer', 'Java', 'C#', 'For', 'The', 'There', 'Natural', 'A', 'Results', 'The', 'Any', 'In', 'In', 'The', 'For', 'The', 'Many', 'These', 'REXX', 'SGML,', 'High-level', 'BCPL,', 'Tcl,', 'Forth.\\n\'b"In', 'Many', 'For', 'In', 'In', 'Most', 'C++,', 'C#', 'Java,', 'Complete', 'Haskell', 'ML.', 'However,', 'C++,', 'Java', 'C#', 'Additionally,', 'As', 'Among', 'However,', 'Lisp,', 'Smalltalk,', 'Perl,', 'Python,', 'JavaScript,', 'Ruby', 'This', 'An', 'Strongly', 'Perl', 'JavaScript,', 'In', 'JavaScript,', 'Array,', 'Such', 'Some', 'Thus', 'C', 'C', 'However,', 'This', 'C', 'Core', 'In', 'However,', 'Indeed,', 'For', 'Java,', 'Smalltalk,', 'BlockContext', 'Conversely,', 'Scheme', 'But', 'A', 'By', 'While', 'Many', 'Although', 'The', 'The', 'As', 'Because', 'This', 'However,', 'Edsger', 'W.', 'Dijkstra', 'Alan', 'Perlis', 'Hybrid', 'Structured', 'English', 'SQL.\\n\'b"A', 'The', 'There', 'It', 'In', 'For', 'BASIC', 'Here', 'Proprietary', 'Oracle', 'Corporation', 'Java', "Microsoft's", 'C#', 'Common', 'Language', 'Runtime', 'MATLAB,', 'VBScript,', 'Wolfram', 'Language.', 'Some', 'Erlang', "Ericsson's", 'When', 'However,', 'The', 'On', 'A', 'These', 'Programming', 'In', 'When', 'Unix', 'One', 'CPU', 'Some', 'For', 'COBOL', 'Fortran', 'Ada', 'C', 'Other', 'Java,', 'C,', 'C++,', 'Python,', 'C#,', 'JavaScript,', 'VB', 'R,', 'PHP,', "MATLAB.[73]\\n'b'A", 'With', 'Scheme', 'Forth,', 'In', 'In', 'Lisp', 'S-expression', 'Lisp-like', 'Lisp', 'Racket', 'Clojure.', 'As', 'The', 'BASIC', 'Forth', 'Forth...', 'Forth."\\n\'b\'There', 'A', 'Languages', 'Ideas', 'For', 'Java', 'Python', 'Traditionally,', 'These', 'A', 'More', 'An', 'By', 'Some', 'For', 'English', 'Other', 'Programming', 'Early', 'Musa', 'Baghdad,', 'Islamic', 'Golden', 'Age.[1]', 'From', 'Jacquard', 'However,', 'Many', 'Some', 'C', 'ISO', 'Standard)', 'Perl)', 'Some', 'Some,', 'Traits', 'XML,', 'HTML,', 'Programming', 'XSLT,', 'Turing', 'XML', 'Moreover,', 'LaTeX,', 'Turing', 'However,', 'One', 'In', 'For', 'John', 'C.', 'Reynolds', 'He', 'Turing-complete,', 'Colossus,', 'For', 'The', 'Machine', 'These', 'An', 'Plankalk\\xc3\\xbcl,', 'German', 'Z3', 'Konrad', 'Zuse', 'However,', "Mauchly's", 'Short', 'Code,', 'Unlike', 'Short', 'Code', 'However,', 'University', 'Manchester,', 'Alick', 'Glennie', 'Autocode', 'A', 'The', 'Mark', 'University', 'Manchester', 'Mark', 'R.', 'A.', 'Brooker', 'Autocode".', 'Brooker', 'Ferranti', 'Mercury', 'University', 'Manchester.', 'The', 'EDSAC', 'D.', 'F.', 'Hartley', 'University', 'Cambridge', 'Mathematical', 'Laboratory', 'Known', 'EDSAC', 'Autocode,', 'Mercury', 'Autocode', 'A', 'Atlas', 'Autocode', 'University', 'Manchester', 'Atlas', 'FORTRAN', 'IBM', 'John', 'Backus.', 'It', 'It', 'Grace', 'Hopper', 'US,', 'FLOW-MATIC.', 'It', 'UNIVAC', 'I', 'Remington', 'Rand', 'Hopper', 'English', 'The', 'FLOW-MATIC', 'FLOW-MATIC', 'COBOL,', 'AIMACO', 'These', 'Edsger', 'Dijkstra,', 'Communications', 'ACM,', 'GOTO', 'C++', 'The', 'United', 'States', 'Ada,', 'Pascal', 'In', 'Japan', 'The', 'ML', 'Lisp.', 'Rather', 'Modula-2,', 'Ada,', 'ML', 'Internet', 'Perl,', 'Unix', 'Java', 'Pascal', 'These', 'C', 'Current', "Microsoft's", 'LINQ.\\n"b\'Fourth-generation', 'Fifth', 'These', 'Most', 'On', 'The', 'Since', 'Backus\\xe2\\x80\\x93Naur', 'Below', "Lisp:\\n'b'This", 'Many', 'In', 'Even', 'C', 'However,', 'Chomsky', 'The', 'Type-2', 'Some', 'Perl', 'Lisp,', 'Languages', 'In', "Lisp's", "Perl's", 'BEGIN', 'C', 'For', 'Examples', 'Many', 'Other', 'Newer', 'Java', 'C#', 'For', 'The', 'There', 'Natural', 'A', 'Results', 'The', 'Any', 'In', 'In', 'The', 'For', 'The', 'Many', 'These', 'REXX', 'SGML,', 'High-level', 'BCPL,', 'Tcl,', 'Forth.\\n\'b"In', 'Many', 'For', 'In', 'In', 'Most', 'C++,', 'C#', 'Java,', 'Complete', 'Haskell', 'ML.', 'However,', 'C++,', 'Java', 'C#', 'Additionally,', 'As', 'Among', 'However,', 'Lisp,', 'Smalltalk,', 'Perl,', 'Python,', 'JavaScript,', 'Ruby', 'This', 'An', 'Strongly', 'Perl', 'JavaScript,', 'In', 'JavaScript,', 'Array,', 'Such', 'Some', 'Thus', 'C', 'C', 'However,', 'This', 'C', 'Core', 'In', 'However,', 'Indeed,', 'For', 'Java,', 'Smalltalk,', 'BlockContext', 'Conversely,', 'Scheme', 'But', 'A', 'By', 'While', 'Many', 'Although', 'The', 'The', 'As', 'Because', 'This', 'However,', 'Edsger', 'W.', 'Dijkstra', 'Alan', 'Perlis', 'Hybrid', 'Structured', 'English', 'SQL.\\n\'b"A', 'The', 'There', 'It', 'In', 'For', 'BASIC', 'Here', 'Proprietary', 'Oracle', 'Corporation', 'Java', "Microsoft's", 'C#', 'Common', 'Language', 'Runtime', 'MATLAB,', 'VBScript,', 'Wolfram', 'Language.', 'Some', 'Erlang', "Ericsson's", 'When', 'However,', 'The', 'On', 'A', 'These', 'Programming', 'In', 'When', 'Unix', 'One', 'CPU', 'Some', 'For', 'COBOL', 'Fortran', 'Ada', 'C', 'Other', 'Java,', 'C,', 'C++,', 'Python,', 'C#,', 'JavaScript,', 'VB', 'R,', 'PHP,', "MATLAB.[73]\\n'b'A", 'With', 'Scheme', 'Forth,', 'In', 'In', 'Lisp', 'S-expression', 'Lisp-like', 'Lisp', 'Racket', 'Clojure.', 'As', 'The', 'BASIC', 'Forth', 'Forth...', 'Forth."\\n\'b\'There', 'A', 'Languages', 'Ideas', 'For', 'Java', 'Python', 'Traditionally,', 'These', 'A', 'More', 'An', 'By', 'Some', 'For', 'English', 'Other', 'Programming', 'Early', 'Musa', 'Baghdad,', 'Islamic', 'Golden', 'Age.[1]', 'From', 'Jacquard', 'However,', 'Many', 'Some', 'C', 'ISO', 'Standard)', 'Perl)', 'Some', 'Some,', 'Traits', 'XML,', 'HTML,', 'Programming', 'XSLT,', 'Turing', 'XML', 'Moreover,', 'LaTeX,', 'Turing', 'However,', 'One', 'In', 'For', 'John', 'C.', 'Reynolds', 'He', 'Turing-complete,', 'Colossus,', 'For', 'The', 'Machine', 'These', 'An', 'Plankalk\\xc3\\xbcl,', 'German', 'Z3', 'Konrad', 'Zuse', 'However,', "Mauchly's", 'Short', 'Code,', 'Unlike', 'Short', 'Code', 'However,', 'University', 'Manchester,', 'Alick', 'Glennie', 'Autocode', 'A', 'The', 'Mark', 'University', 'Manchester', 'Mark', 'R.', 'A.', 'Brooker', 'Autocode".', 'Brooker', 'Ferranti', 'Mercury', 'University', 'Manchester.', 'The', 'EDSAC', 'D.', 'F.', 'Hartley', 'University', 'Cambridge', 'Mathematical', 'Laboratory', 'Known', 'EDSAC', 'Autocode,', 'Mercury', 'Autocode', 'A', 'Atlas', 'Autocode', 'University', 'Manchester', 'Atlas', 'FORTRAN', 'IBM', 'John', 'Backus.', 'It', 'It', 'Grace', 'Hopper', 'US,', 'FLOW-MATIC.', 'It', 'UNIVAC', 'I', 'Remington', 'Rand', 'Hopper', 'English', 'The', 'FLOW-MATIC', 'FLOW-MATIC', 'COBOL,', 'AIMACO', 'These', 'Edsger', 'Dijkstra,', 'Communications', 'ACM,', 'GOTO', 'C++', 'The', 'United', 'States', 'Ada,', 'Pascal', 'In', 'Japan', 'The', 'ML', 'Lisp.', 'Rather', 'Modula-2,', 'Ada,', 'ML', 'Internet', 'Perl,', 'Unix', 'Java', 'Pascal', 'These', 'C', 'Current', "Microsoft's", 'LINQ.\\n"b\'Fourth-generation', 'Fifth', 'These', 'Most', 'On', 'The', 'Since', 'Backus\\xe2\\x80\\x93Naur', 'Below', "Lisp:\\n'b'This", 'Many', 'In', 'Even', 'C', 'However,', 'Chomsky', 'The', 'Type-2', 'Some', 'Perl', 'Lisp,', 'Languages', 'In', "Lisp's", "Perl's", 'BEGIN', 'C', 'For', 'Examples', 'Many', 'Other', 'Newer', 'Java', 'C#', 'For', 'The', 'There', 'Natural', 'A', 'Results', 'The', 'Any', 'In', 'In', 'The', 'For', 'The', 'Many', 'These', 'REXX', 'SGML,', 'High-level', 'BCPL,', 'Tcl,', 'Forth.\\n\'b"In', 'Many', 'For', 'In', 'In', 'Most', 'C++,', 'C#', 'Java,', 'Complete', 'Haskell', 'ML.', 'However,', 'C++,', 'Java', 'C#', 'Additionally,', 'As', 'Among', 'However,', 'Lisp,', 'Smalltalk,', 'Perl,', 'Python,', 'JavaScript,', 'Ruby', 'This', 'An', 'Strongly', 'Perl', 'JavaScript,', 'In', 'JavaScript,', 'Array,', 'Such', 'Some', 'Thus', 'C', 'C', 'However,', 'This', 'C', 'Core', 'In', 'However,', 'Indeed,', 'For', 'Java,', 'Smalltalk,', 'BlockContext', 'Conversely,', 'Scheme', 'But', 'A', 'By', 'While', 'Many', 'Although', 'The', 'The', 'As', 'Because', 'This', 'However,', 'Edsger', 'W.', 'Dijkstra', 'Alan', 'Perlis', 'Hybrid', 'Structured', 'English', 'SQL.\\n\'b"A', 'The', 'There', 'It', 'In', 'For', 'BASIC', 'Here', 'Proprietary', 'Oracle', 'Corporation', 'Java', "Microsoft's", 'C#', 'Common', 'Language', 'Runtime', 'MATLAB,', 'VBScript,', 'Wolfram', 'Language.', 'Some', 'Erlang', "Ericsson's", 'When', 'However,', 'The', 'On', 'A', 'These', 'Programming', 'In', 'When', 'Unix', 'One', 'CPU', 'Some', 'For', 'COBOL', 'Fortran', 'Ada', 'C', 'Other', 'Java,', 'C,', 'C++,', 'Python,', 'C#,', 'JavaScript,', 'VB', 'R,', 'PHP,', "MATLAB.[73]\\n'b'A", 'With', 'Scheme', 'Forth,', 'In', 'In', 'Lisp', 'S-expression', 'Lisp-like', 'Lisp', 'Racket', 'Clojure.', 'As', 'The', 'BASIC', 'Forth', 'Forth...', 'Forth."\\n\'b\'There', 'A', 'Languages', 'Ideas', 'For', 'Java', 'Python', 'Traditionally,', 'These', 'A', 'More', 'An', 'By', 'Some', 'For', 'English', 'Other', 'Programming', 'Early', 'Musa', 'Baghdad,', 'Islamic', 'Golden', 'Age.[1]', 'From', 'Jacquard', 'However,', 'Many', 'Some', 'C', 'ISO', 'Standard)', 'Perl)', 'Some', 'Some,', 'Traits', 'XML,', 'HTML,', 'Programming', 'XSLT,', 'Turing', 'XML', 'Moreover,', 'LaTeX,', 'Turing', 'However,', 'One', 'In', 'For', 'John', 'C.', 'Reynolds', 'He', 'Turing-complete,', 'Colossus,', 'For', 'The', 'Machine', 'These', 'An', 'Plankalk\\xc3\\xbcl,', 'German', 'Z3', 'Konrad', 'Zuse', 'However,', "Mauchly's", 'Short', 'Code,', 'Unlike', 'Short', 'Code', 'However,', 'University', 'Manchester,', 'Alick', 'Glennie', 'Autocode', 'A', 'The', 'Mark', 'University', 'Manchester', 'Mark', 'R.', 'A.', 'Brooker', 'Autocode".', 'Brooker', 'Ferranti', 'Mercury', 'University', 'Manchester.', 'The', 'EDSAC', 'D.', 'F.', 'Hartley', 'University', 'Cambridge', 'Mathematical', 'Laboratory', 'Known', 'EDSAC', 'Autocode,', 'Mercury', 'Autocode', 'A', 'Atlas', 'Autocode', 'University', 'Manchester', 'Atlas', 'FORTRAN', 'IBM', 'John', 'Backus.', 'It', 'It', 'Grace', 'Hopper', 'US,', 'FLOW-MATIC.', 'It', 'UNIVAC', 'I', 'Remington', 'Rand', 'Hopper', 'English', 'The', 'FLOW-MATIC', 'FLOW-MATIC', 'COBOL,', 'AIMACO', 'These', 'Edsger', 'Dijkstra,', 'Communications', 'ACM,', 'GOTO', 'C++', 'The', 'United', 'States', 'Ada,', 'Pascal', 'In', 'Japan', 'The', 'ML', 'Lisp.', 'Rather', 'Modula-2,', 'Ada,', 'ML', 'Internet', 'Perl,', 'Unix', 'Java', 'Pascal', 'These', 'C', 'Current', "Microsoft's", 'LINQ.\\n"b\'Fourth-generation', 'Fifth', 'These', 'Most', 'On', 'The', 'Since', 'Backus\\xe2\\x80\\x93Naur', 'Below', "Lisp:\\n'b'This", 'Many', 'In', 'Even', 'C', 'However,', 'Chomsky', 'The', 'Type-2', 'Some', 'Perl', 'Lisp,', 'Languages', 'In', "Lisp's", "Perl's", 'BEGIN', 'C', 'For', 'Examples', 'Many', 'Other', 'Newer', 'Java', 'C#', 'For', 'The', 'There', 'Natural', 'A', 'Results', 'The', 'Any', 'In', 'In', 'The', 'For', 'The', 'Many', 'These', 'REXX', 'SGML,', 'High-level', 'BCPL,', 'Tcl,', 'Forth.\\n\'b"In', 'Many', 'For', 'In', 'In', 'Most', 'C++,', 'C#', 'Java,', 'Complete', 'Haskell', 'ML.', 'However,', 'C++,', 'Java', 'C#', 'Additionally,', 'As', 'Among', 'However,', 'Lisp,', 'Smalltalk,', 'Perl,', 'Python,', 'JavaScript,', 'Ruby', 'This', 'An', 'Strongly', 'Perl', 'JavaScript,', 'In', 'JavaScript,', 'Array,', 'Such', 'Some', 'Thus', 'C', 'C', 'However,', 'This', 'C', 'Core', 'In', 'However,', 'Indeed,', 'For', 'Java,', 'Smalltalk,', 'BlockContext', 'Conversely,', 'Scheme', 'But', 'A', 'By', 'While', 'Many', 'Although', 'The', 'The', 'As', 'Because', 'This', 'However,', 'Edsger', 'W.', 'Dijkstra', 'Alan', 'Perlis', 'Hybrid', 'Structured', 'English', 'SQL.\\n\'b"A', 'The', 'There', 'It', 'In', 'For', 'BASIC', 'Here', 'Proprietary', 'Oracle', 'Corporation', 'Java', "Microsoft's", 'C#', 'Common', 'Language', 'Runtime', 'MATLAB,', 'VBScript,', 'Wolfram', 'Language.', 'Some', 'Erlang', "Ericsson's", 'When', 'However,', 'The', 'On', 'A', 'These', 'Programming', 'In', 'When', 'Unix', 'One', 'CPU', 'Some', 'For', 'COBOL', 'Fortran', 'Ada', 'C', 'Other', 'Java,', 'C,', 'C++,', 'Python,', 'C#,', 'JavaScript,', 'VB', 'R,', 'PHP,', "MATLAB.[73]\\n'b'A", 'With', 'Scheme', 'Forth,', 'In', 'In', 'Lisp', 'S-expression', 'Lisp-like', 'Lisp', 'Racket', 'Clojure.', 'As', 'The', 'BASIC', 'Forth', 'Forth...', 'Forth."\\n\'b\'There', 'A', 'Languages', 'Ideas', 'For', 'Java', 'Python', 'Traditionally,', 'These', 'A', 'More', 'An', 'By', 'Some', 'For', 'English', 'Other', 'Programming', 'Early', 'Musa', 'Baghdad,', 'Islamic', 'Golden', 'Age.[1]', 'From', 'Jacquard', 'However,', 'Many', 'Some', 'C', 'ISO', 'Standard)', 'Perl)', 'Some', 'Some,', 'Traits', 'XML,', 'HTML,', 'Programming', 'XSLT,', 'Turing', 'XML', 'Moreover,', 'LaTeX,', 'Turing', 'However,', 'One', 'In', 'For', 'John', 'C.', 'Reynolds', 'He', 'Turing-complete,', 'Colossus,', 'For', 'The', 'Machine', 'These', 'An', 'Plankalk\\xc3\\xbcl,', 'German', 'Z3', 'Konrad', 'Zuse', 'However,', "Mauchly's", 'Short', 'Code,', 'Unlike', 'Short', 'Code', 'However,', 'University', 'Manchester,', 'Alick', 'Glennie', 'Autocode', 'A', 'The', 'Mark', 'University', 'Manchester', 'Mark', 'R.', 'A.', 'Brooker', 'Autocode".', 'Brooker', 'Ferranti', 'Mercury', 'University', 'Manchester.', 'The', 'EDSAC', 'D.', 'F.', 'Hartley', 'University', 'Cambridge', 'Mathematical', 'Laboratory', 'Known', 'EDSAC', 'Autocode,', 'Mercury', 'Autocode', 'A', 'Atlas', 'Autocode', 'University', 'Manchester', 'Atlas', 'FORTRAN', 'IBM', 'John', 'Backus.', 'It', 'It', 'Grace', 'Hopper', 'US,', 'FLOW-MATIC.', 'It', 'UNIVAC', 'I', 'Remington', 'Rand', 'Hopper', 'English', 'The', 'FLOW-MATIC', 'FLOW-MATIC', 'COBOL,', 'AIMACO', 'These', 'Edsger', 'Dijkstra,', 'Communications', 'ACM,', 'GOTO', 'C++', 'The', 'United', 'States', 'Ada,', 'Pascal', 'In', 'Japan', 'The', 'ML', 'Lisp.', 'Rather', 'Modula-2,', 'Ada,', 'ML', 'Internet', 'Perl,', 'Unix', 'Java', 'Pascal', 'These', 'C', 'Current', "Microsoft's", 'LINQ.\\n"b\'Fourth-generation', 'Fifth', 'These', 'Most', 'On', 'The', 'Since', 'Backus\\xe2\\x80\\x93Naur', 'Below', "Lisp:\\n'b'This", 'Many', 'In', 'Even', 'C', 'However,', 'Chomsky', 'The', 'Type-2', 'Some', 'Perl', 'Lisp,', 'Languages', 'In', "Lisp's", "Perl's", 'BEGIN', 'C', 'For', 'Examples', 'Many', 'Other', 'Newer', 'Java', 'C#', 'For', 'The', 'There', 'Natural', 'A', 'Results', 'The', 'Any', 'In', 'In', 'The', 'For', 'The', 'Many', 'These', 'REXX', 'SGML,', 'High-level', 'BCPL,', 'Tcl,', 'Forth.\\n\'b"In', 'Many', 'For', 'In', 'In', 'Most', 'C++,', 'C#', 'Java,', 'Complete', 'Haskell', 'ML.', 'However,', 'C++,', 'Java', 'C#', 'Additionally,', 'As', 'Among', 'However,', 'Lisp,', 'Smalltalk,', 'Perl,', 'Python,', 'JavaScript,', 'Ruby', 'This', 'An', 'Strongly', 'Perl', 'JavaScript,', 'In', 'JavaScript,', 'Array,', 'Such', 'Some', 'Thus', 'C', 'C', 'However,', 'This', 'C', 'Core', 'In', 'However,', 'Indeed,', 'For', 'Java,', 'Smalltalk,', 'BlockContext', 'Conversely,', 'Scheme', 'But', 'A', 'By', 'While', 'Many', 'Although', 'The', 'The', 'As', 'Because', 'This', 'However,', 'Edsger', 'W.', 'Dijkstra', 'Alan', 'Perlis', 'Hybrid', 'Structured', 'English', 'SQL.\\n\'b"A', 'The', 'There', 'It', 'In', 'For', 'BASIC', 'Here', 'Proprietary', 'Oracle', 'Corporation', 'Java', "Microsoft's", 'C#', 'Common', 'Language', 'Runtime', 'MATLAB,', 'VBScript,', 'Wolfram', 'Language.', 'Some', 'Erlang', "Ericsson's", 'When', 'However,', 'The', 'On', 'A', 'These', 'Programming', 'In', 'When', 'Unix', 'One', 'CPU', 'Some', 'For', 'COBOL', 'Fortran', 'Ada', 'C', 'Other', 'Java,', 'C,', 'C++,', 'Python,', 'C#,', 'JavaScript,', 'VB', 'R,', 'PHP,', "MATLAB.[73]\\n'b'A", 'With', 'Scheme', 'Forth,', 'In', 'In', 'Lisp', 'S-expression', 'Lisp-like', 'Lisp', 'Racket', 'Clojure.', 'As', 'The', 'BASIC', 'Forth', 'Forth...', 'Forth."\\n\'b\'There', 'A', 'Languages', 'Ideas', 'For', 'Java', 'Python', 'Traditionally,', 'These', 'A', 'More', 'An', 'By', 'Some', 'For', 'English', 'Other']
    

    如您所见,我们的基本规则提取了编程语言,但它也提取了垃圾数据。现在想想如何限制规则,或者如何加入一些约束,这样它会给我们一个准确的输出。那将是你的任务。
    用于校对应用程序的模式匹配规则的python
    现在,假设您想制作一个校对工具。所以,在这里,我将向您提供一个非常简单的错误,您可以很容易地在任何商业邮件或任何信件中发现。然后我们将尝试以高精度纠正错误。
    错误是人们在邮件中指定了会议时间,他们可能指定了时间为下午2pm, 2PM, 或 2P.M.或其他变体,但正确的格式是 2 p.m. 或 9 a.m.。
    这种错误可以通过基于模式的规则来修复。下面是规则逻辑。
    假设长度为2的数字从1到12开始。在这个数字之后,如果AM和PM发生时没有空格或句点,则添加空格和适当的句点符号。
    我将使用正则表达式来实现它。
    \b([1-9]|0[1-9]|1[0-2]{1,2})(am)\b
    \b([1-9]|0[1-9]|1[0-2]{1,2})(pm)\b

    import re
    
    inputstring = "Our meeting will be at 5pm tomorrow."
    # inputstring = "Our meeting will be schedule at 11am tomorrow."
    
    findpattern_am = re.search(r'\b([1-9]|0[1-9]|1[0-2]{1,2})(am)\b',
                               inputstring, re.M | re.I)
    findpattern_pm = re.search(r'\b([1-9]|0[1-9]|1[0-2]{1,2})(pm)\b',
                               inputstring, re.M | re.I)
    
    if findpattern_am:
        #print findpattern_am.group()
        print(re.sub(r'\b([1-9]|0[1-9]|1[0-2]{1,2})(am)\b', r'\1 a.m.', inputstring)) 
    elif findpattern_pm:
        #print findpattern_pm.group()
        print(re.sub(r'\b([1-9]|0[1-9]|1[0-2]{1,2})(pm)\b', r'\1 p.m.', inputstring)) 
    else:
        print("Not matched...!") 
    
    
    Our meeting will be at 5 p.m. tomorrow.
    

    给出的例子是一个基本的例子,但它有助于您思考如何进行校对。许多简单的规则集可以应用于数据,并且根据模式,您将得到正确的结果。

    7.6.3 语法更正

    我们将对一般现在时态的主语动词一致性规则做一个简单的规则。
    我们知道,在一般现在时态中,第三人称单数主语总是以一个s/es作为动词后缀的单数动词。

    He drink tomato soup in the morning
    She know cooking
    We plays game online

    from pycorenlp import StanfordCoreNLP
    from nltk.tree import Tree
    

    启动stanford-corenlp服务

    cd /media/zhou/数据/JavaLibraries/stanford-corenlp-full-2018-10-05
    java -mx4g -cp “*” edu.stanford.nlp.pipeline.StanfordCoreNLPServer

    nlp = StanfordCoreNLP('http://localhost:9000')
    
    leaves_list = []
    text = 'We know cooking.'
    
    output = nlp.annotate(text, properties={
        'annotators': 'tokenize,ssplit,pos,depparse,parse',
        'outputFormat': 'json'
    })
    
    parsetree = output['sentences'][0]['parse']
    
    
    #print parsetree
    for i in Tree.fromstring(parsetree).subtrees():
        if i.label() == 'PRP':
            #print i.leaves(), i.label()
            leaves_list.append(i.leaves())
        if i.label() == 'VBP' or i.label() == 'VBZ':
            #print i.leaves(), i.label()
            leaves_list.append(i.label())
    #print leaves_list
    if (any("We" in x for x in leaves_list) or any("I" in x for x in leaves_list) or any(
                    "You" in x for x in leaves_list) or any("They" in x for x in leaves_list)) and any("VBZ" in x for x in leaves_list):
        print("Alert: \nPlease check Subject and verb in the sentence.\nYou may have plural subject and singular verb. ") 
    elif(any("He" in x for x in leaves_list) or any("She" in x for x in leaves_list) or any(
                    "It" in x for x in leaves_list)) and any("VBP" in x for x in leaves_list):
        print("Alert: \nPlease check subject and verb in the sentence.\n" \
              "You may have singular subject and plural verb.") 
    else:
        print("You have correct sentence.") 
    
    
    You have correct sentence.
    

    7.6.2 基于模板的聊天机器人应用

    在这里,我们将看到如何为chatbot应用程序构建一个核心引擎,它可以帮助贷款申请人申请。我们正在以JSON格式生成输出,因此任何前端开发人员都可以将此输出集成到网站上。
    在这里,我使用flask Web框架,为我们的聊天机器人提出的每个问题提供Web服务。
    如果要保存用户数据,需要安装mongodb。MongoDB的安装步骤如下:https://docs.mongodb.com/manual/tutorial/install-mongodb-on-ubuntu/conversationengine.py是具有手工规则和代码的核心规则引擎。

    def start_converation_action(humanmessage):
    START_CONV_KEYWORDS = (“hello”, “hi”, “Hi”, “Hello”)
    START_CONV_RESPONSES = [
    “Please provide me borrower’s full name”]
    text = humanmessage
    start_res = “”
    if text.lower() in START_CONV_KEYWORDS:
    # start_res = random.choice(START_CONV_RESPONSES)
    start_conv_json_obj = json.dumps(
    {‘message_human’: text, ‘message_bot’: START_CONV_RESPONSES,
    ‘suggestion_message’: [“Please provide me borrower’s full name”],
    ‘current_form_action’: “/hi_chat?msg=”,
    ‘next_form_action’: “/asking_borowers_full_name?msg=”, ‘previous_form_action’: “/welcomemsg_chat”,
    ‘next_field_type’: “text”,
    ‘previous_field_type’: “button”, “placeholder_text”: “Enter borrower’s full name”,
    “max_length”: “255”},
    sort_keys=True, indent=4,
    separators=(’,’, ‘: ‘), default=json_util.default)
    elif text.lower() == “” or text.lower() is None or len(text) == 0:
    start_conv_json_obj = json.dumps({‘message_human’: text,
    ‘message_bot’: defualt_missing_data_error,
    ‘suggestion_message’: [“Hi”], ‘current_form_action’: “/hi_chat?msg”,
    ‘next_form_action’: “”, ‘previous_form_action’: “/welcomemsg_chat”,
    ‘next_field_type’: “”, ‘previous_field_type’: “button”,
    “placeholder_text”: “Hi”},
    sort_keys=True, indent=4,
    separators=(’,’, ‘: ‘), default=json_util.default)
    else:
    start_conv_json_obj = json.dumps({‘message_human’: text,
    ‘message_bot’: defualt_error,
    ‘suggestion_message’: [“Hi”], ‘current_form_action’: “/hi_chat?msg”,
    ‘next_form_action’: “”, ‘previous_form_action’: “/welcomemsg_chat”,
    ‘next_field_type’: “”, ‘previous_field_type’: “button”,
    “placeholder_text”: “Hi”
    },
    sort_keys=True, indent=4,
    separators=(’,’, ': '), default=json_util.default)
    return start_conv_json_obj在这里,我们使用关键字列表和响应列表来实现聊天机器人。我还定制了JSON模式来导出会话,如果您来自Web开发背景,那么您可以编写JavaScript,它将帮助您在前端用GUI显示这个JSON。现在,让我们看一下Web服务部分:

    @app.route(’/’)
    def hello_world():
    return ‘Hello from chat bot Flask…!’

    @app.route("/welcomemsg_chat")
    def welcomemsg_chat():
    welcome_msg = cs.loan_assistant_welcome_msg()
    conversation_list_history.append(welcome_msg)
    # db_handler = mongo.db.chathistory
    # db_handler.insert({“request_user_id”: request_user_id, “conversation”: conversation_list_history,
    # “time”: now_india.strftime(fmt)})
    # db_handler.update({“request_user_id”: request_user_id}, {
    # 'KaTeX parse error: Expected 'EOF', got '#' at position 125: …ime(fmt)}, #̲ "currentDate": {“lastModified”: True}}, upsert=True)
    resp = Response(welcome_msg, status=200, mimetype=‘application/json’)
    return resp
    现在,要运行脚本并查看输出,请执行以下步骤:
    1、第一次运行flaskengin.py
    2、转到http://127.0.0.1:5002//,在这里您可以从chatbot flask看到Hello from chatbot Flask!
    3、您可以查看chatbot json响应:http://127.0.0.1:5002/welcomemsg_chat
    4。您可以看到JSON响应:

    {
    “current_form_action”: “/welcomemsg_chat”,
    “message_bot”: [
    “Hi, I’m personal loan application assistant.”,
    “You can apply for loan with help of mine.”,
    “To keep going say Hi to me.”
    ],
    “message_human”: “”,
    “next_field_type”: “button”,
    “next_form_action”: “/hi_chat?msg=”,
    “placeholder_text”: “Hi”,
    “previous_field_type”: “”,
    “previous_form_action”: “”,
    “suggestion_message”: [
    “Hi”
    ]
    }

    5、现在,向我们的人类用户提供建议,帮助他们分析预期的输入是什么。因此,在这里,您可以看到json属性建议消息:[“hi”]。因此,用户将看到带有Hi标签的按钮。
    6、如果要重定向到下一页或下一个问题,请使用next_form_action并将用户参数放在msg=USER ARGUMENT
    7、例如,在http://127.0.0.1:5002/welcomemsg_chat页面。现在,您可以阅读消息“机器人”。它说你需要向机器人打招呼
    8、您可以这样回复:http://127.0.0.1:5002/hi_chat?msg=Hi
    9、当你输入这个网址: http://0.0.0.0:5002/hi_chat?msg=Hi 你可以看到机器人会问你的名字,现在你需要输入你的名字。
    10、要输入您的姓名并重定向到下一个问题,您需要再次检查下一个“表单”动作属性的URL值
    11、这里的值是/asking_borowers_email_id?msg=
    12、你需要在=符号后加上你的名字,这样URL就变成了
    /asking_borowers_email_id?msg=Jalaj Thanaki
    13、当你使用http://0.0.0.0:5002/asking_borowers_full_name?msg=Jalaj%20Thana
    ki,您可看到下一个问题。
    14、首先,您需要运行脚本:flaskengin.py,然后您可以检查以下URL:
    http://127.0.0.1:5002/welcomemsg_chat
    http://127.0.0.1:5002/hi_chat?msg=Hi
    http://127.0.0.1:5002/asking_borowers_full_name
    msg=Jalaj%20Thanaki
    http://127.0.0.1:5002/asking_borowers_email_id?msg=jalaj@gmai
    l.com
    http://127.0.0.1:5002/mobilenumber_asking?msg=9425897412
    http://127.0.0.1:5002/loan_chat?msg=100000
    http://127.0.0.1:5002/end_chat?msg=Bye
    基于模板的聊天机器人的优势
    易于实施。

    节省时间和成本。

    用例在开发之前就已经被理解了,所以用户体验也会很好。这是一种模式匹配方法,所以如果用户在他们的对话中使用英语和其他语言,那么用户也会得到答案,因为chatbot识别出他用英语提供的关键字,如果英语关键字与chatbot词汇匹配,那么chatbot不能给你答案。
    基于模板的聊天机器人的缺点
    它不能用于未发现的用例

    用户应该处理严格的对话流

    用户拼写错误会给聊天机器人带来问题。在这种情况下,我们将使用深度学习

    7.7 规则式系统与其他方法的对比

    基于规则的方法是一个非常可靠的引擎,它为您的应用程序提供了高精度。当您将RB方法与ML方法或深度学习方法进行比较时,您会发现以下几点:

    • 对于RB方法,您需要领域专家,而对于ML方法或深度学习方法,您不需要领域专家。
    • RB系统不需要大量的数据,而ML和深度学习则需要大量的数据。
    • 对于RB系统,您需要手动查找模式,而ML和深度学习技术则根据数据和输入特性代表您查找模式。
    • RB系统通常是开发最终产品的第一次切割的好方法,这在实践中仍然很流行。

    7.8 规则式系统的优点

    可用性:系统对用户的可用性不是问题
    成本效益:该系统在最终结果方面具有成本效益和准确性。
    速度:您可以优化系统,因为您知道系统的所有部分。所以在几秒钟内提供输出不是一个大问题
    准确度和错误率:尽管不同场景的覆盖率较低,但RB系统覆盖的任何场景都将提供较高的准确度。由于这些预先定义的规则,错误率也较小
    降低风险:我们正在降低系统准确性方面的风险。
    稳定响应:系统产生的输出依赖于规则,因此输出响应是稳定的,这意味着它不能含糊不清。
    与人类相同的认知过程:这个系统为你提供与人类相同的结果,就像人类手工制作的一样。
    模块化:RB系统的模块化和良好的体系结构可以帮助技术团队轻松维护。这减少了人类的努力和时间
    一致性:RB系统在实现和输出方面非常一致。这使得最终用户的生活更容易,因为系统的输出很容易被人理解。
    易于实现:这种方法模拟了人类的思维过程,因此对于开发人员来说,规则的实现相对容易。

    7.9 规则式系统的缺点

    大量的手工工作:RB系统需要对领域有深入的了解,也需要大量的手工工作。

    耗时:为复杂系统生成规则非常困难且耗时

    学习能力不足:在这里,系统会根据规则生成结果,因此系统本身的学习能力要少得多。

    复杂域:如果要构建的应用程序过于复杂,则构建RB系统可能需要花费大量时间和分析。在RB方法中,复杂模式识别是一项具有挑战性的任务。

    7.10 规则式系统面临的挑战

    模仿人类的行为是不容易的。

    选择或设计体系结构是RB系统的关键部分。

    为了开发RB系统,您需要成为为我们生成规则的特定领域的专家。对于NLP,我们需要知道如何分析语言的语言学家。

    自然语言本身就是一个具有挑战性的领域,因为它有如此多的异常情况,并且使用规则覆盖这些异常也是一个具有挑战性的任务,特别是当您拥有大量规则时。

    阿拉伯语、古吉拉特语、印地语和乌尔都语很难在RB系统中实现,因为寻找这些语言的领域专家是一项困难的任务。对于所描述的语言,实现规则的工具也较少。

    人类努力的时间消耗太高。

    7.11 词义消歧的基础

    词义消歧(wsd)是NLP中的一个著名问题。首先,让我们了解什么是WSD。当一个句子中的一个词有多种含义时,WSD用来识别这个词的意义。当一个单词有多个意思时,机器很难识别正确的意思,要解决这个具有挑战性的问题,我们可以使用基于规则的系统或机器学习技术。当你试图解决任何语言的wsd问题时,你需要有大量的数据,在这些数据中,你可以找到不同句子意义不同的单词实例。

    一旦你有了这样的数据集,人类专家就会出现。

    人类专家被用来标记一个或多个单词的含义,通常标记有一些预定义的ID。现在,让我们举个例子:我有句话:我去了河岸,我去了银行存款。在前面的句子中,单词bank有多种含义,其含义根据整个句子而变化。所以,人类专家被用来标记这些单词。这里,我们的话是银行

    因此,人类专家使用预先定义的ID。假设现在ID为100

    在第二句中,单词bank通过使用预定义的ID被标记为金融机构。现在假设ID为101。

    一旦给出了这个标签,下一个阶段就开始了,即选择基于规则的引擎或受监控的机器学习技术。

    如果我们决定采用基于规则的系统,那么人类专家需要想出一个或多个特定的模式或规则来帮助我们消除词义的歧义。

    有时,对于某些单词,专家可以通过使用解析结果或使用词性标注来找到规则,但在大多数情况下,他们不能

    因此,如今,一旦标记完成,标记数据就被用作输入,以开发一个有监督的机器学习模型,帮助人类识别单词。

    有时,只有基于规则的系统不能以同样的方式工作,只有机器学习方法有时不能帮助您。根据我的经验,这是同一种情况。我认为混合方法会给你一个更好的结果

    在标记数据之后,我们应该构建一个RB系统,它可以很好地处理已知的情况,并且我们也有一个不能定义规则的情况。为了解决这个问题,我们需要建立一个机器学习模型。

    您还可以使用矢量化概念和深度学习模型来解决WSD问题。通过深入学习,您对WSD的研究也可以成为一个研究课题。

    7.12 规则式系统近期发展的趋势

    本节讨论当前市场如何使用RB系统。很多人在不同的论坛上问了很多问题,他们想知道RB系统的未来,所以我想和你讨论一个重要的问题

    帮助您了解NLP市场和RB系统的未来趋势。我有一些问题要问。

    RB系统在NLP领域是否过时?我想不回答这个问题。RB系统主要用于所有NLP应用程序、语法更正、语音识别、机器翻译等!当您开始创建任何新的NLP应用程序时,此方法是第一步。如果你想试验你的想法,那么原型可以很容易地在RB方法的帮助下开发。对于原型设计,您需要领域知识和基本的编码技能。你不需要知道高级数学或ML技术。对于基本的原型设计,您应该使用RB系统。深度学习和基于ML的方法能否取代基于RB的系统?这个问题是一个非常开放的问题。我想在这一点上提出一些事实,这将有助于你提出你的问题。现在,我们有大量的数据,我们有廉价的计算能力。人工智能产业和基于人工智能的项目正在引起很多关注。前两点有助于深度学习和ML方法,以获得NLP和其他人工智能应用程序的准确结果。与RB系统相比,这些方法需要更少的人力。这就是为什么这么多人认为RB系统不会被深度学习和基于ML的系统所取代的原因。我认为RB系统不会完全被替换,但它将补充这些方法。现在你问,怎么做?所以,答案是,我想我想采用混合方法,这对我们更有利。我们可以在ML系统的帮助下找到模式或预测,然后将这些预测提供给RB系统,RB系统可以验证预测并为用户选择最佳的预测。这实际上将帮助我们克服RB系统的一个主要挑战,即减少人力和时间。

    对于前面的问题,没有任何正确或错误的答案。它是关于如何看到问题和NLP域的。我只想给你留个想法。想一想,想一想你自己的答案。

    7.13 总结

    在这一章中,我们看到了与基于规则的系统相关的所有细节,以及基于规则的方法如何帮助我们以高精度开发复杂问题的快速原型。我们已经看到了基于规则的系统的体系结构。我们已经了解了基于规则的系统的优点、缺点和挑战。我们已经看到这个系统如何帮助我们开发NLP应用程序,如语法修正系统、聊天机器人等。我们还讨论了基于规则的系统的最新趋势。

    在下一章中,我们将学习其他称为机器学习的主要方法,以解决NLP应用程序。下一章将详细介绍开发NLP应用程序需要使用的机器学习算法。我们将看到有监督的ML、半监督的ML和无监督的ML技术。我们也会

    从头开始开发一些应用程序。所以继续阅读!

    这是自动驾驶汽车考试

    致谢
    《Python自然语言处理》1 2 3,作者:【印】雅兰·萨纳卡(Jalaj Thanaki),是实践性很强的一部新作。为进一步深入理解书中内容,对部分内容进行了延伸学习、练习,在此分享,期待对大家有所帮助,欢迎加我微信(验证:NLP),一起学习讨论,不足之处,欢迎指正。
    在这里插入图片描述

    参考文献


    1. https://github.com/jalajthanaki ↩︎

    2. 《Python自然语言处理》,(印)雅兰·萨纳卡(Jalaj Thanaki) 著 张金超 、 刘舒曼 等 译 ,机械工业出版社,2018 ↩︎

    3. Jalaj Thanaki ,Python Natural Language Processing ,2017 ↩︎

    展开全文
  • Python自然语言处理-BERT模型实战

    千人学习 2019-10-21 21:54:40
    购买课程后,添加小助手微信(微信号:itxy41)回复【唐宇迪】 进入学习群,获取唐宇迪老师答疑 Python自然语言处理-BERT模型实战课程旨在帮助同学们快速掌握当下NLP领域最核心的算法模型BERT的原理构造与应用实例。...
  • 自然语言处理入门学习系列<一>

    千次阅读 2016-12-06 22:27:28
    最近在学习和实践自然语言处理相关的知识,在这个文档从头到尾做个总结,防止自己忘记,也提供给新人来参考。本教程英文处理使用的是NLTK这个Python库,中文处理使用的是jieba这个Python库,主要是看July7月学习NLP...

    最近在学习和实践自然语言处理相关的知识,在这个文档从头到尾做个总结,防止自己忘记,也提供给新人来参考。本教程英文处理使用的是NLTK这个Python库,中文处理使用的是jieba这个Python库,主要是看July7月学习NLP视频学习而来,如有侵权,立即删除。Natural Language Processing(NLP)自然语言处理主要是处理以及理解自然语言的计算过程。整个自然语言处理的大致流程入下图所示:
    这里写图片描述
    图1:自然语言处理流程
    一、自然语言处理流程
    第一步:Tokenize——分词,分词是将一个句子分成很多个单词,用一个word list存起来。如:
    英文:How are you today? 会分成 [“How”,”are”,”you”,”today”,”?”]
    中文:今天心情很好。 会分成[“今天”,”心情”,”很”,”好”,”。”]
    第二步: Stemming/Lemma——提取词干,是将英文的过去式,名词形式,复数形式全部转换为最原始单词。如:
    apples => apple, went => go, watched => watch, watching => watch
    第三步:stopwords ——去除停止词,去掉单词列表中的停止词the,a等单词。如:
    英文: The school is beautiful. => [“school”,”beautiful”],去掉了the,is等单词。
    有时会用到POS Tag —— 标注词性,即标注出单词是动词/名词/形容词/副词等。
    第四步:Get feature —— 提取特征,这个步骤的意思是用一个什么样的向量来表示这单词或者句子。如使用TF-IDF来表示一个单词:
    TF:Term Frequecy:衡量一个单词在文档中出现的次数
    TF(term) = (term出现在文档中的次数)/(文档中单词的总数)
    IDF:Inverse Document Frequecy,衡量一个单词的重要性
    IDF(term) = loge(文档总数/含有term的文档总数)
    如果一个单词在所有文档中都出现了,则IDF(term) = 0,表明这个单词不重要。
    TF-IDF = TF * IDF
    对每个单词进行统计和计算,就可以得到每个单词的TF-IDF的值,用这个值来代替这个单词,整个句子就变成了一个浮点数的List。
    当然这个是最简单的模型,这个模型有很多缺陷,现在流行的word2vect和fasttext,都是由google实习生写出来的,这两个模型生成的分布式向量可以有效的表达出两个单词之间的关系,这个在后续再做介绍。
    第五步:Machine Learning——机器学习,机器学习是表示得到特征向量之后,能根据训练集合来预测需要测试集合。这个部分也在后续再做专门的介绍。
    二、自然语言处理入门软件安装以及常见问题
    整个实验环境是在VMWare+Ubuntu 16.04 LTS下完成的,最好是能翻墙,我用的翻墙软件是LoCo加速器。
    NLTK 安装
     安装pip
    安装pip,一个python第三方软件的库,apt-get是获得软件或者库
    sudo apt-get install python-pip python-dev build-essential
     问题1,可能会碰到的问题: install的时候碰到Could not get lock /var/lib/dpkg/lock,无法Install
    解决方案:找到哪个线程锁住了这个资源,然后Kill掉,指令:
    sudo lsof /var/lib/dpkg/lock
    sudo kill -9 (get from lsof output)
     更新pip这个库
    sudo pip install –upgrade pip
     安装nltk库,用于自然语言处理。
    sudo pip install -U nltk
     安装numpy库
    sudo pip install -U numpy
     下载nltk所有相关东西(语料库,模型等)
    python
    import nltk
    nltk.download(‘all’)
     Python Debug使用
    import pdb
    在需要断点的地方 pdb.set_trace()
    h Help
    q Quit
    p Print
    Pp Prettyprint
    w Where+stack trace 执行到了什么地方
    l 断点前后的代码
    n 执行下一句
    b 35 在第35行断点
    变量名称 打印出变量的值是多少
    c continue until break
    s step inside
     使用VIM做IDE,可能需要配置和Python相关的信息,在.vrmrc中进行配置,第一次需要新建这个文件,如果需要添加插件,则先在.vimrc中进行配置,然后使用vim,输入:PluginInstall来在Vim上安装指定插件。
     问题2:运行pandas.test报错:
    运行numpy.test()或者pandas.test()出现如下错误
    ImportError: Need nose >= 1.0.0 for tests - see http://somethingaboutorange.com/mrl/projects/nose
    需要先安装nose,sudo pip install nose
     问题3:pandas 从0.19.0开始不再支持pandas.io.wb,改用pandas_datareader,这个python库需要先行下载,sudo pip install pandas_datareader
    Starting in 0.19.0, pandas will no longer support pandas.io.data or pandas.io.wb, so you must replace your imports from pandas.io with those from pandas_datareader:
    from pandas.io import data, wb # becomes
    from pandas_datareader import data, wb
    Many functions from the data module have been included in the top level API.
    import pandas_datareader as pdr
    pdr.get_data_yahoo(‘AAPL’)
     问题4:使用matplotlibc出现错误
    ImportError: No module named _tkinter, please install the python-tk package
    需要安装python-tk安装包
    sudo apt-get install python-tk
     问题5:vim添加Python支持
    1、Ctrl+Alt+T 打开命令终端,输入: vim –version |grep python 查看vim是否支持python我这个vim只支持python3,不支持python。
    2、安装py2包,在命令终端下输入: sudo apt-get install vim-nox-py2。
    3、可以再次用vim –version|grep python 查看此时vim是否支持python,若支持到此为止,若不支持,请执行第四步。
    4、在命令终端输入:sudo update-alternatives –config vim
    这里写图片描述
    我这里是第三项属于python,第二项属于python3,想打开哪一项支持就输入它的编号就可以了(0,1,2,3)。

    其他资料的使用:
     matplotlin画图软件,画二维图可以使用这个工具,功能和matlab画图类似 sudo pip install matplotlib,结合pandas使用
    API使用文档:
    http://matplotlib.org/1.5.3/users/beginner.html
     pandas-datareader:从yahoo Finance,google API 上下载相关信息,具体使用API如下
    https://pandas-datareader.readthedocs.io/en/latest/
     python一些常见库的入门指导材料,可以加快学习的速度:
    https://pythonprogramming.net/
     美国金融方面的数据,房价/股票等信息,已经格式化好了,容易处理的数据:
    https://www.quandl.com/
     pandas入门资料:
    http://pandas.pydata.org/pandas-docs/stable/10min.html
    三、自然语言处理实践
    实践的题目是Kaggle上的一道竞赛题目,
    链接:https://www.kaggle.com/c/home-depot-product-search-relevance, Home Depot是美国一家网上卖五金的公司,在用户输入修洗脸盆的时候,希望能提供给用户所有洗脸盆需要的五金和工具。
    给出了五组数据:
    产品属性:
    “product_uid”,”name”,”value”
    100001,”Bullet01”,”Versatile connector for various 90° connections and home repair projects”
    产品描述:
    “product_uid”,”product_description”
    100001,”Not only do angles make joints stronger, they also provide more consistent, straight corners. Simpson Strong-Tie offers a wide variety of angles in various sizes and thicknesses to handle light-duty jobs or projects where a structural connection is needed. Some can be bent (skewed) to match the project. For outdoor projects or those where moisture is present, use our ZMAX zinc-coated connectors, which provide extra resistance against corrosion (look for a “”Z”” at the end of the model number).Versatile connector for various 90 connections and home repair projectsStronger than angled nailing or screw fastening aloneHelp ensure joints are consistently straight and strongDimensions: 3 in. x 3 in. x 1-1/2 in.Made from 12-Gauge steelGalvanized for extra corrosion resistanceInstall with 10d common nails or #9 x 1-1/2 in. Strong-Drive SD screws”
    测试集:
    “id”,”product_uid”,”product_title”,”search_term”
    1,100001,”Simpson Strong-Tie 12-Gauge Angle”,”90 degree bracket”
    训练集合:
    “id”,”product_uid”,”product_title”,”search_term”,”relevance”
    2,100001,”Simpson Strong-Tie 12-Gauge Angle”,”angle bracket”,3
    提交的样本:
    “id”,”relevance”
    1,1
    Relevance是表示选出工具和输入搜索关键词之间的相关性,相关性=3表示非常相关,相关性=1表示不太相关。
    第一步:数据清洗
     用pandas读取csv中的数据,因为数据过大,没法一次读取出来进行处理,每次处理10000条,处理完1次就放到另外一个csv文件中存储起来。
     处理的过程是将英文用nltk的stemming方法对每个单词进行提取词干。
     只有第一次写入csv文件的时候需要写入header,且不需要index。Header表示表头。
    这里写图片描述
    这里写图片描述

    处理完成之后产品描述变成如下的样子,训练数据和测试数据类似处理:
    product_uid,product_description
    100001,”not onli do angl make joint stronger, they also provid more consi stent, straight corners. simpson strong-ti offer a wide varieti of angl i n various size and thick to handl light-duti job or project where a struc tur connect is needed. some can be bent (skewed) to match the project. fo r outdoor project or those where moistur is present, use our zmax zinc-co at connectors, which provid extra resist against corros (look for a “”z”” at the end of the model number).versatil connector for various 90 connec t and home repair projectsstrong than angl nail or screw fasten alonehelp ensur joint are consist straight and strongdimensions: 3 in. x 3 in. x 1 -1/2 in.mad from 12-gaug steelgalvan for extra corros resistanceinstal wi th 10d common nail or #9 x 1-1/2 in. strong-driv sd screw”
    注意事项:
     使用chunk_size进行分块读入
     使用iterrows 一行一行读入数据
     使用final_df[“column”] = A新增加一列,A可以是一个list
     to_csv的header设置来表示是否需要表格头
     注意编码是ISO-8859-1
    第二步:提取特征
    假设使用搜索关键词在产品名字和产品描述中出现的最大次数来表示这个搜索关键词的两个主要特征,搜索关键词的长度表示另外一个特征。
    这里写图片描述
    注意事项:
     数据连接之后可能会出现NaN的字符,Python会默认为float类型的无穷大,需要通过pd.isnull(a)来判断下是否为空。
    第三步:使用机器学习来预测,加博士是用的随机森林来进行relevance的预测,后续章节会继续深入讨论。
    未完,待续。

    展开全文
  • Tensorflow-自然语言处理

    千人学习 2018-04-01 09:52:29
    课程以Tensorflow作为机器学习的核心武器,基于自然语言处理热点话题进行案例实战。选择当下热门模型,使用真实数据集进行实战演示,通俗讲解整个算法模型并使用tensorflow进行实战,详解其中的原理与代码实现。
  • 自然语言处理实战 TextCNN文本分类

    千人学习 2020-06-26 17:47:20
    适用人群 (1)想要从事NLP的在校学生、NLP研发工程师 (2)自然语言处理从业者、深度学习爱好者 课程简介 短文本分类作为自然语言处理的基础技术之一NLP领域的热门应用,常用在对话语言平台,文章分类,智能客服,FAQ...
  • 自然语言处理动手学Bert文本分类

    千人学习 2020-05-30 09:41:43
    Bert作为目前自然语言处理领域最流行的技术之一,文本分类作为自然语言处理领域最常见的任务之一,Pytorch作为目前最流程的深度学习框架之一,三者结合在一起将会产生什么样的花火,本套课程基于Pytorch最新1.4版本...
  • 技术书籍,内容主要涉及编程,算法,机器学习,深度学习,自然语言处理,数学及网络等。 持续更新。 算法 (algorithm) 1、剑指offer 名企面试官精讲典型编程题 2、十五个经典算法研究与总结 3、算法图解 4、python...
  • 零基础Python人工智能自然语言处理文本挖掘关键词提取:零基础入门学习自然语言处理自然语言处理基本流程,文本挖掘基本处理流程,anaconda对Python项目多包多环境多版本管理,关键词提取算法TF-IDF/TextRank算法...
  • HanLP是一系列模型与算法组成的NLP工具包,由大快搜索主导并完全开源,目标是普及自然语言处理在生产环境中的应用。 HanLP具备功能完善、性能高效、架构清晰、语料时新、可自定义的特点。 HanLP提供下列功能: 中文...
  • 适用人群: 自然语言处理从业者、深度学习爱好者 课程简介: 命名实体识别作为自然语言处理的基础技术之一,在自然语言处理上游各个任务(问答系统、机器翻译、对话系统等)重扮演者十分重要的角色,因此深入掌握...
  • 课程目标 学习完本门课程,您将对自然语言处理技术有更深入的了解, 掌握基于深度学习情感分析方法;课程基于PyTorch主流框架实现,其中涉及深度学习主流框架LSTM模型以及自然语言处理的词向量;彻底掌握中文情感分析...
  • MATLAB已成为适合多学科、多种工作平台的功能强大、界面友好、语言自然并且开放性强的大型优秀应用软件,同时也已成为国内外高等院校高等数学、数值分析、数字信号处理、自动控制理论以及工程应用等课程的基本教学...
  • 自然语言处理Word2Vec视频学习教程

    万人学习 2017-06-21 22:39:12
    自然语言处理Word2Vec视频培训课程:自然语言处理中重要的算法,word2vec原理,词向量模型。教程从语言模型入手,详解词向量构造原理与求解算法。理论与实战结合,使用深度学习框架Tensorflow从零开始打造word2vec词...
  • 适用人群: 自然语言处理从业者、深度学习爱好者 课程简介: 命名实体识别作为自然语言处理的基础技术之一,在自然语言处理上游各个任务(问答系统、机器翻译、对话系统等)重扮演者十分重要的角色,因此深入掌握...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,087
精华内容 4,034
关键字:

matlab自然语言处理

matlab 订阅