精华内容
下载资源
问答
  • 运用灰色关联分析法,计算并优选了加速氧化阶段可信度较高的标志气体。获得了吉宁煤矿2号煤层煤自燃的复合预测指标,即缓慢氧化阶段以CO为主,加速氧化阶段以C2H4为主,激烈氧化阶段以C2H2为预测的主指标。
  • 编译原理实验:词法分析

    万次阅读 多人点赞 2018-09-29 21:17:16
    编译原理实验:词法分析1. 实验题目:词法分析实验目的实验内容实验要求输入输出2. 设计思想3.算法流程4. 源程序5. 调试数据 1. 实验题目:词法分析 实验目的 根据PL/0语言的文法规范,编写PL/0语言的词法分析...

    1. 实验题目:词法分析

    实验目的

    1. 根据PL/0语言的文法规范,编写PL/0语言的词法分析程序;或者调研词法分析程序的自动生成工具LEX或FLEX,设计并实现一个能够输出单词序列的词法分析器。
    2. 通过设计调试词法分析程序,实现从源程序中分出各种单词的方法;加深对课堂教学的理解;提高词法分析方法的实践能力。
    3. 掌握从源程序文件中读取有效字符的方法和产生源程序的内部表示文件的法。
    4. 掌握词法分析的实现方法。上机调试编出的词法分析程序。

    实验内容

     已给PL/0语言文法,输出单词符号(关键字、专用符号以及其它标记)。

    实验要求

    1. 把词法分析器设计成一个独立一遍的过程。
    2. 词法分析器的输出形式采用二元式序列,即:(单词种类,单词的值)

    输入输出

    输入:
      const a=10;
      var b,c;
      begin
      read(b);
      c:=a+b;
      write( c);
      end.
    输出:
      (constsym, const)
      (ident , a)
      (eql, =)
      (number, 10)
      (semicolon, ; )
      (varsym, var)
      (ident,b)
      (comma, ,)
      (ident, c)
      (semicolon, ; )
      (beginsym, begin)
      (readsym, read )
      (lparen,( )
      (ident, b)
      (rparen, ))
      (semicolon, ; )
      (ident, c)
      (becomes, := )
      (ident, a)
      (plus, +)
      (ident,b )
      (semicolon, ; )
      (writesym,write)
      (lparen, ( )
      (ident, c)
      (rparen,) )
      (endsym, end )
      (period, .)

    2. 设计思想

    基本字:

    单词(编码)正规式r
    begin(beginsym)begin
    call(callsym)call
    const(constsym)const
    do(dosys)do
    end(endsym)end
    if(ifsym)if
    odd(oddsym)odd
    procedure(proceduresym)procedure
    read(readsym)read
    var(varsym)var
    while(whilesym)while
    write(writesym)write
    then(thensym)then

    标识符:

    单词(编码)正规式r
    <标识符>(ident)(字母)(字母 |数字)*

    常数:

    单词(编码)正规式r
    <常数>(ident)(数字)(数字)*

    运算符:

    单词(编码)正规式r
    +(plus)+
    -(minus)-
    *(times)*
    /(slash)/
    =(eql)=
    <>(neq)<>
    <(lss)<
    <=(leq)<=
    >(gtr)>
    >=(geq)>=
    :=(becomes):=

    界符:

    单词(编码)正规式r
    ( (lparen)(
    ) (rparen))
    , (comma),
    ; (semicolon);
    . (period).

    3.算法流程

    在这里插入图片描述

    1. 词法分析程序打开源文件,读取文件内容,直至遇上文件结束符,然后读取结束。
    2. 接下来就要对源文件从头到尾进行扫描了,从头开始扫描,这个时候扫描程序首先要询问当前的字符是不是空格,若是空格,则继续扫描下一个字符,直至不是空格。然后询问这个字符是不是字母,若是则进行标识符和保留字的识别;若这个字符为数字,则进行数字的判断。否则,依次对这个字符可能的情况进行判断(界符和运算符),若将所有可能都走了一遍还是没有知道它是谁,则认定为错误符号,输出该无法识别error,程序结束。每次成功识别了一个单词后,单词都会存在word1[]数组中,然后字符指针往后移,进行下一个单词的识别。
    3. 主控程序需要负责对每次识别的种别码进行判断,对于不同的单词种别做出不同的反应,直至文件结束。
    4. 本次实验我采用了map这个STL关联容器,主要是考虑到词法分析中的数据映射的关系,因此采用这种结构。map提供一对一的数据处理能力,其中第一个可以称为关键字,每个关键字只能在map中出现一次,第二个可能称为该关键字的值。这个容器是非常方便使用的,对于查找可以直接使用迭代器进行,利用find()函数,若一直到末尾都未找到,则是不能识别或为标识符。

    4. 源程序

    #include<bits/stdc++.h>
    using namespace std;
    map<string,string> word;//应用map数据结构形成一个string->string的对应
    std::map<string,string>::iterator it;//用来遍历整个对应关系的迭代器
    void map_init(){//对应关系进行初始化
        word["begin"]="beginsym";
        word["call"]="callsym";
        word["const"]="constsym";
        word["do"]="dosym";
        word["end"]="endsym";
        word["if"]="ifsym";
        word["odd"]="oddsym";
        word["procedure"]="proceduresym";
        word["read"]="readsym";
        word["then"]="thensym";
        word["var"]="varsym";
        word["while"]="whilesym";
        word["write"]="writesym";
        word["+"]="plus";
        word["-"]="minus";
        word["*"]="times";
        word["/"]="slash";
        word["="]="eql";
        word["<>"]="neq";
        word["<"]="lss";
        word["<="]="leq";
        word[">"]="gtr";
        word[">="]="geq";
        word[":="]="becomes";
        word["("]="lparen";
        word[")"]="rparen";
        word[","]="comma";
        word[";"]="semicolon";
        word["."]="period";
    }
    int main(){
        map_init();//初始化
        char ch;
        char a;
        string word1;//string变量识别单词
        string str;//string变量进行字符识别
        ifstream infile("F:\\编译原理\\第一次实验\\analysis.txt");//文件输入流
        ofstream outfile("F:\\编译原理\\第一次实验\\result.txt");//文件输出流
        ostringstream buf;
        while(buf&&infile.get(ch)) buf.put(ch);//将文件中的字符读出来
        str= buf.str();//将得到的字符储存到string类型变量中
        int csize=str.length();
        for(int i=0;i<csize;i++){//对整个字符串进行遍历
            while(str[i]==' '||str[i]=='\n') i++;//若最开始为空格或换行符,则将指针的位置往后移
            if(isalpha(str[i])){//对标识符和基本字进行识别,调用库函数isalpha()
                word1=str[i++];
                while(isalpha(str[i])||isdigit(str[i])){
                    word1+=str[i++];
                }
                it=word.find(word1);
                if(it!=word.end()){//判断是不是基本字,若为基本字则进行输出
                    cout<<"("<<word[word1]<<","<<word1<<")"<<endl;
                }
                else{//否则直接输出
                    cout<<"(ident"<<","<<word1<<")"<<endl;
                }
                i--;
            }
            else if(isdigit(str[i])){//判断是不是常数,调用库函数isdigit()
                word1=str[i++];
                while(isdigit(str[i])){
                    word1+=str[i++];
                }
                if(isalpha(str[i])){
                    cout<<"error!"<<endl;
                    break;
                }
                else{
                    cout<<"(number"<<","<<word1<<")"<<endl;
                }
                i--;
            }else if(str[i]=='<'){//对<,<=分别进行判断
                word1=str[i++];
                if(str[i]=='>'){
                    word1+=str[i];
                    cout<<"("<<word[word1]<<","<<word1<<")"<<endl;
                }else if(str[i]=='='){
                    word1+=str[i];
                    cout<<"("<<word[word1]<<","<<word1<<")"<<endl;
                }else if(str[i]!=' '||!isdigit(str[i])||!isalpha(str[i])){
                    cout<<"("<<word[word1]<<","<<word1<<")"<<endl;
                }else{
                    cout<<"error!"<<endl;
                    break;
                }
                i--;
            }else if(str[i]=='>'){//对>,>=分别进行判断
                word1=str[i++];
                if(str[i]=='='){
                    word1+=str[i];
                    cout<<"("<<word[word1]<<","<<word1<<")"<<endl;
                }else if(str[i]!=' '||!isdigit(str[i])||!isalpha(str[i])){
                    cout<<"("<<word[word1]<<","<<word1<<")"<<endl;
                }else{
                    cout<<"error!"<<endl;
                    break;
                }
                i--;
            }else if(str[i]==':'){//对:=进行判断
                word1=str[i++];
                if(str[i]=='='){
                    word1+=str[i];
                    cout<<"("<<word[word1]<<","<<word1<<")"<<endl;
                }else{
                    cout<<"error!"<<endl;
                    break;
                }
                i--;
            }else{//对其他的基本字依次进行判断
                word1=str[i];
                it=word.find(word1);
                if(it!=word.end()){
                    cout<<"("<<word[word1]<<","<<word1<<")"<<endl;
                }else{
                    cout<<"error!"<<endl;
                    break;
                }
            }
        }
        infile.close();
        return 0;
    }
    

    5. 调试数据

    待输入的文件流:
    在这里插入图片描述
    输出数据:
    在这里插入图片描述
    在这里插入图片描述
    说明:如上实验仅符合当时实验要求的相关条件,其他的需求略微进行更改就行,思想是一样的,还是很简单的。输入输出自己按自己需求更改即可。

    展开全文
  • 灰色关联分析法是一种描述元素之间影响程度的分析法,适合于小项目数据集。小项目数据集制约着传统的软件缺陷...通过实验分析对比,验证了在灰色关联分析法的基础上,提出的软件缺陷类型预测方法的准确性和可靠性。
  • 以确定煤自然发火指标气体为目标,设计并研制自然发火模拟试验装置,采用理论分析实验研究相结合的研究方法,以灰色理论为基础,根据灰色关联分析理论建立模型,并通过实验及理论分析,研究和计算煤自然发火指标气体与煤...
  • 鉴于目前以CO、C2H4和C2H2为标志性气体已不能满足煤层自然发火的早期预测预报,以神华新疆能源公司碱沟煤矿B2煤层自然发火标志气体产物测试数据为例,选取100~300℃煤样氧化产物浓度,运用灰色关联法计算分析煤体升温...
  • 该方法分为三个阶段,分别基于分形模型、改进的最大距离聚类和Apriori算法进行分段、聚类和时序分析,最终从用户的数据交换中获知用户的行为规律。实验表明,该方法在无法获知用户消息的具体内容的前提下,仍能...
  • 关联分析之Apriori算法

    千次阅读 2017-11-08 14:03:41
    本文demo源码、实验数据:传送门引言如题,关联分析这个词语对于初学者而言或许比较陌生。但是我若将关联分析换成另一个短语“尿布与啤酒”大家就会很熟悉了。据报道,美国中西部的一家连锁店发现,男人们会在周四...

    本文demo源码、实验数据:传送门

    引言

    如题,关联分析这个词语对于初学者而言或许比较陌生。但是我若将关联分析换成另一个短语“尿布与啤酒”大家就会很熟悉了。据报道,美国中西部的一家连锁店发现,男人们会在周四购买尿布和啤酒。这样商店实际上可以将尿布和啤酒放在一块,并确保在周四的销售中获利。“尿布与啤酒”是关联分析中最著名的例子。那么关联分析的定义也就呼之欲出了:从大规模数据集中寻找物品间的隐含关系被称作关联分析或者关联规则学习。但是寻找物品之间的隐含关系是一项十分耗时的任务,所需的计算代价很高,这就催生出了Apriori算法来在合理的时间范围内解决上述问题。

    频繁项集、关联分析

    关联分析是一种在大规模数据集中寻找有趣关系的任务。这些关系可以有两种形式:频繁项集或关联规则。频繁项集是经常出现在一起的物品的集合,关联规则暗示两种物品之间可能存在很强的关系。我们来举个例子来说明这两个概念。下图给出了某个杂货店的交易清单。
    grocery store
    频繁项是指那些经常出现在一起的物品集合,如上图所示的{diapers,wine}就是频繁项集的一个例子。从上图中我们也能找到诸如diapers wine的关联规则。这意味着如果有人买了diapers,那么他很可能也会买wine。

    量化的方法–支持度、置信度

    如何判断数据集中存在这种关系,如何量化数据从而得到判断这些关系是否存在的标准呢?有人提出了支持度(support)和置信度(confidence)的概念。
    一个项集的支持度被定义为数据集中包含该项的记录所占的比例。如上图所示,{soy milk}的支持度为4/5。支持度是针对项集来说的,因此可以定义一个最小支持度,而只保留满足最小支持度的项集。置信度是针对诸如diapers wine的关联规则来定义的。这条规则的置信度被定义为:支持度({diapers,wine})/支持度({diapers})。这一定义也可以用条件概率来解释:

    P(diapers,wine)=P(wine|diapers)P(diapers)

    大家看到这个条件概率是不是很惊奇?其实从apriori这里我们就能发现一丝端倪了。Apriori在拉丁语中指”来自以前”。当定义问题时,通常会使用先验知识或者假设,这被称作“一个先验”(apriori)。在贝叶斯统计中,使用先验知识作为条件进行推断也很正常。
    支持度和置信度是用来量化关联分析是否成功的方法。假设想找到支持度大于0.8的所有项集,应该如何去做?或许有人会想到“贪心”的方法,就是生成一个物品所有可能组合的清单,然后对每一种组合统计它出现的频繁程度,但是当物品成千上万时,上述做法就需要消耗大量的计算资源。因此有人提出了Apriori算法来减少关联规则学习时所需的计算量。

    举例

    我们以经营一家商品种类并不多的杂货店为例。我们总共有四种商品:商品0,商品1,商品2,商品3。那么这四种商品所有可能的项集组合如下所示:
    possible
    对于仅有4种物品的集合,也要有15种项集组合。对于N种物品的集合,就有 2N1 种项集组合。
    这种项集组合个数指数型增长将会消耗极大的计算资源。那么,到底有没有一种方法能够降低所需要的计算时间呢?

    Apriori原理

    研究人员发现了一种所谓的Apriori原理。这种原理可以帮助我们减少可能感兴趣的项集。为什么Apriori原理能够减少计算时间呢?那是因为在数据中,如果某个项集是频繁的,那么它的所有子集都是频繁地。反之,如果一个项集是非频繁的,那么它的所有超集也都是非频繁的。
    apriori
    上图给出了所有可能的项集,其中非频繁项用灰色表示。由于集合{2,3}是非频繁的,因此{0,2,3}、{1,2,3}、{0,1,2,3}也是非频繁的,它们的支持度根本不需要计算。

    使用Apriori算法来发现频繁项集

    前面我们有说,关联分析的目标包括两项:发现频繁项集和发现关联规则。首先需要先找到频繁项集,然后才能获得关联规则。
    Apriori算法是发现频繁项集的一种方法。Apriori算法的两个输入参数分别是最小支持度和数据集。该算法首先会生成所有单个物品的项集列表。接着扫描交易记录来查看哪些项集满足最小支持度的要求,那些不满足最小支持度的集合会被去掉。然后,对剩下来的集合进行组合以生成包含两个元素的项集。接下来,再重新扫描交易记录,去掉不满足最小支持度的项集。该过程重复进行直到满足退出条件。

    生成候选项集

    下面会创建一个用于构建初始集合的函数,也会创建一个通过扫描数据集以寻找交易记录子集的函数。数据集扫描的伪代码如下:
    这里写图片描述
    实际代码如下:

    def loadDataSet():
        return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
    
    def createC1(dataSet):
        C1 = []
        for transaction in dataSet:
            for item in transaction:
                if not [item] in C1:
                    C1.append([item])
    
        C1.sort()
        return list(map(frozenset, C1))#use frozen set so we
                                #can use it as a key in a dict    
    
    def scanD(D, Ck, minSupport):
        ssCnt = {}
        for tid in D:
            for can in Ck:
                if can.issubset(tid):
                    if not can in ssCnt: ssCnt[can]=1
                    else: ssCnt[can] += 1
        numItems = float(len(D))
        retList = []
        supportData = {}
        for key in ssCnt:
            support = ssCnt[key]/numItems
            if support >= minSupport:
                retList.insert(0,key)
            supportData[key] = support
        return retList, supportData

    我们一共有三个函数,第一个函数loadDataSet()
    用来构建交易记录,一共四条交易记录,商品种类一共5种。第二个函数是createC1()这里C1是指大小为1的所有候选项集的集合。第三个函数scanD(),它有三个参数,分别是数据集、候选集列表Ck以及感兴趣项集的最小支持度minSupport。
    我们来看实际的运行效果:

    import importlib
    import apriori
    dataSet = apriori.loadDataSet()
    dataSet
    [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
    
    importlib.reload(apriori) 
    C1 = apriori.createC1(dataSet)
    C1
    [frozenset({1}),
     frozenset({2}),
     frozenset({3}),
     frozenset({4}),
     frozenset({5})]
    
    L1 ,suppData0  = apriori.scanD(dataSet,C1,0.5)
    L1
    [frozenset({5}), frozenset({2}), frozenset({3}), frozenset({1})]
    

    上述四个项集构成了L1列表,该列表的每个但物品项集至少出现在50%以上的记录中。这通过去掉物品4,从而为接下来寻找两两物品组合的项集减少了工作量。

    完整的Apriori算法

    整个Apriori算法的伪代码如下:
    algorithm
    完整的代码如下:

    def aprioriGen(Lk, k): #creates Ck
        retList = []
        lenLk = len(Lk)
        for i in range(lenLk):
            for j in range(i+1, lenLk): 
                L1 = list(Lk[i])[:k-2]; L2 = list(Lk[j])[:k-2]
                L1.sort(); L2.sort()
                if L1==L2: #if first k-2 elements are equal
                    retList.append(Lk[i] | Lk[j]) #set union
        return retList
    
    def apriori(dataSet, minSupport = 0.5):
        C1 = createC1(dataSet)
        D = dataSet
        L1, supportData = scanD(D, C1, minSupport)
        L = [L1]
        k = 2
        while (len(L[k-2]) > 0):
            Ck = aprioriGen(L[k-2], k)
            Lk, supK = scanD(D, Ck, minSupport)#scan DB to get Lk
            supportData.update(supK)
            L.append(Lk)
            k += 1
        return L, supportData

    上述代码由两个函数组成,主函数是apriori(),它会调用aprioriGen()来创建候选集Ck。其中有句代码需要注意下:

    L1 = list(Lk[i])[:k-2]; L2 = list(Lk[j])[:k-2]

    这里的k-2或许大家不是很清楚,k是指要生成的元素个数,假设有项集{0,1},{0,2},{1,2}那么如果两两集合合并,就会得到重复项,为了减少遍历列表时的时间复杂度,我们发现如果比较集合的前k-2个元素是否相等,相等便合并,不想等不合并。按这个规则合并,不仅结果一样,而且没有重复计算的过程。
    具体实验结果如下:

    ##apriori algorithm
    importlib.reload(apriori) 
    L,suppData = apriori.apriori(dataSet)
    L
    [[frozenset({5}), frozenset({2}), frozenset({3}), frozenset({1})],
     [frozenset({2, 3}), frozenset({3, 5}), frozenset({2, 5}), frozenset({1, 3})],
     [frozenset({2, 3, 5})],
     []]
    
    L[0]
    [frozenset({5}), frozenset({2}), frozenset({3}), frozenset({1})]
    
    L[1]
    [frozenset({2, 3}), frozenset({3, 5}), frozenset({2, 5}), frozenset({1, 3})]
    
    L[2]
    [frozenset({2, 3, 5})]
    
    L[3]
    []
    

    从频繁项集中挖掘关联规则

    前面我们介绍了Apriori原理,然后实现了Apriori算法来发现频繁项集,现在我们就来找出关联规则。要想找到关联规则,首先就要从频繁项集入手。我们希望从某个元素或者某个元素集合去推导出另一个元素或集合。
    从杂货店的例子,我们可以得到如果存在一个频繁项集{diapers,wine},那么就可能有一条关联规则“diaper wine”,这意味着如果有人购买了diapers,那么他购买wine的概率会很大。但是反之并不一定成立。我们前面给出了关联规则置信度的量化定义。在这里一条规则
    “diaper wine”的置信度定义为support(diaper,wine)/support(diapers)。所以现在看来,要想求关联规则,就先获取置信度,而置信度通过公式就是将前面求得的支持度做了个除法。
    那么从一个频繁项集中,能够生成多少规则呢?我们假设频繁项集{0,1,2,3}那么下图给出了关联规则网格示意图。
    这里写图片描述
    与频繁项集的生成类似,我们也能找到一个原理来减少规则数目从而降低计算量。图中阴影部分给出了低置信度的规则,可以观察得到,如果某条规则并不满足最小置信度要求,那么该规则的所有子集也不会满足最小置信度要求。与前面讲述的apriori算法类似,首先从一个频繁项集开始,接着创建一个规则列表,其中规则右部只包含元素,然后对这些规则进行测试。接下来合并所有剩余规则来创建一个新的规则列表,其中规则右部包含两个元素。这种方法也被称作分级法。
    下面我们直接给出该算法的实现代码:

    def generateRules(L, supportData, minConf=0.7):  #supportData is a dict coming from scanD
        bigRuleList = []
        for i in range(1, len(L)):#only get the sets with two or more items
            for freqSet in L[i]:
                H1 = [frozenset([item]) for item in freqSet]
                if (i > 1):
                    rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)
                else:
                    calcConf(freqSet, H1, supportData, bigRuleList, minConf)
        return bigRuleList         
    
    def calcConf(freqSet, H, supportData, brl, minConf=0.7):
        prunedH = [] #create new list to return
        for conseq in H:
            conf = supportData[freqSet]/supportData[freqSet-conseq] #calc confidence
            if conf >= minConf: 
                print(freqSet-conseq,'-->',conseq,'conf:',conf)
                brl.append((freqSet-conseq, conseq, conf))
                prunedH.append(conseq)
        return prunedH
    
    def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):
        m = len(H[0])
        if (len(freqSet) > (m + 1)): #try further merging
            Hmp1 = aprioriGen(H, m+1)#create Hm+1 new candidates
            Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)
            if (len(Hmp1) > 1):    #need at least two sets to merge
                rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)

    上述代码一共有三个函数,其中第一个函数generateRules()是主函数,其余两个函数rulesFromConseq()和calcConf分别用于生成候选规则集合以及对规则进行评估。
    看一下实际运行效果:

    ##association
    ##生成一个最小支持度为0.5的频繁项的集合
    L,suppData = apriori.apriori(dataSet,minSupport=0.5)
    rules =apriori.generateRules(L,suppData,minConf=0.7)
    rules
    frozenset({5}) --> frozenset({2}) conf: 1.0
    frozenset({2}) --> frozenset({5}) conf: 1.0
    frozenset({1}) --> frozenset({3}) conf: 1.0
    
    [(frozenset({5}), frozenset({2}), 1.0),
     (frozenset({2}), frozenset({5}), 1.0),
     (frozenset({1}), frozenset({3}), 1.0)]
    

    总结

    关联分析是用于发现大数据集中元素间有趣关系的一个工具集,可以采用两种方式来量化这些有趣的关系。第一种是频繁项集,第二种是关联规则。发现元素项间不同的组合是个十分耗时的任务,这就需要一些更智能的方法,比如Apriori算法来降低时间复杂度。但是这种算法还是存在问题的,因为在每次增加频繁项集的大小,Apriori都会重新扫描整个数据集。当数据集很大时,这回显著降低频繁项集发现的速度。FP-growth算法就能很好的解决这个问题。

    展开全文
  • 采用云模型,将土地评价因素指标的自然语言描述映射为可细微变化的不同云滴,利用云不确定性推理,实现定性和定量的...在此基础上,结合关联分析法,提出了一种新的土地评价影响因素权重获取方法,并给出了实验结果。
  • IBM SPSS Modeler 【5】 关联分析

    万次阅读 2016-04-09 05:42:51
    通过该实验,能够客观实际地理解关联分析和决策树的相关知识。 首先进行的是关联分析,之后利用关联分析的数据建立一个决策树。 1、关联分析 (1) 打开并查看数据文件。利用“可变文件”节点将“Demos”...

    SPSS 数据挖掘方法概述——关联、决策树

    本实验是基于关联和决策树在数据挖掘中的应用。通过该实验,能够客观实际地理解关联分析和决策树的相关知识。

    首先进行的是关联分析,之后利用关联分析的数据建立一个决策树。

    1、关联分析

    (1)          打开并查看数据文件。利用“可变文件”节点将“Demos”下的“BASKETS1n”添加节点中。然后使用“输出”选项卡下的“表”查看数据,如图 41 所示。这里的数据是某商场中的购买记录,共 18 个字段,1000 条记录,在后面的列中,值“T”表示已购买该商品,值“F”表示没有购买该商品。

     图 41 “表”窗口

     

    (2)          确定关联分析字段。在这里中,需要对购买商品之间进行关联分析,即确定客户购买商品之间是否存在关联性,也就是说客户在购买一种商品时,购买另一种商品的概率是多少。所以,在这里,将选择记录中能够体现是否购买某商品的字段进行关联分析,其中有 fruitveg,freshmeat,dairy,cannedveg,cannedmeat,frozenmeal,beer,wine,softdrink,fish,confectione ry,共 11 个字段。

    (3)          读入分析字段的类型。在工作区生成“类型”节点,并双击编辑,将上一步骤选出的 11 个字段的角色设定为“两者”,如图 42

     图 42“类型”节点编辑窗口(4)添加模型节点。分别在“类型”之后添加“Apriori”模型节点和“Crama”模型节点,如图43 所示。其中,“Apriori”模型是基于“最低支持度”和“最小置信度”进行关联性分析。

     图 43 工作区中的“Apriori”模型和“Crama”模型

     

    (5)          运行并查看“Apriori”关联模型结果。运行“Apriori”模型的数据流,在右上侧生成数据模型,右键查看,如图 44 所示。表中可以看出,客户同时购买 frozenmealbeer、 cannedveg 的概率很高。因此,商家可以将这三种商品放在相邻的位置,以促进销量。

     

     图 44 Apriori”模型查看窗口

     

    (6)          运行并查看“Carma”关联模型结果。运行“Carma”模型的数据流,在右上侧生成数据模型,右键查看,如图 45 所示。同样可以看出,客户同时购买 frozenmealbeer、 cannedveg 的概率很高。

     图 45 Carma”模型查看窗口

     

    (7)          利用“网络”图进行定性关联分析。选定“类型”节点,双击“图形”选项卡下的“网络”,既可添加“网络节点”。然后,需双击编辑 “网络”节点,将步骤(5)中选择的 11 个字段选定为分析字段。运行该“网络”节点,则右上区域生成关联模型,查看该关联模型,如图 46。从图中表明,两点之间的线越粗,表示两者间相关性越强。同时可以通过调节下面的滑动点,查看相关性。

     图 46 “关联”模型查看窗口

    展开全文
  • 该算法利用灰色关联分析法检测出SAR图像像素中的边缘点和非边缘点;通过IHS变换,在线性加权融合时赋予边缘点较大的权值。实验表明,该算法在保持光谱信息方面具有显著的优越性,并且能够有效提高融合图像的空间分辨...
  • 灰色关联分析

    千次阅读 2019-03-04 23:22:17
    灰色关联分析是灰色理论中的一种运用。 灰色理论认为系统的行为现象是朦胧的,数据是复杂的。灰色理论建立的是生成数据的模型,不是原始数据模型。 所谓灰色系统是介于白色系统和黑箱系统之间的过渡系统。 原始...

    灰色关联分析是灰色理论中的一种运用。

    灰色理论认为系统的行为现象是朦胧的,数据是复杂的。灰色理论建立的是生成数据的模型,不是原始数据模型。

    所谓灰色系统是介于白色系统和黑箱系统之间的过渡系统。

    原始数据:

    整理成数据:

    data =[
        [102.4, 102.8, 103.1, 102.9, 103.3, 103.5,
         103.6, 104.4, 105.1, 104.6, 104.9, 104.9, 105.4],
        [105.2, 105.9, 106.1, 105.7, 106.8, 107.5, 108.0, 110.1,
         117.1, 109.6, 110.3, 111.0, 111.7],
        [101.7, 101.7, 101.7, 101.7, 101.6, 101.5,
         101.4, 101.5, 101.6, 101.8, 101.8, 101.9, 102.1],
        [98.9, 98.7, 98.8, 99.0, 99.2, 98.8, 98.5,
         98.7, 99.3, 100.1, 99.8, 100.4, 100.8],
        [99.3, 99.5, 99.7, 100.0, 100.2, 100.4, 100.4,
         100.5, 100.7, 101.2, 101.4, 101.4, 101.9],
        [102.5, 102.8, 103.2, 103.2, 103.3, 103.3, 103.4,
         103.7, 104.0, 104.0, 103.2, 103.0, 103.2],
        [100.0, 100.0, 100.1, 99.7, 99.3, 99.4, 99.3,
         99.5, 99.3, 99.3, 99.9, 99.7, 100.1],
        [100.3, 100.4, 100.6, 100.9, 101.1, 101.2, 101.2,
         100.9, 100.6, 100.7, 101.0, 100.3, 100.5],
        [100.3, 104.5, 105.0, 105.0, 104.8, 104.4, 104.3,
         104.9, 105.8, 106.0, 106.8, 106.1, 106.6]
    ]

    本实验运用灰色关联分析法,分析城市食品零食价格指数对CPI 的影响

    本次计算灰色关联度:

         1.   计算data中CPI,食品等的平均值m

         2.  生产新的数据data1:   data/a  (每个特征值/对应的平均值)

         3. 生产新数据data2:      data1中,每个特征对应的值相减

         4. 找出data2中最大值b, 最小值a

         5. 计算关联系数zk:  (a+0.5b)/data2+0.5b

         6.计算关联度:

                          zk.sum(axis=1)/(n-1)

    代码如下:

    import pandas  as pd
    def getGM(data):
        ndata = pd.DataFrame(data)
        meandata = ndata.mean(axis=1)
        r,c = ndata.shape
        for item in range(r):
            ndata.iloc[item] = ndata.iloc[item]/meandata[item]
        diffdata = ndata.diff().iloc[1:].abs()
        a = diffdata.min().min()
        b = diffdata.max().max()
        res = (a + 0.5*b)/(diffdata +0.5*b)
        ret = res.sum(axis=1)/(c-1)
        return ret
    print getGM(data)

      

    展开全文
  • 针对不确定信息的相似性度量方法无法充分反映信息之间的关联情况, 提出了直觉模糊集关联趋势分析法RTIFS。利用直觉模糊集之间的距离表示不确定信息的差别, 通过区间数与直觉模糊集之间的等价关系, 利用区间数的...
  • 通过对6种不同变质程度的煤进行煤质分析、元素分析和微观孔隙结构分析,采用多元统计分析法和主成分分析法对多组试验数据进行耦合关联综合分析,确定了煤样水分、挥发分、碳含量、氧含量、孔隙率等主要影响因素在公共...
  • 根据灰色系统理论,计算电动机三相定子电流与完好电动机的灰色关联度,可确定电动机断条故障的严重程度,再通过测量完好电动机、一根断条电动机、三根断条电动机的三相定子电流,得到原始实验数据,最终按计算结果来判定...
  • 【知识图谱】知识图谱的基础概念与构建流程

    千次阅读 多人点赞 2019-11-09 18:46:49
    例如文献[18]基于字典,使用最大熵算法在Medline论文摘要的GENIA数据集上进行了实体抽取实验实验的准确率与召回率都在70%以上。近年来随着深度学习的兴起应用,基于深度学习的命名实体识别得到广泛应用。在文献[19...
  • 示波器不仅应用于实验室,更成为信息时代不可缺少的辅助工具,利用示波器对电子产品的电路进行信号的检测和分析,可以大大提高检修效率。理解并掌握示波器的示波原理是解决这些问题的前提,但大多数同学对此难以理解...
  • 针对卷积神经网络巨大的计算量和存储量导致其...实验结果表明,相比APoZ、L1,所提方法在同一推理速度提升下精度提高了5.3%和10.4%,在VGG-16模型上取得了相对于初始模型2.7倍的加速效果,存储量压缩为原来的1/13.5。
  • 测试开发笔记

    万次阅读 多人点赞 2019-11-14 17:11:58
    界面检查 1明确被修改的功能 简单 2修改功能的上下游功能 3调用修改功能的功能和 修改功能调用了的功能 4和修改功能游相同输入输出的功能 5在测试中执行上诉关联的用例 代码检查 1明确被修改的函数和代码 准确,...
  • matlab人脸识别论文

    万次阅读 多人点赞 2019-10-11 17:41:51
    摘 要 本文设计了一种基于BP神经网络的人脸识别系统,并对其进行了性能分析。该系统首先利用离散小波变换获取包含人脸图像大部分原始信息的低频分量,对图像数据进行降维;...通过系统仿真实验分析发现:人脸特征的提...
  • MySQL 面试题

    万次阅读 多人点赞 2019-09-02 16:03:33
    MySQL 面试题 MySQL 涉及的内容非常非常非常多,所以面试题也容易写的杂乱。当年,我们记着几个一定要掌握的重心: 重点的题目添加了【重点】前缀。 索引。 ...因为 MySQL 还会有部分内容和运维相关度比较高,所以...
  • 黑盒测试方法之正交实验法

    千次阅读 2020-10-26 09:40:31
    或者因果关系非常庞大,导致利用因果图得到的测试用例数目非常大,为了有效地、合理地减少测试的工时与费用(测试用例的数量),就可以使用正交实验法。 2、定义 此方法是由数理统计学科中正交实验方法演化而来的一种...
  • 示波器不仅应用于实验室,更成为信息时代不可缺少的辅助工具,利用示波器对电子产品的电路进行信号的检测和分析,可以大大提高检修效率。理解并掌握示波器的示波原理是解决这些问题的前提,但大多数同学对此难以理解...
  • 基于LSTM的股票预测模型_python实现_超详细

    万次阅读 多人点赞 2019-07-05 22:25:13
    文章目录一、背景二、主要技术介绍1、RNN模型2、LSTM模型3、控制门工作原理四、代码实现五、案例分析六、参数设置七、结论 一、背景 近年来,股票预测还处于一个很热门的阶段,因为股票市场的波动十分巨大,随时...
  • Matlab时间序列分析

    万次阅读 多人点赞 2018-11-13 18:53:46
    下载地址,包含本实验用到的数据/资料以及全部代码,实验报告,引用请告知,关注并留言获取提取码,或者到我的csdn下载进行下载 我们可以发现,在数据中似乎有种明显的趋势规律,或许还存在一定的周期性。...
  • 软件测试面试题汇总

    万次阅读 多人点赞 2018-09-27 12:31:09
    转载自: ... 软件测试面试题汇总 测试技术面试题 ...........................................................................................................
  • 介绍一种灰色诊断.在铁谱分析技术中,运用灰关联分析进行故障诊断的模式识别,并在油样分析故障诊断实验研究中得到了验证.结果表明,灰关联分析法是铁谱分析技术中进行状态识别与故障诊断的一个有效工具.
  • NBT:鸟枪宏基因组-从取样到数据分析Shotgun metagenomics, from sampling to analysisNature Biotechnology [IF:3...
  • C#基础教程-c#实例教程,适合初学者

    万次阅读 多人点赞 2016-08-22 11:13:24
    C#基础教程-c#实例教程,适合初学者。 第一章 C#语言基础 本章介绍C#语言的基础知识,希望具有C语言的读者能够基本掌握C#语言,并以此为基础,能够进一步学习用C#语言编写window应用程序和Web应用程序。...
  • Python 脚本编写

    万次阅读 多人点赞 2018-07-14 19:50:05
    在解释器中进行实验 安装 Python 检查计算机是否安装了 Python ? 在终端窗口输入如下指令,并按回车 python --version 系统可能会显示已安装的 Python 版本是 Python 2.7.9。在这种情况下,表明你已...
  • 主成分分析法

    千次阅读 2015-08-11 12:57:34
    主成分分析法的基本原理及应用 什么是主成分分析法  主成分分析也称主分量分析,旨在利用降维的思想,把多指标转化为少数几个综合指标。  在统计学中,主成分分析(principal components analysis,PCA)是一种...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,515
精华内容 7,806
关键字:

关联法实验分析