栈的一个应用—关于中缀和后缀表达式求值

表达式求值(后缀表达式)(数据结构) 如果每个操作符跟在它的两个操作数之后,而不是两个操作数之间,那么这个表达式就是后缀表达,又称为逆波兰表达式,如:3 5 + 7 * 1 -2.从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,其中先出栈的是右操作数,后出栈的是左操作数,5)遇到+运算符,弹出20和1,计算1+20的值,得到21,将21压入栈;4)遇到×运算符,弹出4和5,计算5×4的值,得到20,将20压入栈;2)遇到+运算符,3和2弹出,计算2+3的值,得到5,将5压入栈;6)遇到5,将5压入栈; 阅读详情

栈的一个应用—关于中缀和后缀表达式求值

  1. 中缀表达式直接转化为后缀表达式求值:
import java.util.Stack;
public class Suffix {
 static Stack<Character> op = new Stack<>();
    /*将中缀表达式转化为后缀表达式*/
    public static String tosuffix(String str) {
     char[]  str1=str.toCharArray();
     int len=str1.length;
        String res="";
        for(int i=0;i<len;i++) {
         char ch=str1[i];
         if(ch==' ') {continue;}
         if(ch>='0'&&ch<='9') {
          res=res+ch;
          continue;
         }
         if(ch=='('){
          op.push(ch);
         }
         if(ch=='+'||ch=='-') {
          while(!op.isEmpty()&&op.peek()!='(') {
           res+=op.pop();}
          op.push(ch);
             continue;
         }
         if(ch=='*'||ch=='/') {
          while(!op.isEmpty()&&(op.peek()=='*'||op.peek()=='/')) {res=res+op.pop();}
          op.push(ch);
          continue;
         }
         if(ch==')') {
          while(!op.isEmpty()&&op.peek()!='(') {
           res+=op.pop();
          }
          op.pop();
          continue;
         }
        }
        while(!op.empty()) {res+=op.pop();}
        return res;
    }
    //求值
    public static Float getValue(String str) {
     Stack<Float> v = new Stack<>();        
     char[] arr = str.toCharArray();        
     int len = arr.length;        
     for(int i = 0; i < len; i++){            
      Character ch = arr[i];             // if is operand, push to the stack            
      if(ch >= '0' && ch <= '9') 
       v.push(Float.valueOf(ch - '0'));             
      // if is operator, calculate the result            
      // with top 2 operands in the stack,            
      // push the result into the stack            
      else v.push(caculate(ch, v.pop(), v.pop()));        }        
     return v.pop();
     }
    public static Float caculate(char op,Float num1,Float num2) {
     switch(op) {
     case'+':
      return num1+num2;
     case'-':
      return num2-num1;
     case'/':
      return num2/num1;
     case'*':
      return num2*num1;
     default:return Float.valueOf(0);
     }
    } 
    public static void main(String[] args) {
     String str="5+4*3";
     System.out.println(getValue(tosuffix(str)));
     
    }
}
  1. 注:数字只能选择0-9之间的数字,而不能选择其他数字。
    要想更进一步输入双位数,则可以将数组的下一位也在同一步中进行判断,然后删除下一个数组的对应 元素,使得单一位存储双数个,而数组也将改为string类型。
    实现(先转化为数组,然后,在):
private static String[] strToExpressionArr(String str) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) < '0' || str.charAt(i) > '9') {
                str = str.substring(0, i) +" " + str.charAt(i) + " " +str.substring(i + 1, str.length());
                i += 2;
            }
        }
        Scanner sc = new Scanner(str);
        while (sc.hasNext())
            list.add(sc.next());
        return list.toArray(new String[list.size()]);
    }
  1. 利用双栈实现不转化就求值(其实相当于上面的两个栈,只不过是把中缀表达式转化为后缀表达式的过程变为分别将op与数据分别存入不同的栈中,然后挨个操作,符号边进栈边计算)
    重点是多了优先级的判断(*/±)。
 package 栈;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;
