精华内容
下载资源
问答
  • 12.5 并行序列模式挖掘 早期的并行序列模式挖掘算法大多被用于解决算法效率低下的问题。因此,许多并行算法是由其串行版本改进得到。例如,Zaki [28] 扩展了由他自己提出的 SPADE 算法,提出了在内存共享框架下的...

    12.5 并行序列模式挖掘

    早期的并行序列模式挖掘算法大多被用于解决算法效率低下的问题。因此,许多并行算法是由其串行版本改进得到。例如,Zaki [28] 扩展了由他自己提出的 SPADE 算法,提出了在内存共享框架下的并行算法 pSPADE。pSPADE 的并行性主要来源于对垂直格式数据库的划分,这种划分既可以横向也可以纵向,最终实现了并行。采用了相似策略的算法还有 Par-ASP [29] 和 Par-CSP [30] 等。

    近年来,随着数据量的不断增大、数据类型的不断变化,以及新型并行计算框架(如 HadoopMapReduce 和 Spark)的不断涌现,并行序列模式挖掘算法开始面向更大的数据及更加复杂的应用。Berberich 等人[31]提出了基于 MapReduce 的并行序列模式挖掘算法,从大规模的文本语料中挖掘 n元语法模式。Miliaraki 等人[32]考虑了更为复杂的带有间隔约束的序列模式挖掘问题,提出了基于MapReduce 的大规模带间隔约束的并行序列模式算法 MS-FSM。该算法提出了一系列对序列集合的改写方法,使得在 MapReduce 的任务划分更加平衡,从而取得更好的并行效率。Beedkar 等人[33]又继续对 MS-FSM 算法进行扩展,解决更为复杂的带有层次结构的间隔约束序列模式挖掘问题。所提出的LASH算法在大规模文本数据集上的实验结果显示,当数据具有或者不具有层次结构时,LASH 算法的表现均优于 MS-FSM 算法。我们最近的工作将序列模式挖掘技术与基于线段树的索引技术相结合,实际用于我国证券市场“老鼠仓”发现应用中,实现了基于 MapReduce 和 Spark 的高可扩展趋同行为发现并行算法,将同等规模任务的运行时间从“天”级缩短到分钟级。

    展开全文
  • 根据这些参数,将待安装零件作为知识论域,提出了适切隶属度函数作为评价指标的不可辨识关系,在基于知识论域和不可辨识关系表示的知识库中采用模糊粗糙集模型,生成装配并行序列。机用台虎钳和等离子体增强化学气相...
  • 为了在多核处理器上充分利用多核资源以提升挖掘性能,提出了一种动态与静态任务分配机制相结合的基于多核的并行序列模式挖掘算法。该算法采用数据并行与任务并行相结合的策略,在各处理器核生成局部序列模式后,再与...
  • 为了在多核处理器上充分利用多核资源以提升挖掘性能,提出了一种动态与静态任务分配机制相结合的基于多核的并行序列模式挖掘算法。该算法采用数据并行与任务并行相结合的策略,在各处理器核生成局部序列模式后,再与...
  • 基于改进遗传编程的并行装配序列规划
  • 针对处理机节点具有不同计算速度、不同通信能力的情况,考虑计算和通信启动...实验结果表明,基于最优序列串分配方法的双序列最长公共子序列并行算法优于平均分配序列串算法,获得了较好的加速,并具有良好的可扩展性。
  • 启发式并行化单触发序列挖掘算法
  • 由于它具有应用广泛、计算复杂以及海量数据等特点,加之现在高性能计算的兴起,使得近年来序列比对并行处理技术快速发展。首先介绍了序列比对领域高性能计算的新进展,接着从体系结构特征入手对其研究进行分类,并对...
  • CPU和GPU协同并行加速多生物序列比对
  • 结合云计算平台和MaxCompute大数据处理技术,设计实现了时间序列数据的表存储方法和并行化的时间序列数据排列熵特征提取算法。在云计算平台上采用不同规模的数据集对并行化算法进行测试,验证了并行化排列熵算法的...
  • MapReduce分布式并行模型中混沌序列加密算法的实现
  • 详细介绍了 CUDA平台上序列比对并行软件的优化
  • 序列化:把对象转换为字节序列的过程称为对象的序列化。 反序列化:把字节序列恢复为对象的过程称为对象的反序列化。 1、序列化基本实现 a)最基本的序列化:实现Serializable接口,通过文件流的方式将对象持久化...

    概念:
    序列化:把对象转换为字节序列的过程称为对象的序列化。
    反序列化:把字节序列恢复为对象的过程称为对象的反序列化。
    对象的序列化主要有两种用途:
    1)把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中;
    2)在网络上传送对象的字节序列。
    串行化与序列化的关系:
      串行化也叫做序列化,就是把存在于内存的对象数据转化成可以保存成硬盘文件的形式去存储;
    并行化与反序列化的关系:
      并行化也叫反序列化,就是把序列化后的硬盘文件加载到内存,重新变成对象数据.
    也就是把内存中对象数据变成硬盘文件.
    1、序列化基本实现
    a)最基本的序列化:实现Serializable接口,通过文件流的方式将对象持久化到磁盘。

    public class Person implements Serializable{
    //主要用于保证序列化对象的版本兼容
     private static final long serialVersionUID = -8146973185149904486L;
        private String name;
        private int age;
        private Person per;
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public Person() {
            super();
        }
        @Override
        public String toString() {
            return "Person [name=" + name + ", age=" + age + ", per=" + (per !=null ? per.getName() : "[null]") + "]";//注意这里有一个括号
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public Person getPer() {
            return per;
        }
        public void setPer(Person per) {
            this.per = per;
        }
    
    }
        @Test
        public void serialize(){
            Person p1 = new Person("柳三", 32);
            Person p2 = new Person("徐五", 26);
            p1.setPer(p2);
            p2.setPer(p1);
            try {
                FileOutputStream fileOutputStream = new FileOutputStream("my.ser");
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
                objectOutputStream.writeObject(p1);
                objectOutputStream.close();
            } catch (Exception e) {
                e.printStackTrace();
            } 
        }

    b)最基本的反序列化:读取之前序列化之后的文件,恢复成对象

    @Test
    public void deserialize(){
            try {
                FileInputStream fileInputStream = new FileInputStream("my.ser");
                ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
                Person pp= (Person) objectInputStream.readObject();
                objectInputStream.close();
                System.out.println(pp.toString());
                new File("facked.ser").delete();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    2、模糊化序列化数据(并不是加密)

    public class Person implements Serializable{
        private static final long serialVersionUID = -8146973185149904486L;
        private String name;
        private int age;
        private Person per;
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public Person() {
            super();
        }
        //模糊化数据处理:这里采用简单方式
        private void writeObject(ObjectOutputStream objectOutputStream) throws IOException{
            age = age << 2;//混淆关键字段
            objectOutputStream.defaultWriteObject();//将当前类的非静态和非瞬态字段写入此流
        }
        private void readObject(ObjectInputStream objectInputStream) throws ClassNotFoundException, IOException {
            objectInputStream.defaultReadObject();
            age = age >> 2;//解混淆关键字段 注意解混淆放在objectInputStream.defaultReadObject();后面
        }
    
        @Override
        public String toString() {
            return "Person [name=" + name + ", age=" + age + ", per=" +  (per !=null ? per.getName() : "[null]") + "]";
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public Person getPer() {
            return per;
        }
        public void setPer(Person per) {
            this.per = per;
        }   
    }

    想了解更多可以参考:http://blog.csdn.net/qq_35101189/article/details/55045189

    展开全文
  • 多核系统上任意2序列公共元素的并行查找
  • 并行单边jacobi算法 奇偶序列

    千次阅读 2014-03-05 16:44:55
    单边jacobi算法大家都非常熟悉,就是不停地计算旋转矩阵,简单说就是计算c和s,...通过这几天研究jacobi算法,我选择了从奇偶序列着手来实现其并行算法。 下面是8*8的矩阵,其中for循环可以做并行实现的,但是pc机上

    单边jacobi算法大家都非常熟悉,就是不停地计算旋转矩阵,简单说就是计算c和s,然后旋转。然而其中做一轮旋转(任何两列都需要旋转一次)需要n*(n-1)/2次单独的旋转,这样的旋转其实是可以并行来实现的,这也就是为何jacobi算法最近比较热门的原因了。

    通过这几天研究jacobi算法,我选择了从奇偶序列着手来实现其并行算法。

    下面是8*8的矩阵,其中for循环可以做并行实现的,但是pc机上不支持并行,只有FPGA上面可以实现并行,所以下一步打算从FPGA上面入手,实现并行jacobi算法的硬件。

    void jacobi()
    {
    double a[Matrix_M][Matrix_M]={{0.4218   , 0.6787,    0.2769  ,  0.4387   , 0.7094   , 0.9597  ,  0.8909  ,  0.8143}
    ,{ 0.9157   , 0.7577   , 0.0462  ,  0.3816   , 0.7547 ,   0.3404,    0.9593  ,  0.2435}
    ,{  0.7922 ,   0.7431 ,   0.0971 ,   0.7655  ,  0.2760  ,  0.5853 ,   0.5472 ,   0.9293}
    ,{  0.9595   , 0.3922  ,  0.8235  ,  0.7952   , 0.6797  ,  0.2238   , 0.1386 ,   0.3500}
    ,{  0.6557 ,   0.6555  ,  0.6948 ,   0.1869  ,  0.6551  ,  0.7513  ,  0.1493  ,  0.1966}
    ,{  0.0357 ,   0.1712 ,   0.3171   , 0.4898    ,0.1626  ,  0.2551  ,  0.2575  ,  0.2511}
    ,{ 0.8491,    0.7060  ,  0.9502  ,  0.4456,   0.1190  ,  0.5060   , 0.8407  ,  0.6160}
    ,{  0.9340 ,   0.0318 ,   0.0344  ,  0.6463 ,   0.4984  ,  0.6991 ,   0.2543,    0.4733}};
    int cnt, l;
    int order[Matrix_M]={1,2,3,4,5,6,7,8};
    int couplenums;
    int sequence[Matrix_M]={1,2,3,4,5,6,7,8};
    int oddoreven;
    int numi[Matrix_M];
    int  numj[Matrix_M];
    int k;
    int m;
    printf("##################################\n");
    for(m=0;m<Matrix_M;m++){
    for(cnt=0;cnt<Matrix_M;cnt++)
    {
    printf(" %10f ", a[m][cnt]);
    }
    printf("\n");
    }
    printf("\n##################################\n");
    for(k=0;k<56;k++)
    {
    numbercreation(numi, numj , k,  sequence, &couplenums);
    for(l=0;l<couplenums;l++){
    Orthogonality_operation(numi[l], numj[l], a[numi[l]-1], a[numj[l]-1], order);
    printf("\n##################################\n");
    for(m=0;m<Matrix_M;m++){


    for(cnt=0;cnt<Matrix_M;cnt++)
    {
    printf(" %10f ", a[m][cnt]);
    }
    printf("\n");


    }
    }
    printf("\n##################################\n");
    }
    for(m=0;m<Matrix_M;m++)
    {
    printf(" %d ",order[m]);
    }
    }

    展开全文
  • Verilog – 并行2bit输入序列检测器 @(verilog) 乐鑫2020笔试题: 描述:模块输入口是并行的2bit,实现对(1011001)2(1011001)_2(1011001)2​的序列检测,输入数据顺序为高位2bit先输入,当检测到序列时输出一拍高电...

    Verilog – 并行2bit输入序列检测器

    @(verilog)

    乐鑫2020笔试题

    描述:模块输入口是并行的2bit,实现对(1011001)2(1011001)_2的序列检测,输入数据顺序为高位2bit先输入,当检测到序列时输出一拍高电平脉冲,用verilg描述。

    方法一:状态机

    采用状态机描述,先列出状态转移表,跟单bit输入不同的是,这里的输入是并行的2bit:

    state\input 00 01 10 11
    0 0 1 10 1
    1 0 101 10 1
    10 0 1 10 1011
    101 0 101 10110 1
    1011 101100 101 10 1
    10110 0 1011001 10 1011
    101100 0 1 10 1
    1011001 0 101 10 1

    以及输出的状态转移表:

    state\input 00 01 10 11
    0 0 0 0 0
    1 0 0 0 0
    10 0 0 0 0
    101 0 0 0 0
    1011 0 0 0 0
    10110 0 1 0 0
    101100 0 0 1 1
    1011001 0 0 0 0

    通过分析可以发现,1011001和1状态是完全等价的,因此可以归并,并且其他状态的转移也有相同的,也可以放到一起:
    状态转移表

    state\input 00 01 10 11
    0\101100 0 1 10 1
    1 0 101 10 1
    10\10110 0 1 10 1011
    101 0 101 10110 1
    1011 101100 101 10 1

    输出转移表:

    state\input 00 01 10 11
    0\1\10\101\1011 0 0 0 0
    10110 0 1 0 0
    101100 0 0 1 1

    Verilog代码:

    
    
    
    
    `timescale 1ns/1ps
    
    module two_bit_input_seq_detector
    (
    input                                   clk,
    input                                   rst_n,
    input        [1:0]                      data,
    output reg                              success
    );
    
    reg [2:0] current_state;
    reg [2:0] next_state;
    
    parameter S0      =  3'b000,
              S1      =  3'b001,
              S10     =  3'b011,
              S101    =  3'b010,
              S1011   =  3'b110,
              S10110  =  3'b111,
              S101100 =  3'b101;
    
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) current_state <= 3'b0;
        else current_state <= next_state;
      end
    
    always @(*) 
      case(current_state)
        S0,S101100: 
                case(data)
                  2'b00: next_state = S0;
                  2'b01: next_state = S1;
                  2'b10: next_state = S10;
                  2'b11: next_state = S1;
                endcase
        S1:     case(data)
                  2'b00: next_state = S0;
                  2'b01: next_state = S101;
                  2'b10: next_state = S10;
                  2'b11: next_state = S1;
                endcase
        S10,S10110:
                case(data)
                  2'b00: next_state = S0;
                  2'b01: next_state = S1;
                  2'b10: next_state = S10;
                  2'b11: next_state = S1011;
                endcase   
        S101:   case(data)
                  2'b00: next_state = S0;
                  2'b01: next_state = S101;
                  2'b10: next_state = S10110;
                  2'b11: next_state = S1;
                endcase
        S1011:  case(data)
                  2'b00: next_state = S101100;
                  2'b01: next_state = S101;
                  2'b10: next_state = S10;
                  2'b11: next_state = S1;
                endcase
        default:         next_state = S0;
      endcase
    
      
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
          success <= 0;
        end else begin
          case(current_state)
            S0,S1,S10,S101,S1011:        success <= 0;
            S10110 : if(data == 2'b01)   success <= 1;
                     else                success <= 0;
            S101100: if(data[1] == 1'b1) success <= 1;
                     else                success <= 0;
            default:                     success <= 0;
          endcase
        end
      end
    
    endmodule
    
    
    
    
    

    testbench:

    
    `timescale 1ns/1ps
    
    module two_bit_input_seq_detector_tb();
    
    
    reg         clk;
    reg         rst_n;
    reg   [1:0] data;
    
    wire     success;
    reg [127:0] seq;
    
    
    always #1 clk = ~clk;
    initial begin
      clk = 0;
      data = 0;
      rst_n = 1;
      #4 rst_n = 0; #2 rst_n = 1;
    
      seq = 0;
      while(1) begin
        @(posedge clk) begin 
          data <= $random%4;
          seq <= (seq<<2) + data;
        end
      end
    
    end
    
    
    
    two_bit_input_seq_detector U_2BIT_INPUT_SEQ_DETECTOR_0
    (  .clk     ( clk     ),
       .rst_n   ( rst_n   ),
       .data    ( data    ),
       .success ( success ));
    
    
    initial begin
      $fsdbDumpvars();
      $fsdbDumpMDA();
      $dumpvars();
      #1000 $finish;
    end
    
    endmodule
    
    
    

    波形图:

    放大来看:

    可以看到,功能正确。

    方法二:移位寄存器

    使用移位寄存器解决序列检测问题是真的简单粗暴,直接上代码:

    
    `timescale 1ns/1ps
    
    module two_bit_input_seq_detector_v2
    (
    input                                   clk,
    input                                   rst_n,
    input        [1:0]                      data,
    output                                  success
    );
    
    parameter DETECTOR = 7'b1011001;
    reg [7:0] fifo;
    
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
          fifo <= 8'b0;
        end else begin
          fifo <= {fifo[5:0],data};
        end
    end
    
    assign success = (fifo[7:1]==DETECTOR || fifo[6:0]==DETECTOR) ? 1:0;
    
    endmodule
    

    testbench:

    
    `timescale 1ns/1ps
    
    module two_bit_input_seq_detector_v2_tb();
    
    
    reg         clk;
    reg         rst_n;
    reg   [1:0] data;
    
    wire     success;
    reg [127:0] seq;
    
    
    always #1 clk = ~clk;
    initial begin
      clk = 0;
      data = 0;
      rst_n = 1;
      #4 rst_n = 0; #2 rst_n = 1;
    
      seq = 0;
      while(1) begin
        @(posedge clk) begin 
          data <= $random%4;
          seq <= (seq<<2) + data;
        end
      end
    
    end
    
    
    
    
    two_bit_input_seq_detector_v2 U_TWO_BIT_INPUT_SEQ_DETECTOR_V2_0
    (  .clk     ( clk     ),
       .rst_n   ( rst_n   ),
       .data    ( data    ),
       .success ( success ));
    
    
    initial begin
      $fsdbDumpvars();
      $fsdbDumpMDA();
      $dumpvars();
      #1000 $finish;
    end
    
    endmodule
    

    仿真波形:

    功能正确!

    展开全文
  • 利用动态规划序列比对算法内在的并行性,提出了自适应的动态规划序列比对的并行策略.该策略在计算初期和计算末期采用较小的高度和宽度值使得大部分处理器参与计算,在计算中期采用较大的高度和宽度值降低处理器间的...
  • 为了克服它们的缺点,基于提出的问题解决模型和并行拓扑排序策略,我们提出了一种新颖的高效并行MLCS算法。 对随机序列和生物学序列的基准数据集进行的综合实验表明,该算法的时间和空间复杂度仅与对齐序列的优势...
  • 基于并行组合扩频通信的混沌序列优选,李北明,张文超,并行组合扩频通信是一种具有较高通信效率的扩频通信方式,但是采用常用扩频码,受到扩频码个数限制,无法降低并行通道之间的干扰
  • 什么是序列化和反序列化什么是串行化和并行化 当两个进程在进行远程通信时,彼此可以发送各种类型的数据。无论是何种类型的数据,都会以二进制序列的形式在网络上传送。发送方需要把这个对象转换为字节序列,才能...
  • 无论是何种类型的数据,都会以二进制序列的形式在网络上传送。发送方需要把这个对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再恢复为对象。 把对象转换为字节序列的过程称为对象的序列化。 把...
  • 什么是序列化和反序列化 什么是串行化和并行化 什么是序列化和反序列化 什么是串行化和并行化      当两个进程在进行远程通信时,彼此可以发送各种类型的数据。无论是何种类型的数据,都会以二进制...
  • 无论是何种类型的数据,都会以二进制序列的形式在网络上传送。发送方需要把这个对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再恢复为对象。 1、把对象转换为字节序列的过程称为对象的序列化。 ...
  • 序列图中的多任务建模是利用并行和临界区两种复合片段来实现的,本文就说明并行与临界区。
  • MPI-dot2dot是一种并行工具,可加快多序列数据集上串联重复序列的识别。 该工具接收FASTQ或FASTA格式的多序列文件作为输入。 它使用MPI进程和OpenMP线程来利用多核群集的计算功能。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 129,376
精华内容 51,750
关键字:

并行序列