精华内容
下载资源
问答
  • I/O密集和CPU密集
    千次阅读
    2016-12-28 21:26:36

    定义

    在计算机科学中,I/O bound指的是完成计算所需时间取决于I/O操作的时间,也就是指系统的CPU效能相对硬盘/内存的效能要好很多,系统大部分时间开销都花在了I/O上,导致CPU长时间处于空闲状态;CPU bound(计算密集型)与此相反,指的是I/O设备长期处于空闲状态。

    原理分析(wikipedia)

      The Von Neumann architecture, which is employed by many computing devices, is based on a logically separate central processor unit which requests data from main memory,[clarification needed] processes it and writes back the results. Since data must be moved between the CPU and memory along a bus which has a limited data transfer rate, there exists a condition that is known as the Von Neumann bottleneck. Put simply, this means that the data bandwidth between the CPU and memory tends to limit the overall speed of computation. In terms of the actual technology that makes up a computer, the Von Neumann Bottleneck predicts that it is easier to make the CPU perform calculations faster than it is to supply it with data at the necessary rate for this to be possible.

      In recent history, the Von Neumann bottleneck has become more apparent. The design philosophy of modern computers is based upon a physically separate CPU and main memory. It is possible to make the CPU run at a high data transfer rate because data is moved between locations inside them across tiny distances. The physical separation between CPU and main memory, however, requires a data bus to move data across comparatively long distances of centimetres or more. The problem of making this part of the system operate sufficiently fast to keep up with the CPU has been a great challenge to designers.[2]

    现阶段大量使用的冯洛伊曼结构的设备是基于逻辑上分开的中央处理单元的,重要处理器从内存读取数据,再把处理的结果回写到内存。数据在CPU和内存上的传输依赖总线,而总线有一个极限的传输速率,也就是众所周知的维纳瓶颈。简单来说,这意味着CPU和内存之间的传输速度开始制约计算机的速度。最新的技术使得容易使CPU的执行速度超过所需要的速度。

    近年来,冯洛伊曼瓶颈变得显而易见。现有的设计哲学都是基于CPU和内存物理隔离的。由于数据总是在很短的距离内移动,因此很容易使CPU在很高的传输速率下运行。而CPU和内存在物理上的隔离导致数据总线需要长距离的传输数据。因此,是的这一部分快速运转以跟上CPU的速度是设计者面临的主要挑战。

          在多重程序系统中,大部份时间用来做计算、逻辑判断等CPU动作的程序称之CPU bound。例如一个计算圆周率至小数点一千位以下的程序,在执行的过程当中绝大部份时间用在三角函数和开根号的计算,便是属于CPU bound的程序。CPU bound的程序一般而言CPU占用率相当高。这可能是因为任务本身不太需要访问I/O设备,也可能是因为程序是多线程实现因此屏蔽掉了等待I/O的时间。而I/O bound的程序一般在达到性能极限时,CPU占用率仍然较低。这可能是因为任务本身需要大量I/O操作,而pipeline做得不是很好,没有充分利用处理器能力。

    更多相关内容
  • 指令周期:CPU从内存取出一条指令执行这条指令的时间总和。 CPU周期:又称机器周期,CPU访问一次内存所花的时间较长,因此用从内存读取一条指令字的最短时间来定义。 时钟周期:通常称为节拍脉冲或T周期。一个CPU...

    一、一些概念

    1.单周期CPU

           指令周期:CPU从内存取出一条指令并执行这条指令的时间总和。
           CPU周期:又称机器周期,CPU访问一次内存所花的时间较长,因此用从内存读取一条指令字的最短时间来定义。
           时钟周期:通常称为节拍脉冲或T周期。一个CPU周期包含若干个时钟周期。
           指令周期>CPU周期>时钟周期。
           单周期CPU:取出并执行一条指令在一个时钟周期内完成,即一条指令用一个周期。MIPS就是一个单周期CPU。

    2.MIPS指令格式和通用寄存器定义

           MIPS所有的指令均为32位,MIPS指令的三种格式如下(op是指令码):
    MIPS指令格式描述
           R类型指令的op为0,具体操作由func指定。rs和rt是源寄存器号,rd是目的寄存器号。只有移位指令使用sa来指定移位位数。I型指令的低16位是立即数,计算时要把它扩展到32位。依指令的不同,有零扩展和符号扩展两种。零扩展是把32位的高16位置成0;符号位扩展是把高16位的每一位置成与立即数最高为相同的值,即保持立即数的正负符号不变。J型指令的指令格式最简单,右边的26位是字地址,用于产生跳转的目的地址。

           MIPS指令中的寄存器号(rs、rt和rd)有5位,因此它能访问2^5=32个寄存器。下表列出了这32个寄存器的名称和用途。

    寄存器名寄存器号用途
    $zero0常数0
    $at1汇编器专用
    v 0   v0~ v0 v12~3表达式计算或者函数调用的返回结果
    a   a~ a a34~7函数调用参数1~3
    t 0   t0~ t0 t78~15临时变量,函数调用时不需要保存和恢复
    s 0   s0~ s0 s716~23函数调用时需要保存和恢复的寄存器变量
    t 8   t8~ t8 t924~25临时变量,函数调用时不需要保存和恢复
    k 0   k0~ k0 k126~27操作系统专用
    $gp28全局变量指针(Global Poiner)
    $sp29堆栈指针(Stack Pointer)
    $fp30帧指针(Frame Pointer)
    $ra31返回地址(Return Address)

           注意:
           ①0号寄存器的内容永远是0。
           ②32号寄存器用来保存返回地址。
           上表虽然给出了使用这些寄存器的一些约定,但除了以上两点,这些寄存器并无本质的区别。因此,描述这些寄存器时可以不使用带有$的寄存器名,可以直接在r后面加寄存器号:r0,r1,…,r31。

    二、MIPS CPU

           框图:
    MIPS CPU
           IF是取指模块(Instruction Fetch),ID是译码模块,InstMen是指存(指令存储器)模块,是一个Rom芯片,RagFile是寄存器堆,EX模块是执行指令,包括写指令(用来做运算,可以认为是ALU)。

           I型指令的执行过程:
           IF的pc将指令的地址送入InstMem(指存)中,读取相应指令,pc每过一个clk就会自加4(这个过程在IF里完成),指向下一个指令。取出的指令送到ID ,ID将源寄存器的地址给regaAddress,将目的寄存器的地址给regcAddress(在I型指令中是这样,其他指令里就不一定了),将ID中的regaAddress和regaRd(读信号)送给RegFile,然后读取数据RegFile中的regaData,将RegFile的regaData送给ID的regaData_i,regaData_i会作为ID的regData送给EX。指令中的立即数也是可以在ID中直接获得的,当regaRd无效时,就会将立即数的值进行扩展,然后送给regaData。
           而运算的功能是EX模块来做的,所以ID读取数据完成后,将数据regaData,和目的寄存器地址送给EX,op是操作码,用来决定将进行何种操作,也送给EX。EX获得数据和操作码后就进行运算,运算后的结果存到regcData中,运算的结果也是要写进RegFile中的,所以EX将regcData,regcAddr(要写入的地址)和regcWr(写信号)送给RegFile,将数据写入寄存器堆保存起来,到这里这条I型指令就执行完了。
    在这里插入图片描述
           红色的线是IF要做的事,蓝色的是ID要做的事,绿色的是EX要做的事。

    三、代码设计

           IF、ID、EX和RegFile都是子模块,我们需要写一个MIPS模块调用这几个子模块,InstMem是一个单独的模块,是在MIPS外面,MIPS和InstMem相结合就组成了一个更高一级的模块,称作Soc,我们可以写一个Soc模块调用MIPS和InstMem。
    Soc系统设计
           I型指令很多,这里只举ori、addi、andi和xori指令的实现,每个模块可以参照模块图进行理解。
           ①define.v

    
    
    `define RstEnable       1'b1
    `define RstDisable      1'b0
    `define RomEnable       1'b1 
    `define RomDisable      1'b0
    `define RamWrEnable     1'b1
    `define RamWrDisable    1'b0
    `define Zero	        32'b0
    `define Valid	        1'b1
    `define Invalid	        1'b0
    
    `define Inst_addi       6'b001000
    `define Inst_andi       6'b001100
    `define Inst_ori        6'b001101
    `define Inst_xori       6'b001110
    `define Inst_lui        6'b001111
    
    `define Or              6'b000001
    `define Add             6'b000010
    `define And             6'b000100
    `define Xor             6'b000101
    
    `define Nop     6'b000000
    `define Or      6'b000001
    

           ②IF.v
    IF模块设计

    
    `include "define.v"
    module IF(
        input wire clk,
        input wire rst,
        output reg romCe, 
    output reg [31:0] pc
    );
        always@(*)
            if(rst == `RstEnable)
                romCe = `RomDisable;
            else
                romCe = `RomEnable;
        always@(posedge clk)
            if(romCe == `RomDisable)
                pc = `Zero;
            else
                pc = pc + 4;
    endmodule
    

           ③ID.v
    ID模块设计

    `include "define.v"
    module  ID (
        input wire rst,    
        input wire [31:0] inst,
        input wire [31:0] regaData_i,
        input wire [31:0] regbData_i,
        output reg [5:0] op,
        output reg [4:0] regaAddr,
        output reg [4:0] regbAddr,    
        output reg [4:0] regcAddr,    
        output reg [31:0] regaData,
        output reg [31:0] regbData,
        output reg regaRd,
        output reg regbRd,
        output reg regcWr  
    );
        wire [5:0] inst_op = inst[31:26];    
        reg [31:0] imm;
        always@(*)
            if(rst == `RstEnable)
              begin
                op = `Nop;
                regaRd = `Invalid;
                regbRd = `Invalid;
                regcWr = `Invalid;
                regaAddr = `Zero;
                regbAddr = `Zero;
                regcAddr = `Zero;
                imm = `Zero;
              end
            else  
                case(inst_op)
                    `Inst_ori:
                      begin
                        op = `Or;
                        regaRd = `Valid;
                        regbRd = `Invalid;
                        regcWr = `Valid;
                        regaAddr = inst[25:21];
                        regbAddr = `Zero;
                        regcAddr = inst[20:16];
                        imm = {16'h0, inst[15:0]};
                      end
                    `Inst_addi:
                        begin
                            op = `Add;
                            regaRd = `Valid;
                            regbRd = `Invalid;
                            regcWr = `Valid;
                            regaAddr = inst[25:21];
                            regbAddr = `Zero;
                            regcAddr = inst[20:16];
                            imm = {16'b0,inst[15:0]};
                        end
                    `Inst_andi:
                        begin
                            op = `And;
                            regaRd = `Valid;
                            regbRd = `Invalid;
                            regcWr = `Valid;
                            regaAddr = inst[25:21];
                            regbAddr = `Zero;
                            regcAddr = inst[20:16];
                            imm = {16'b0,inst[15:0]};
                        end
                    `Inst_xori:
                        begin
                            op = `Xor;
                            regaRd = `Valid;
                            regbRd = `Invalid;
                            regcWr = `Valid;
                            regaAddr = inst[25:21];
                            regbAddr = `Zero;
                            regcAddr = inst[20:16];
                            imm = {16'b0,inst[15:0]};
                        end
                    default:
                      begin
                        op = `Nop;
                        regaRd = `Invalid;
                        regbRd = `Invalid;
                        regcWr = `Invalid;
                        regaAddr = `Zero;
                        regbAddr = `Zero;
                        regcAddr = `Zero;
                        imm = `Zero;
                      end
                endcase
        always@(*)
          if(rst == `RstEnable)
              regaData = `Zero;
          else if(regaRd == `Valid)
              regaData = regaData_i;
          else
              regaData = imm;
        always@(*)
          if(rst == `RstEnable)
              regbData = `Zero;      
          else if(regbRd == `Valid)
              regbData = regbData_i;
          else
              regbData = imm; 
    endmodule
    
    
    
    

           ④EX.v
    EX模块设计

    
    
    `include "define.v"
    module EX(
        input wire rst,
        input wire [5:0] op,    
        input wire [31:0] regaData,
        input wire [31:0] regbData,
        input wire regcWr_i,
        input wire [4:0]regcAddr_i,
        output reg [31:0] regcData,
        output wire regcWr,
        output wire [4:0] regcAddr
    );    
        always@(*)
            if(rst == `RstEnable)
                regcData = `Zero;
            else
              begin
                case(op)
                    `Or:
                        regcData = regaData | regbData;
                    `Add:
                        regcData = regaData + regbData;
                    `And:
                        regcData = regaData & regbData;
                    `Xor:
                        regcData = regaData ^ regbData;
                    default:
                        regcData = `Zero;
                endcase
              end
        assign regcWr = regcWr_i;
        assign regcAddr = regcAddr_i;
    endmodule
    
    

           ⑤InstMem.v
    InstMem模块设计

    
    `include "define.v"
    module InstMem(
        input wire ce,
        input wire [31:0] addr,
        output reg [31:0] data
    );
        reg [31:0] instmem [1023 : 0];    
        always@(*)      
            if(ce == `RomDisable)
              data = `Zero;
            else
              data = instmem[addr[11 : 2]];  //??????? 
        initial
          begin
            instmem [0] = 32'h34011100;//ori:32'h00000000 or 32'h00001100 =32'h00001100
            instmem [1] = 32'h20430000;//addi:32'h00000011 add 32'h00000000 = 32'h00000011
            instmem [2] = 32'h30850001;//andi:32'h00000001 and 32'h00000101 = 32'h00000001
            instmem [3] = 32'h38C70001;//xori:32'h00000001 xori 32'h00000011 = 32'h00000010
          end
    endmodule
    

           ⑥RegFile.v
    RegFile模块设计

    
    
    `include "define.v"
    module RegFile(
        input wire clk,
        input wire rst,
        input wire we,
        input wire [4:0] waddr,
        input wire [31:0] wdata,
        input wire regaRd,
        input wire regbRd,
        input wire [4:0] regaAddr,
        input wire [4:0] regbAddr,
        output reg [31:0] regaData,
        output reg [31:0] regbData
    );
    
    
        reg [31:0] reg32 [31 : 0];    
        always@(*)
            if(rst == `RstEnable)
                regaData = `Zero;
            else if(regaAddr == `Zero)
                regaData = `Zero;
            else
                regaData = reg32[regaAddr];
        always@(*)
            if(rst == `RstEnable)          
                regbData = `Zero;
            else if(regbAddr == `Zero)
                regbData = `Zero;
            else
                regbData = reg32[regbAddr];
    
        always@(*)
            if(we == `RamWrEnable)
                reg32[waddr] = wdata;
            else
                reg32[waddr] = `Zero;
    
        initial
            begin
                reg32[0] = 32'h00000001; //ori
                reg32[2] = 32'h00000011; //addi
                reg32[4] = 32'h00000101; //andi
                reg32[6] = 32'h00000011; //xori
            end  
    endmodule
    

           ⑦MIPS.v

    
    `include "define.v"
    module MIPS(
        input wire clk,
        input wire rst,
        input wire [31:0] instruction,
        output wire romCe,
        output wire [31:0] instAddr
    );
        wire [31:0] regaData_regFile, regbData_regFile;
        wire [31:0] regaData_id, regbData_id; 
        wire [31:0] regcData_ex;
        wire [5:0] op;    
        wire regaRd, regbRd;
        wire [4:0] regaAddr, regbAddr;
        wire regcWr_id, regcWr_ex;
        wire [4:0] regcAddr_id, regcAddr_ex;
        IF if0(
            .clk(clk),
            .rst(rst),
            .romCe(romCe), 
            .pc(instAddr)
        );
        ID id0(
            .rst(rst),        
            .inst(instruction),
            .regaData_i(regaData_regFile),
            .regbData_i(regbData_regFile),
            .op(op),
            .regaData(regaData_id),
            .regbData(regbData_id),
            .regaRd(regaRd),
            .regbRd(regbRd),
            .regaAddr(regaAddr),
            .regbAddr(regbAddr),
            .regcWr(regcWr_id),
            .regcAddr(regcAddr_id)
        );
        EX ex0(
            .rst(rst),
            .op(op),        
            .regaData(regaData_id),
            .regbData(regbData_id),
            .regcWr_i(regcWr_id),
            .regcAddr_i(regcAddr_id),
            .regcData(regcData_ex),
            .regcWr(regcWr_ex),
            .regcAddr(regcAddr_ex)
        );    
        RegFile regfile0(
            .clk(clk),
            .rst(rst),
            .we(regcWr_ex),
            .waddr(regcAddr_ex),
            .wdata(regcData_ex),
            .regaRd(regaRd),
            .regbRd(regbRd),
            .regaAddr(regaAddr),
            .regbAddr(regbAddr),
            .regaData(regaData_regFile),
            .regbData(regbData_regFile)
        );
    
    endmodule
    
    
    

           ⑧Soc.v
    Soc系统设计

    
    module SoC(
        input wire clk,
        input wire rst
    );
        wire [31:0] instAddr;
        wire [31:0] instruction;
        wire romCe;    
        MIPS mips0(
            .clk(clk),
            .rst(rst),
            .instruction(instruction),
            .instAddr(instAddr),
            .romCe(romCe)
        );    
        InstMem instrom0(
            .ce(romCe),
            .addr(instAddr),
            .data(instruction)
        );
    endmodule
    
    
    

           ⑨soc_tb.v

    
    `include "define.v"
    module soc_tb;
        reg clk;
        reg rst;
        initial
          begin
            clk = 0;
            rst = `RstEnable;
            #100
            rst = `RstDisable;
            #10000 $stop;        
          end
        always #10 clk = ~ clk;
        SoC soc0(
            .clk(clk), 
            .rst(rst)
        );
    endmodule
    
    
    

           仿真波形图:

    在这里插入图片描述
           由左到右指令1、2、3、4依次是ori指令、addi指令、andi指令、xori指令的测试数据以及结果。因为没有加MEM模块,所以在EX中计算好的值,直接通过RegcData、RegcAddr和RegcWr三条线送入到RegFile里的we、waddr和w的data。

    展开全文
  • 统计学中存在两类错误 ...由实测的样本,计算出统计量的值,根据预先给定的显著性水平进行检验,作出拒绝或接受假设H0的判断。常用的假设检验方法有u—检验法、t检验法、χ2检验法(卡方检验)、F—检验

    统计学中存在两类错误

    内容参考:链接: (https://blog.csdn.net/gdp12315_gu/article/details/49976139)
    这两类错误主要是在统计学假设检验中所出现的,因此,先要了解假设检验的基本概念。

    1.假设检验

    • 假设检验(Hypothesis Testing)是数理统计学中根据一定假设条件由样本推断总体的一种方法。具体作法是:根据问题的需要对所研究的总体作某种假设,记作H0;选取合适的统计量,这个统计量的选取要使得在假设H0成立时,其分布为已知;由实测的样本,计算出统计量的值,并根据预先给定的显著性水平进行检验,作出拒绝或接受假设H0的判断。常用的假设检验方法有u—检验法、t检验法、χ2检验法(卡方检验)、F—检验法,秩和检验等

    • 假设检验(反证法的思想),依据样本统计量作出的统计推断,其推断结论并非绝对正确,结论有时也可能有错误,错误分为两类。

    2.两类错误

    • 简单来说,
      第一类错误,拒绝了实际上成立的,为“弃真”的错误
      第二类错误,不拒绝实际上不成立的,为“存伪”的错误
      假设检验时,根据检验结果作出的判断,即拒绝H0 或不拒绝H0 。

    • 第一类错误(typeⅠerror),Ⅰ型错误,拒绝了实际上成立的H0 ,即错误地判为有差别,这种弃真的错误称为Ⅰ型错误。其概率大小用即检验水准用α表示。α可取单尾也可取双尾。假设检验时可根据研究目的来确定其大小,一般取0.05或者0.01,当拒绝H0时则理论上理论100次检验中平均有5次或者1次发生这样的错误。

    • 第二类错误(typeⅡ error)。Ⅱ型错误,接受了实际上不成立的H0 ,也就是错误地判为无差别,这类取伪的错误称为第二类错误。第二类错误的概率用β表示,β的大小很难确切估计。

    • 当样本例数固定时,α愈小,β愈大;反之,α愈大,β愈小。因而可通过选定α控制β大小。要同时减小α和β,唯有增加样本例数。统计上将1-β称为检验效能或把握度(power of a test),即两个总体确有差别存在,而以α为检验水准,假设检验能发现它们有差别的能力。实际工作中应权衡两类错误中哪一个重要以选择检验水准的大小。

    假设检验时应注意的事项

    • (一)要有严密的抽样研究设计;样本必须是从同质总体中随机抽取的;要保证组间的均衡性和资料的可比性。
    • (二)根据现有的资料的性质、设计类型、样本含量大小正确选用检验方法。
    • (三)对差别有无统计学意义的判断不能绝对化,因检验水准只是人为规定的界限,是相对的。差别有统计学意义时,是指无效假设H0 被接受的可能性只有5%或不到5%,甚至不到1%,根据小概率事件一次不可能拒H0 ,但尚不能排除有5%或1%出现的可能,所以可能产生第一类错误;同样,若不拒绝H0 ,可能产生第二类错误。
    • (四)统计学上差别显著与否,与实际意义是有区别的。如应用某药治疗高血压,平均降低舒张压0.5kPa,并得出差别有高度统计学意义的结论。从统计学角度,说明该药有降压作用,但实际上,降低0.5kPa是无临床意义。因此要结合专业作出恰如其分的结论。

    补充

    • 假设验证无非是一个数学结构。在涉及这样的一个数学结构(检验策略)的时候,统计学家说:“我必将Type I error 发生的概率控制在0.05以内,并在这个前提下尽可能减小Type II error发生的概率(但减小到什么程度我就不能保证了)。”所以,统计学家的听众们就知道了,在统计学家设计的这个数学结构中,I error发生的概率是可以完美控制的。听众们想利用这个数学结构来检验一些命题,以此来解决一些实际问题,但是人们不想犯错误,所以,人们通过合理挑选原假设、备择假设,以使得其最不想犯的错误恰为可以完美控制发生概率的Type I error。

    所以,为什么第一类错误更有价值?因为在使用假设检验进行分析时,人们就将不想犯的根本性错误放在了被该方法可控的第一类错误的位置,所以第一类错误往往会揭示实验体系存在根本性错误,而第二类错误则不能排除误差的可能的,或者说实验体系本身没问题,只是精确度上还有待完善。

    示例辅助理解

    • typeI error和typeII error在生物统计背景下有一个很好的解释。
      假设现在有一批药需要测试疗效。H0:这批药没效果H1:这批药有效果α=H0真时拒绝H0,拒真错误。对应到现实里是,拒绝没效果=有效果。我们认为一批药有效果以后将给病人吃,但其实这批药是没效果的,那病人吃了以后就死了呀,这个α对应的是人生命的风险,是消费者风险。β=H0错时接受H0,取伪错误。接受无效,一批药明明有效确认为它无效。这个充其量就是药厂不会生产这种药,但还有什么阿司匹林,阿莫西林其他的药可以生产,威胁不到人的生命,是一种生产者风险。生命高于金钱,所以在控制两类错误时,我们优先控制type I error,一般都是规定好的0.05,然后想办法降低typeII error。关于α和β,和第I和第II类错误的命名我觉得也是这样的,因为人们觉得第I类错误比第II类错误更加重要,而希腊字母里α也排的比β前,越重要的东西越放在前面。
      作者:逍遥温温
      链接:https://www.zhihu.com/question/37437658/answer/332072770

    • 一般情况下,零假设代表无效、无作用或者无影响,而备选假设代表有效、有作用或者有影响。出于谨慎目的,我们会特别在意,实际无效但被我们判断有效的第一类型错误。比如在验证自己设计新算法有效性实验中,如果我们能控制算法实际无效但被我们判断有效的第一类型错误,只要我们做出“新算法有效”的结论,这个结论就一定是坚实的。至于本来新算法有效而被我们认为无效,这样的第二类错误可以狗带了。
      作者:AlgorithmDog
      链接:https://www.zhihu.com/question/37437658/answer/72020413

    • 链接:https://www.zhihu.com/question/37437658/answer/75413132
      H0:A是好人。
      H1:A是坏人。
      这个时候法官要怎么判?如果A是好人,但是却判成了坏人,这就是犯了第一类错误,拒真错误。但是如果A是坏人,却错判成了好人,这就是犯了第二类错误。这时候法官问陪审团怎么看。
      法官问了陪审团100个人如下2个问题:
      问题1:A是不是好人吗?
      问题2:A是不是坏人吗?
      有一些陪审员坚定的认为A是好人,另一些人为A是坏人,但是还有一些人说不准,并不知道是不是好人,还有的人觉得A应该不是好人,但是又不能说A是坏人。
      结果这四个问题的投票结果如下:

      100个人里面,有97个说,他不是好人,但是还有3个人坚定的说A是好人。这就是P值为0.03。也就是如果他是好人,那么犯错的概率应该是0.03。另一方面,100个人里面却只有45个人认为,他应该是坏人。所以如果A是坏人,那么犯第二类错误的概率应该是0.55。
      这时候法官要如何判决呢?这就要给定一些条件了。如果你说,我宁可错杀三千,绝不放过一个!那你就让第二类错误的概率尽可能小。只要陪审员里面有足够的人认为他是坏人,那么我就判他是坏人。比如这个投票结果中,只有45个人认为是坏人,如果这样就判定A是坏人的话,可能就很武断了。这样判刑带来的代价是很可怕的。政治清明的年代,司法应该尽可能减少冤假错案,即所谓疑罪从无_百度百科和无罪推定_百度百科的原则。也就是,如果没有足够的人说A不是好人,那么司法就应该判定A为好人。因此,全国最高法院给出了这样的标准是:100个人里面只有至少有95个人说他不是好人,那么才能判决A有罪。如果这样,在这个例子中法官就可以判A有罪了。用统计学的语言说,就是,在alpha=0.05的置信水平下,P=0.03,拒绝了原假设。此时犯第二类错误的概率为0.55。但是如果最高法院设定的标准为100个人里面,需要有99个人说A不是好人,才可以判刑,那么法官只能将A无罪释放了。
      这里并不是说不用避免犯第二类错误,第二类错误也是需要尽量避免的。只不过根据无罪推定原则和疑罪从无原则,我们应该控制的是尽可能别把没罪判为有罪,其次应该控制的才是尽可能减少让有罪的人继续逍遥法外。
      如果还有另外一组陪审员更明察秋毫,纠结的人很少,判案比较果断的话,那么这组陪审员的判案效果是要好过之前的这组陪审员的。比如他们对法官的两个问题的解释是:
      那么这组陪审员给出的检验结果就很好。统计学的话就是:犯第一类错误的概率为0.03,犯第二类错误的概率为0.1。这组陪审员与第一组陪审员相比,在犯第一类错误的概率相等的情况下,犯第二类错误的概率更小。这样的陪审员才是好的陪审员啊!(也就是检验2优于检验1)
      那么如何寻找这样优秀的陪审员呢?N-P引理告诉我们,如果我们控制犯第一类错误的概率在某个限度内,去寻找犯第二类错误可能最小的检验,在这样的准则下,似然比检验 wikipedia.org 的页面 就是最优的。

    展开全文
  • 第一类错误即 I 错误是拒绝了实际上成立的H0,为“弃真”的错误,其概率通常用α表示,这称为显著性水平。α可取单侧也可取双侧,可以根据需要确定α的大小,一般规定α=0.05或α=0.01。 第二类错误即 II 错误...

     

    简介

    我们不妨先看下定义:

    第一类错误:原假设是正确的,却拒绝了原假设。
    第二类错误:原假设是错误的,却没有拒绝原假设。

    第一类错误即 I 型错误是指拒绝了实际上成立的H0,为“弃真”的错误,其概率通常用α表示,这称为显著性水平。α可取单侧也可取双侧,可以根据需要确定α的大小,一般规定α=0.05或α=0.01。
    第二类错误即 II 型错误是指不拒绝实际上不成立的H0,为“存伪”的错误,其概率通常用β表示。β只能取单尾,假设检验时一般不知道β的值,在一定条件下(如已知两总体的差值δ、样本含量n和检验水准α)可以测算出来。

    来自:传送门

    我们知道,一型错误往往利用 α分位数进行假设推断,而二型错误我们则用 β 值进行衡量

    一,二型错误之间的联系

    对于实际情况来说,我们可以看到预测情况与真实情况之间的数量关系,即混淆矩阵:

     

     

    我们假设有原假设H0和备择假设H1,那么利用自己的data构造统计量,即构造某种满足H0的统计量分布;同样的我们也可以构造某种满足H1的统计量分布:

     


    其中虚线表示分位数 α , 黑色曲线表示H0统计量分布,红色曲线表示H1统计量分布
    这样一来,H0极端情况(小概率事件)为虚线右侧与黑色分布曲线相围成的面积,并且定义为FP(α);对于H1极端情况(小概率事件)为虚线左侧与红色分布曲线相围成的面积,并且定义为FN(β)

    那么倘若我们想降低一型错误发生率,即将虚线往右移动,那么势必会增大二型错误发生率;同样,我们想降低二型错误发生率,即将虚线往右移动,那么势必会增大一型错误发生率
    唯一降低两型错误发生率的办法是提高样本量,使得二者分母都变大

    拓展

    我们往往在做统计推断的时候只考虑一型错误发生情况(即 α 分位数),那是因为我们往往围绕H0构造统计量(比较好构造);而H1的统计量分布往往不太好求,并且二型错误发生情况必须知道H1的统计量分布才能求出,所以我们一般做简单的统计推断时不考虑二型错误

    展开全文
  • CPU密集也叫计算密集的是系统的硬盘、内存性能相对CPU要好很多,此时,系统运作大部分的状况是CPU Loading 100%,CPU要读/写I/O(硬盘/内存),I/O在很短的时间就可以完成,而CPU还有许多运算要处理,CPU ...
  • CPU密集I/O密集

    千次阅读 2017-03-06 17:26:26
    引用至:> http://blog.csdn.net/q_l_s/article/details/51538039CPU密集: cpu密集也称为计算密集,在多重程序系统中,大部分时间... I/O密集型指的是系统的CPU效能相对于硬盘/内存要好很多,大部分时间都是
  • 计算密集应用领域的软件系统是CPU资源消耗多, 计算量大的系统,主要以追求计算速度为主要指标。例如超级计算机。 特点: 传统的计算密集应用往往通过并行计算方式在紧耦合的超级计算机上运行少量计算作业...
  • CPU-bound(计算密集) 和I/O bound(I/O密集)

    万次阅读 多人点赞 2016-05-30 15:02:32
    I/O bound 的是系统的CPU效能相对硬盘/内存的效能要好很多,此时,系统运作,大部分的状况是 CPU 在等 I/O (硬盘/内存) 的读/写,此时 CPU Loading 不高。 CPU bound 的是系统的 硬盘/内存 效能 相对 CPU 的效能...
  • I/O基础知识:什么是I/O设备?

    千次阅读 2020-07-17 19:03:01
    OS(操作系统)必须向设备发送命令、捕捉中断处理错误、还应该在设备和OS之间提供一个接口 不同的人对I/O设备的理解是不同的: 电子工程师眼中:I/O设备是硬件即芯片、导线、电源和其他组成硬件的物理设备 ...
  • CPU密集与IO密集

    千次阅读 2021-11-12 21:04:14
    CPU密集也叫计算密集的是系统的硬盘、内存性能相对CPU要好很多,此时,系统运作大部分的状况是CPU Loading 100%,CPU要读/写I/O(硬盘/内存), I/O在很短的时间就可以完成,而CPU还有许多运算要处理,CPU ...
  • 不是医疗器械分类。 —————————————————————— 医疗电气设备按照“设备防电击的程度”可以划分为三类: B:对电击有特定防护的设备。如:彩超、电子血压计等。 BF:具有F隔离应用部分的...
  • i++ 、 ++ii+=1、i=i+1 的问题

    万次阅读 多人点赞 2019-04-19 22:36:40
    i++ 、 ++ii+=1、i=i+1 等这类问题是也笔试必考内容之一,基础中的基础。如果不会,那就已经可以看出你个人的基础水平了。虽然看上去简单,但是不懂原理是不行的。只有了解原理才能记忆最深 i++ 和 ++i 的区别: ...
  • 操作系统 I/O 全流程详解

    千次阅读 多人点赞 2020-06-18 11:18:24
    操作系统必须向设备发送命令,捕捉中断处理错误。它还应该在设备和操作系统的其余部分之间提供一个简单易用的接口。操作系统如何管理 I/O 是我们接下来的重点。 不同的人对 I/O 硬件的理解也不同。对于电子工程师...
  • 一篇文章带你看遍Google I/O 2019大会

    万次阅读 多人点赞 2019-05-13 07:21:24
    为期三天的Google I/O 2019大会终于在上周落下了帷幕,每年的Google I/O大会都可以说是一场全球的开发者盛宴。不过可惜的是,由于和美国存在时差,I/O大会的直播时间正好是我们这边的深夜,因此对于大多数的人来说...
  • CPU密集也叫计算密集的是系统的硬盘、内存性能相对CPU要好很多,此时,系统运作大部分的状况是CPU Loading 100%,CPU要读/写I/O(硬盘/内存),I/O在很短的时间就可以完成,而CPU还有许多运算要处理,CPU ...
  • 计算密集和IO密集

    千次阅读 2019-04-23 19:19:27
    什么是计算密集 计算密集就是计算、逻辑判断量非常大而且集中的类型,因为主要占用cpu资源所以又叫cpu密集,而且当计算任务数等于cpu核心数的时候,是cpu运行效率最高的时候。 特点:消耗cpu 什么是IO密集 ...
  • 一般来讲I/O端口就是一组寄存器,本质上跟内存一样。所以计算机对I/O端口寻址,有两种方式,一种是将内存寻址和I/O端口寻址整合在一起,即使用同一控制总线和数据总线。第二种是,I/O端口和内存复用数据总线,分别...
  • 关系数据库的ACID的是什么?

    千次阅读 2017-11-25 11:44:55
    关系数据库的ACID: 1、A (Atomicity) 原子性 原子性很容易理解,也就是说事务里的所有操作要么全部做完,要么都不做,事务成功的条件是事务里的所有操作都成功,只要有一个操作失败,整个事务就失败,需要回滚...
  • 求若当标准的变换矩阵

    千次阅读 2020-11-19 14:52:29
    已知 A=[200140102] A = \begin{bmatrix} 2 &...∣λI−A∣=∣λ−200−1λ−40−10λ−2∣=(λ−2)2(λ−4)=0 |\lambda I - A| = \begin{vmatrix} \lambda -2 & 0 &0 \\ -1 & \lamb
  • offer(41-50题)详解

    千次阅读 2020-01-26 21:52:56
    但是他不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? ...
  • I2C部分已经接近尾声了,接下来...如 I2C 仲裁、Linux I2C 工具查看配置I2C设备、什么是漏极开路等等。 一、动手画出I2C时序图 看了那么多东西,都记不牢的或者理解不透。只有亲自画出时序图,你才能明白的。 ...
  • 所谓IO密集任务,是磁盘IO、网络IO占主要的任务,计算量很小。比如请求网页、读写文件等。当然我们在Python中可以利用sleep达到IO密集任务的目的。 所谓计算密集任务,是CPU计算占主要的任务,CPU一直...
  • Offer66题之每日6题 - 第二天

    千次阅读 2017-12-29 20:44:25
    整数只能保存 F 0 → F 46 F 0 → F 46 F_0 \to F_{46} ,下面是这个区间的斐波拉契数列的值: 0: 0 1: 1 2: 1 3: 2 4: 3 5: 5 6: 8 7: 13 8: 21 9: 34 10: 55 11: 89 12: 144 13: 233 14: 377 15: 610 16: ...
  • i.MX8系列应用处理器是恩智浦针对高端应用市场推出的旗舰产品。恩智浦半导体日前又推出全新的i.MX 8X系列,进一步扩大了i.MX 8系列应用处理器的可扩展范围。i.MX 8X系列沿用了高端i.MX 8系列的通用子系统和架构,...
  • RV32I 六种指令格式

    千次阅读 2020-06-18 17:09:17
    RV32I 有六种基本指令格式...令,用于短立即数和访存load 操作的I 指令,用于访存store 操作的S 型指 令,用于条件跳转操作的B 类型指令,用于长立即数的U 指令和用于无条件 跳转的J 指令。 指令参考卡: ...
  • 函数数据主成分分析(FPCA)

    千次阅读 多人点赞 2019-11-24 19:57:27
    更近一步,我们介绍了函数主成分分析方法(FPCA),包括其基本思想、数学推导、算法描述等,最为重要的是,我们将该方法和本领域进行结合,有了一些新的思考,感谢"数据科学与矩阵优化"课程给带来的灵感。...
  • (1)char字符数据可以转换成任意一种数值类型,反之亦然。将整数转换成插入数据时,只用到该数据的低十六位,其余部分被忽略。如:char ch=(char)0xAB0041;输出ch+‘A’; (2)将一个浮点值转换成char时,首先...
  • T知识结构

    千次阅读 2017-03-21 09:09:54
    前三个类型一般是专业技术人才,在某种程度上相当于传统知识结构。后三个类型则是掌握两个以上领域的通才。而所谓"T"知识结构,也就是纵横交错的知识结构。这里的"纵",表示某一专业知识方面的深度;这里的"横
  • 多线程之IO密集和CPU密集

    千次阅读 2018-09-11 10:35:33
    CPU密集也叫计算密集的是系统的硬盘、内存性能相对CPU要好很多,此时,系统运作大部分的状况是CPU Loading 100%,CPU要读/写I/O(硬盘/内存),I/O在很短的时间就可以完成,而CPU还有许多运算要处理,CPU ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 362,299
精华内容 144,919
关键字:

并指i型