//不借助中缀表达式转化为后缀表达式的方法:将op与num分别存入两个不同的栈
public class caculator {
 public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个算术表达式:");
        String str = input.nextLine();
        compute(str);
    }
     //用字符串做参数重载的计算函数,调用下面用字符串数组做方法参数的函数
  public static void compute(String expression) {
        String[] arr = strToExpressionArr(expression);
        if (isLegalExpression(arr))
            System.out.println(compute(strToExpressionArr(expression)));
        else
            System.out.println("请输入合法表达式");
    }
    private static String[] strToExpressionArr(String str) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) < '0' || str.charAt(i) > '9') {
                str = str.substring(0, i) +" " + str.charAt(i) + " " +str.substring(i + 1, str.length());
                i += 2;
            }
        }
        Scanner sc = new Scanner(str);
        while (sc.hasNext())
            list.add(sc.next());
        return list.toArray(new String[list.size()]);
    }
    //计算算术表达式
    private static int compute(String[] expression) {
        Stack<Integer> numStack = new Stack<>();
        Stack<Character> opStack = new Stack<>();
        for (int i = 0; i < expression.length; i++) {
            String ele = expression[i];
            //如果是数字,进入数字栈
            if (isNumber(ele)) {
                numStack.push(new Integer(ele));
            }
            //以下是符号
            //遇到加减号,把栈顶的符号都处理完,直到遇到(左括号和栈空情况,最后把提取到的符号压入栈
            else if (ele.charAt(0) == '+' || ele.charAt(0) == '-') {
                while (!opStack.isEmpty() && opStack.peek() != '(') {
                    int b = numStack.pop();
                    int a = numStack.pop();
                    numStack.push(getAnswer(a, opStack.pop(), b));
                }
                if (!opStack.isEmpty() && opStack.peek() == '(')
                    opStack.pop();
                opStack.push(ele.charAt(0));
            }
            //遇到乘除号,把前面的乘除号处理完,最后把提取到的符号压入栈
            else if (ele.charAt(0) == '*' || ele.charAt(0) == '/') {
             //注意下一步中关于优先级的判断
                while (!opStack.isEmpty() && opStack.peek() != '(' &&
                        opStack.peek() != '+' && opStack.peek() != '-') {
                    int b = numStack.pop();
                    int a = numStack.pop();
                    numStack.push(getAnswer(a, opStack.pop(), b));
                }
                if (!opStack.isEmpty() && opStack.peek() == '(')
                    opStack.pop();
                opStack.push(ele.charAt(0));
            }
            //遇到左括号,只进栈
            else if (ele.charAt(0) == '(') {
                opStack.push(ele.charAt(0));
            }
            //遇到右括号,只处理栈顶全部符号
            else if (ele.charAt(0) == ')') {
                while (!opStack.isEmpty() && opStack.peek() != '(') {
                    int b = numStack.pop();
                    int a = numStack.pop();
                    numStack.push(getAnswer(a, opStack.pop(), b)); }
                if (!opStack.isEmpty() && opStack.peek() == '(')
                    opStack.pop();
            }
        }
        //最后没有以右括号结尾的表达式还得另外把剩下的符号处理完
        if (!opStack.isEmpty()) {
            int b = numStack.pop();
            int a = numStack.pop();
            numStack.push(getAnswer(a, opStack.pop(), b));
        }
        return numStack.peek();
    }
    //判断是否数字
    private static boolean isNumber(String s) {
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) < '0' || s.charAt(i) > '9')
                return false;
        }
        return true;
    }
    //四则运算
    private static int getAnswer(int a, char operator, int b) {
        switch (operator) {
            case '+': return a + b;
            case '-': return a - b;
            case '*': return a * b;
            case '/': return a / b;
        }
        return 0;
    }
    //判断表达式是否合法(加减乘除号左右必然有左端与右端、括号要一一对应(与做运算时候的判断方法相同))
    static boolean isLegalExpression(String[] arr) {
        //表达式的开头和结尾不能出现加减乘除符号
        char hc = arr[0].charAt(0);
        char tc = arr[arr.length - 1].charAt(0);
        if (hc == '+' || hc == '-' || hc == '*' || hc == '/' ||
                tc == '+' || tc == '-' || tc == '*' || tc == '/')
            return false;
        //括号要一一对应,而且开头不能是右括号,结尾不能是左括号
        Stack<Character> stk = new Stack();
        for (String s : arr) {
            if (s.charAt(0) == '(')
                stk.push(s.charAt(0));
            else if (s.charAt(0) == ')') {
                if (stk.isEmpty())
                    return false;
                stk.pop();
            }
        }
        if (!stk.isEmpty())
            return false;
        //不能出现非法字符,就是除了加减乘除和括号和数字外,不能出现其他字符
        String ts = "";
        for (String s : arr) {
            ts += s;
        }
        for (char c : ts.toCharArray()) {
            if (c != '+' && c != '-' && c != '*' && c != '/' && c != '(' && c != ')'&&!(c >= '0' && c <= '9'))
                return false;
        }
        //看每个数字两边是否缺少符号操作和每个符号两边是否缺少数字
        for (int i = 0; i < arr.length; i++) {
            char c = arr[i].charAt(0);
        //数字
            if (isNumber(arr[i])) {
                boolean hasLeft = true;
                boolean hasRight = true;
            if (i == 0)
                    hasLeft = false;
            if (i == arr.length - 1)
                    hasRight = false;
            //看左边是否有符号
                if (i > 0) {
                    char cha = arr[i - 1].charAt(0);
                    if (cha != '+' && cha != '-' && cha != '*' && cha != '/')
                        hasLeft = false;
                }
                //看右边有没有符号
                if (i < arr.length - 1) {
                    char cha = arr[i + 1].charAt(0);
                    if (cha != '+' && cha != '-' && cha != '*' && cha != '/')
                        hasRight = false;
                }
                //都没有就非法
                if (!hasLeft && !hasRight)
                    return false;
            }
            //运算符
            else if ( c == '+' || c == '-' || c == '*' || c == '/') {
                boolean hasLeft = true;
                boolean hasRight = true;
                if (i == 0)
                    hasLeft = false;
                if (i == arr.length - 1)
                    hasRight = false;
                //看左边是否有数字
                if (i > 0) {
                    if (!isNumber(arr[i - 1]))
                        hasLeft = false;
                }
                //看右边有没有数字
                if (i < arr.length - 1) {
                    if (!isNumber(arr[i + 1]))
                        hasRight = false;
                }
                //都没有就非法
                if (!hasLeft && !hasRight)
                    return false;
            }
        }
        return true;
    }
}

                
【c++】后缀表达式求值(详解) 后缀表达式的介绍和详细代码实现,计算逆波兰表达式的结果,用C++实现 阅读详情

相关推荐

栈的应用之表达式求值(前缀、中缀、后缀)

继续遍历,出现“/”,与此时栈顶元素“*”优先级相等,出栈顶元素*,并且进行运算3*6=18而不是6*3=18,入栈OPND,然后“/”入栈OPTR。继续遍历,2入栈,-比/优先级低,所以/出栈,OPND也要出栈2个元素,计算18/2=9,入栈,-也入栈;得到9后,继续遍历,5入栈,无元素再遍历,所以9-5=4,-出栈,而OPND只剩一个4,得到结果。遇到+运算符,因此弹出3和4(3为栈顶元素,4为次顶元素),计算出3+4的值,得7,再将7入栈;次栈顶元素加减乘除栈顶元素!次栈顶元素加减乘除栈顶元素!

2301_79705447的博客 1755

中缀表达式转换为后缀表达式

一、后缀表达式求值 后缀表达式也叫逆波兰表达式,其求值过程可以用到栈来辅助存储。假定待求值的后缀表达式为:6  5  2  3  + 8 * + 3  +  *,则其求值过程如下: 1)遍历表达式,遇到的数字首先放入栈中,此时栈如下所示: 2)接着读到“+”,则弹出3和2,执行3+2,计算结果等于5,并将5压入到栈中。 3)读到8,将其直接放入栈中。 4)读到“*”,弹出8和

__七把刀__ 17万+

数据结构——栈:栈的应用:表达式求值

前缀表达式的计算机求值从右至左扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(栈顶元素 op 次顶元素),并将结果入栈;重复上述过程直到表达式最左端,最后运算得出的值即为表达式的结果例如:- × + 3 4 5 61. 从右至左扫描,将6、5、4、3压入堆栈2. 遇到+运算符,因此弹出3和4(3为栈顶元素,4为次顶元素,注意与后缀表达式做比较)...

sunshare77的博客 3002

【数据结构】 后缀表达式求值

后缀表达式求值后缀表达式是什么后缀表达式运算规则为什么使用后缀表达式流程图解代码实现(c++)重要代码栈的数据结构操作栈的方法判断是否为操作符计算结果后缀表达式计算主函数总结 后缀表达式是什么 后缀表达式也称逆波兰式(Reverse Polish notation,RPN,或逆波兰记法),也叫后缀表达式(将运算符写在操作数之后)。 若是没有学习过计算机知识可能一辈子都不会接触到这个表达式,我们日常生活中使用最频繁的是中缀表达式,例如1+1就是一个中缀表达式,其实就是操作符在俩操作数之间的表达式。 那么由中缀

就很有趣的博客 1万+

前缀中缀后缀表达式介绍

一前缀表达式 1 前缀表达式又称波兰式,前缀表达式的运算符位于操作数之前。 2 举例 (3+4)×5-6 对应的前缀表达式是: - × + 3 4 5 6 3前缀表达式的计算机求值过程 从右至左扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(栈顶元素 和 次顶元素),并将结果入栈;重复上述过程直到表达式最左端,最后运算得出的值即为表达式的结果。 例如: (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 , 针对前缀表达...

实践求真知 1万+

常用数据结构栈的应用—-表达式求值

常用数据结构栈的应用—-表达式求值 常用数据结构栈的应用-表达式求值 栈 表达式求值 后缀表达式求值 中缀表达式转后缀表达式 代码示例栈 栈是常用的数据结构,栈又称堆栈,是一种受限的线性表。其限制是允许在表中的一端进行插入和删除元素。栈中的元素符合后进先出(FILO)的性质。允许插入和删除元素的一端被称为栈顶,另一端被称为栈底。 栈有两种关键的操作,分别为出栈和压栈。 栈有两种关键的操作,

Spground 1万+

后缀表达式

后缀表达式:不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则,如:(2 + 1) * 3 , 即2 1 + 3 *

当凌绝顶,俯瞰天下 2251

栈的应用——表达式求解,中缀表达式转换成后缀表达式

栈的应用——表达式求解,内容主要有 中缀表达式转换成后缀表达式以及求解过程,需要可自行下载

【尚硅谷_数据结构与算法】四、栈

文章目录参考资料1. 定义2. 应用场景3. 实现3.1 用数组实现4. 应用4.0 前缀、中缀、后缀表达式(逆波兰表达式)知识4.0.1. 前缀表达式4.0.2. 中缀表达式4.0.3. 后缀表达式4.1 表达式求值(中缀表达式)4.2 中缀转后缀4.3 逆波兰计算器 参考资料 https://www.bilibili.com/video/BV1E4411H73v?p=30 Java数据结构与算法 1. 定义 栈(Stack)是一个先入后出(FILO-First In Last Out)的有序列表。

weixin_42301220的博客 590

自定义栈中缀表达式转换为后缀表达式并求值

自定义栈,中缀表达式转换为后缀表达式并求值,三个抽象数据类型定义(1.class stack 2.class Middle_expressionToPost_expression 3.class Post_expression_value)

栈的应用之中缀表达式求值(QT平台)

本程序利用两个栈——一个符号栈一个数字栈,实现了中缀表达式的计算,代码风格是C++,运行平台是QT,欢迎大家下载参考。

栈和逆波兰表达式

中缀表达式 1+2,1+3*2,1+(3*2*(1+3)),这些就是中缀表达式,就是我们平时经常见到的形式,先算加减再算乘除,有括号的先算括号里面的,没有括号按照优先级顺序进行计算。但是,计算机处理中缀表达式却并不方便,因为没有一种简单的数据结构可以方便从一个表达式中间抽出,一部分算完结果,再放进去,然后继续后面的计算(链表也许可以,但是,代价也是不菲)。 若用链表进行计算,不断地更新值...

cjh1459463496的博客 479

STM32CubeMx搭建LWIP程序

  使用STM32CubeMx5.21,在stm32f745平台上搭建ethernet通信程序,PHY选用KSZ8081RNB。(LAN8742/DP83848使用一样) 1、系统时钟设置   RCC设置,勾选外部高速时钟源。   系统时钟配置。写入外部晶振频率、HSE提供PLCCLK、HCLK,其他参数自动生成。 2、ETH设置   勾选设置NVIC。   根据硬件设置对应GPIO引脚。   参数设置默认   根据硬件设置PHY地址,其他参数默认。 3、LWIP设置   勾选使能,通用参数设置

Gandalf94的博客 3240

【尚硅谷】Java数据结构与算法笔记04 - 栈

栈的英文为(stack)栈是一个先入后出(FILO-First In Last Out)的有序列表。栈(stack)是限制线性表中元素的揷入和删除只能在线性表的同一端进行的一种特殊线性表。允许揷入和删除的 一端, 为变化的一端, 称为栈顶(Top), 另一端为固定的一端, 称为栈底(Bottom)。根据栈的定义可知, 最先放入栈中元素在栈底, 最后放入的元素在栈顶, 而删除元素刚好相反, 最后放入的元 素最先删除, 最先放入的元素最后删除图解方式说明出栈(pop)和入栈(push)的概念。

知不足而奋进,望远山而前行 2万+

Unity 2022打包Android APK:手把手教你创建和配置第一个签名Keystore(避坑指南)

本文详细介绍了Unity 2022打包Android APK时创建和配置签名Keystore的全流程,包括环境准备、Keystore创建、高级配置避坑指南以及签名验证与故障排查。特别强调了Android应用签名的重要性及安全维护策略,帮助开发者避免常见错误,确保应用顺利发布。

weixin_27379781的博客 243

2024从零开始使用VSCode编程(静态页面制作篇)HTML+CSS+JS阶段

VSCode第一个前端静态页面的编写

ssrsrrn的博客 9593

java数据结构栈的应用—逆波兰式

逆波兰式

weixin_46683791的博客 249

单细胞测序流程(八)单细胞的marker基因转化和​GO富集分析

系列文章目录 单细胞测序流程(一)简介与数据下载 单细胞测序流程(二)数据整理 单细胞测序流程(三)质控和数据过滤——Seurat包分析,小提琴图和基因离差散点图 单细胞测序流程(四)主成分分析——PCA 单细胞测序流程(五)t-sne聚类分析和寻找marker基因 单细胞测序流程(六)单细胞的细胞类型的注释 单细胞测序流程(七)单细胞的细胞类型轨迹分析———————————————— 本期主讲内容——单细胞的maeker基因转化和​富集分析 marker基因转化是为了将基因的id和基.

qq_45478665的博客 1万+

5.栈Stack

栈Stack 栈的简介 栈的英文为(stack) 栈是一个先入后出(FILO-First In Last Out)的有序列表。 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端,为变化的一端,称为栈顶(Top),另一端为固定的一端,称为栈底(Bottom)。 根据栈的定义可知,最先放入栈中元素在栈底,最后放入的元素在栈顶,而删除元素刚好相反,最后放入的元素最先删除,最先放入的元素最后删除 出栈(pop)和入栈(pus)(图显) 栈的应用场景

HK_Milky的博客 729

基于CY7C68013A芯片的USB2.0设计

基于FPGA的USB2.0读写控制项目简介CY7C68013A芯片介绍CY7C68013A芯片读写时序控制CY7C68013A芯片读写代码USB2.0的测试结果结束语 项目简介 我们前面已经写过了USB3.0的FPGA实现,所用到的芯片是FX600Q芯片,这次我们讲解USB2.0的FPGA代码的编写。我们用到的芯片是Cypress厂家的Cy7C68013A,该款芯片在市场上的应用率极广,我们这里不...

zhangningning1996的博客 1万+

基于FFmpeg的视频播放器之十二:seek

seek是播放器的常用操作,也是衡量播放器好坏的重要标志之一。 一.效果 下面是对正在播放的4K视频执行seek操作

草上爬的博客 5406

【数据结构与算法】栈实现综合计算器(中缀表达式)

什么是栈? 栈(stack)是一种线性结构 栈是一个先入后出的有序列表 展示限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许删除和插入的一端,为变化的一端,称为栈顶,另一端为固定的一端,称为栈底。 什么时候用栈? 子程序的调用:在跳往子程序前,会先将下一个指令的地址存储到堆栈中,直到子程序执行完成后再将地址取出,以回到原来的程序中。 处理递归调用:和子程序的调用类似,...

刘亚男 557

yolov26改进 | 融合改进篇 | 基于 MobileNetV4 和双向特征金字塔网络BiFPN的融合改进(全网独家首发)

本文介绍BiFPN与MobileNetV4融合改进的YOLOv26。许多模块单独使用能够涨点,但直接叠加后可能因功能重复、通道不匹配、尺度冲突而掉点,因此融合前必须理解各模块作用。MobileNetV4利用UIB与Mobile MQA构建轻量主干,提升特征提取能力;BiFPN通过可学习权重完成双向多尺度融合,强化大、中、小目标的信息交互。两者优化Backbone与Neck,功能互补、结构冲突较少。本文提供代码、配置、消融对比及Codex修改思路,MobileNetV4也可替换其他主干,便于组合实验与二次创新

Snu77的博客 244

下推栈 中缀-后缀表达式转换 后缀表达式求值 数组与链表实现

Item.h (自定义类型) : 1 typedef double Item; STACK.h (下推栈接口) : 1 #include "Item.h" 2 3 bool STACKerror(int i); 4 void STACKinit(int); 5 int STACKempty(void); 6 void STACKpush(Item); ...

weixin_30741653的博客 187

在STM32F103RBT6微控制器上利用USB虚拟Com端口技术,高效实现ADC数据传输:详细操作步骤与示例代码解析

以上就是在STM32F103RBT6上使用USB虚拟Com端口实现ADC数据传输的全部内容。虽然过程中有很多步骤和细节需要注意,但只要按照步骤来,理解每一段代码的作用,就完全可以掌握这个过程。在实际应用中,我们可能需要根据实际需要修改一些代码,如调整ADC的参数,改变数据的处理方式等。但是,只要理解了这个过程,我们就可以很灵活地进行修改。希望这篇文章对你有所帮助。如果你有任何疑问,欢迎在评论区留言,我会尽我所能进行解答。

qq_38334677的博客 1168

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

栈和队列常见oj题

栈和队列 栈是先进后出(在栈顶进行删除和插入),所以你可以用在一些特殊的地方,比如逆序打印链表等等。 比如判断栈出数据的顺序,中缀表达式 转 后缀表达式 (后缀表达式也叫作逆波兰表达式) 现将转换成后缀表达式,通过这个表达式去计算。那么如何去转换成后缀表达式 需要用到栈 栈中的一些方法,可以查看api,比较常用的:peek,pop,push,isEmpty,search public static void main(String[] args) { MyStack s

weixin_59551524的博客 906

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

上一篇: 数据结构之栈与队列
下一篇: Thread Tree(线索二叉树)
锋魂
博客等级 码龄7年 9粉丝 18原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值