【设计模式】—— 解释器模式Interpret

模式意图

自定义某种语言后,给定一种文法标准,定义解释器,进行解析。

做过搜索的朋友们可能更了解一些,平时我们搜索所需要的词库,通常就需要用这种方式来实现。

应用场景

1 有复杂的语法分析场景

2 需要高效的解释,胜过快速的效率(即看中解释的结果,而放弃效率)

模式结构



Expression 语法解释器的抽线模型

/**
 * 指定抽象表达式,具体表达式必须实现的方法
 * @author xingoo
 *
 */
abstract class Expression{
    /**
     * 以上下文环境为准,解释指定的表达式
     * @param ctx
     * @return
     */
    public abstract boolean interpret(Context ctx);
    /**
     * 检验两个表达式,是否相同
     */
    public abstract boolean equals(Object o);
    /**
     * 返回表达式代表的hashCode
     */
    public abstract int hashCode();
    /**
     * 转换成字符串
     */
    public abstract String toString();
}

以下是具体的解释器实现过程,这里主要模仿JAVA模式中的例子

/**
 * 常量表达式
 * @author xingoo
 *
 */
class Constant extends Expression{
    private boolean value;
    public Constant(boolean value){
        this.value = value;
    }
    public boolean interpret(Context ctx){
        return value;
    }
    public boolean equals(Object o){
        if(o!=null && o instanceof Constant){
            return this.value == ((Constant)o).value;
        }
        return false;
    }
    public int hashCode() {
        return (this.toString()).hashCode();
    }
    public String toString() {
        return new Boolean(value).toString();
    }
}
/**
 * 变量表达式
 * @author xingoo
 *
 */
class Variable extends Expression{
    private String name;
    
    public Variable(String name){
        this.name = name;
    }
    
    public boolean interpret(Context ctx) {
        return ctx.lookup(this);
    }
    
    public boolean equals(Object o) {
        if(o!=null && o instanceof Variable){
            return this.name.equals(((Variable)o).name);
        }
        return false;
    }

    public int hashCode() {
        return (this.toString()).hashCode();
    }
    public String toString() {
        return name;
    }
    
}
/**
 * 与 表达式
 * @author xingoo
 *
 */
class And extends Expression{
    private Expression left,right;
    
    public And(Expression left,Expression right){
        this.left = left;
        this.right = right;
    }
    
    public boolean interpret(Context ctx) {
        return left.interpret(ctx) && right.interpret(ctx);
    }

    @Override
    public boolean equals(Object o) {
        if(o!=null && o instanceof And){
            return this.left.equals(((And)o).left) && this.right.equals(((And)o).right);
        }
        return false;
    }

    public int hashCode() {
        return (this.toString()).hashCode();
    }

    public String toString() {
        return "("+left.toString()+" AND "+right.toString()+")";
    }
}
/**
 * 或 表达式
 * @author xingoo
 *
 */
class Or extends Expression{
    private Expression left,right;
    
    public Or(Expression left,Expression right){
        this.left = left;
        this.right = right;
    }
    
    public boolean interpret(Context ctx) {
        return left.interpret(ctx) || right.interpret(ctx);
    }

    public boolean equals(Object o) {
        if(o!=null && o instanceof Or){
            return this.left.equals(((Or)o).left) && this.right.equals(((Or)o).right);
        }
        return false;
    }

    public int hashCode() {
        return (this.toString()).hashCode();
    }

    public String toString() {
        return "("+left.toString()+" Or "+right.toString()+")";
    }
}
/**
 * 非 表达式
 * @author xingoo
 *
 */
class Not extends Expression{
    private Expression exp;
    
    public Not(Expression exp){
        this.exp = exp;
    }
    
    public boolean interpret(Context ctx) {
        return !exp.interpret(ctx);
    }

    public boolean equals(Object o) {
        if(o!=null && o instanceof Not){
            return this.exp.equals(((Not)o).exp);
        }
        return false;
    }

    public int hashCode() {
        return (this.toString()).hashCode();
    }

    public String toString() {
        return "(Not "+exp.toString()+")";
    }
    
}

Context  上下文环境,存储一些表达式的内容

/**
 * 上下文环境
 * @author xingoo
 *
 */
class Context{
    
    private HashMap map = new HashMap();
    
    public void assign(Variable var,boolean value){
        map.put(var, new Boolean(value));
    }
    
    public boolean lookup(Variable var) throws IllegalArgumentException{
        Boolean value = (Boolean)map.get(var);
        if(value == null){
            throw new IllegalArgumentException();
        }
        return value.booleanValue();
    }
}

全部代码

  1 package com.xingoo.interpreter;
  2 
  3 import java.util.HashMap;
  4 /**
  5  * 指定抽象表达式,具体表达式必须实现的方法
  6  * @author xingoo
  7  *
  8  */
  9 abstract class Expression{
 10     /**
 11      * 以上下文环境为准,解释指定的表达式
 12      * @param ctx
 13      * @return
 14      */
 15     public abstract boolean interpret(Context ctx);
 16     /**
 17      * 检验两个表达式,是否相同
 18      */
 19     public abstract boolean equals(Object o);
 20     /**
 21      * 返回表达式代表的hashCode
 22      */
 23     public abstract int hashCode();
 24     /**
 25      * 转换成字符串
 26      */
 27     public abstract String toString();
 28 }
 29 /**
 30  * 常量表达式
 31  * @author xingoo
 32  *
 33  */
 34 class Constant extends Expression{
 35     private boolean value;
 36     public Constant(boolean value){
 37         this.value = value;
 38     }
 39     public boolean interpret(Context ctx){
 40         return value;
 41     }
 42     public boolean equals(Object o){
 43         if(o!=null && o instanceof Constant){
 44             return this.value == ((Constant)o).value;
 45         }
 46         return false;
 47     }
 48     public int hashCode() {
 49         return (this.toString()).hashCode();
 50     }
 51     public String toString() {
 52         return new Boolean(value).toString();
 53     }
 54 }
 55 /**
 56  * 变量表达式
 57  * @author xingoo
 58  *
 59  */
 60 class Variable extends Expression{
 61     private String name;
 62     
 63     public Variable(String name){
 64         this.name = name;
 65     }
 66     
 67     public boolean interpret(Context ctx) {
 68         return ctx.lookup(this);
 69     }
 70     
 71     public boolean equals(Object o) {
 72         if(o!=null && o instanceof Variable){
 73             return this.name.equals(((Variable)o).name);
 74         }
 75         return false;
 76     }
 77 
 78     public int hashCode() {
 79         return (this.toString()).hashCode();
 80     }
 81     public String toString() {
 82         return name;
 83     }
 84     
 85 }
 86 /**
 87  * 与 表达式
 88  * @author xingoo
 89  *
 90  */
 91 class And extends Expression{
 92     private Expression left,right;
 93     
 94     public And(Expression left,Expression right){
 95         this.left = left;
 96         this.right = right;
 97     }
 98     
 99     public boolean interpret(Context ctx) {
100         return left.interpret(ctx) && right.interpret(ctx);
101     }
102 
103     @Override
104     public boolean equals(Object o) {
105         if(o!=null && o instanceof And){
106             return this.left.equals(((And)o).left) && this.right.equals(((And)o).right);
107         }
108         return false;
109     }
110 
111     public int hashCode() {
112         return (this.toString()).hashCode();
113     }
114 
115     public String toString() {
116         return "("+left.toString()+" AND "+right.toString()+")";
117     }
118 }
119 /**
120  * 或 表达式
121  * @author xingoo
122  *
123  */
124 class Or extends Expression{
125     private Expression left,right;
126     
127     public Or(Expression left,Expression right){
128         this.left = left;
129         this.right = right;
130     }
131     
132     public boolean interpret(Context ctx) {
133         return left.interpret(ctx) || right.interpret(ctx);
134     }
135 
136     public boolean equals(Object o) {
137         if(o!=null && o instanceof Or){
138             return this.left.equals(((Or)o).left) && this.right.equals(((Or)o).right);
139         }
140         return false;
141     }
142 
143     public int hashCode() {
144         return (this.toString()).hashCode();
145     }
146 
147     public String toString() {
148         return "("+left.toString()+" Or "+right.toString()+")";
149     }
150 }
151 /**
152  * 非 表达式
153  * @author xingoo
154  *
155  */
156 class Not extends Expression{
157     private Expression exp;
158     
159     public Not(Expression exp){
160         this.exp = exp;
161     }
162     
163     public boolean interpret(Context ctx) {
164         return !exp.interpret(ctx);
165     }
166 
167     public boolean equals(Object o) {
168         if(o!=null && o instanceof Not){
169             return this.exp.equals(((Not)o).exp);
170         }
171         return false;
172     }
173 
174     public int hashCode() {
175         return (this.toString()).hashCode();
176     }
177 
178     public String toString() {
179         return "(Not "+exp.toString()+")";
180     }
181     
182 }
183 /**
184  * 上下文环境
185  * @author xingoo
186  *
187  */
188 class Context{
189     
190     private HashMap map = new HashMap();
191     
192     public void assign(Variable var,boolean value){
193         map.put(var, new Boolean(value));
194     }
195     
196     public boolean lookup(Variable var) throws IllegalArgumentException{
197         Boolean value = (Boolean)map.get(var);
198         if(value == null){
199             throw new IllegalArgumentException();
200         }
201         return value.booleanValue();
202     }
203 }
204 public class Client {
205     private static Context ctx;
206     private static Expression exp;
207     public static void main(String[] args) {
208         ctx = new Context();
209         Variable x = new Variable("x");
210         Variable y = new Variable("y");
211         
212         Constant c = new Constant(true);
213         
214         //放入上下文中
215         ctx.assign(x, false);
216         ctx.assign(y, true);
217         
218         exp = new Or(new And(c,x),new And(y,new Not(x)));
219         System.out.println("x = "+x.interpret(ctx));
220         System.out.println("y = "+y.interpret(ctx));
221         System.out.println(exp.toString() +" = "+exp.interpret(ctx));
222     }
223 }

运行结果


asd

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1 目标检测的定义 目标检测(Object Detection)的任务是找出图像中所有感兴趣的目标(物体),确定它们的类别和位置,是计算机视觉领域的核心问题之一。由于各类物体有不同的外观、形状和姿态,加上成像时光照、遮挡等因素的干扰,目标检测一直是计算机视觉领域最具有挑战性的问题。 目标检测任务可分为两个关键的子任务,目标定位和目标分类。首先检测图像中目标的位置(目标定位),然后给出每个目标的具体类别(目标分类)。输出结果是一个边界框(称为Bounding-box,一般形式为(x1,y1,x2,y2),表示框的左上角坐标和右下角坐标),一个置信度分数(Confidence Score),表示边界框中是否包含检测对象的概率和各个类别的概率(首先得到类别概率,经过Softmax可得到类别标签)。 1.1 Two stage方法 目前主流的基于深度学习的目标检测算法主要分为两类:Two stage和One stage。Two stage方法将目标检测过程分为两个阶段。第一个阶段是 Region Proposal 生成阶段,主要用于生成潜在的目标候选框(Bounding-box proposals)。这个阶段通常使用卷积神经网络(CNN)从输入图像中提取特征,然后通过一些技巧(如选择性搜索)来生成候选框。第二个阶段是分类和位置精修阶段,将第一个阶段生成的候选框输入到另一个 CNN 中进行分类,并根据分类结果对候选框的位置进行微调。Two stage 方法的优点是准确度较高,缺点是速度相对较慢。 常见Tow stage目标检测算法有:R-CNN系列、SPPNet等。 1.2 One stage方法 One stage方法直接利用模型提取特征值,并利用这些特征值进行目标的分类和定位,不需要生成Region Proposal。这种方法的优点是速度快,因为省略了Region Proposal生成的过程。One stage方法的缺点是准确度相对较低,因为它没有对潜在的目标进行预先筛选。 常见的One stage目标检测算法有:YOLO系列、SSD系列和RetinaNet等。 2 常见名词解释 2.1 NMS(Non-Maximum Suppression) 目标检测模型一般会给出目标的多个预测边界框,对成百上千的预测边界框都进行调整肯定是不可行的,需要对这些结果先进行一个大体的挑选。NMS称为非极大值抑制,作用是从众多预测边界框中挑选出最具代表性的结果,这样可以加快算法效率,其主要流程如下: 设定一个置信度分数阈值,将置信度分数小于阈值的直接过滤掉 将剩下框的置信度分数从大到小排序,选中值最大的框 遍历其余的框,如果和当前框的重叠面积(IOU)大于设定的阈值(一般为0.7),就将框删除(超过设定阈值,认为两个框的里面的物体属于同一个类别) 从未处理的框中继续选一个置信度分数最大的,重复上述过程,直至所有框处理完毕 2.2 IoU(Intersection over Union) 定义了两个边界框的重叠度,当预测边界框和真实边界框差异很小时,或重叠度很大时,表示模型产生的预测边界框很准确。边界框A、B的IOU计算公式为: 2.3 mAP(mean Average Precision) mAP即均值平均精度,是评估目标检测模型效果的最重要指标,这个值介于0到1之间,且越大越好。mAP是AP(Average Precision)的平均值,那么首先需要了解AP的概念。想要了解AP的概念,还要首先了解目标检测中Precision和Recall的概念。 首先我们设置置信度阈值(Confidence Threshold)和IoU阈值(一般设置为0.5,也会衡量0.75以及0.9的mAP值): 当一个预测边界框被认为是True Positive(TP)时,需要同时满足下面三个条件: Confidence Score > Confidence Threshold 预测类别匹配真实值(Ground truth)的类别 预测边界框的IoU大于设定的IoU阈值 不满足条件2或条件3,则认为是False Positive(FP)。当对应同一个真值有多个预测结果时,只有最高置信度分数的预测结果被认为是True Positive,其余被认为是False Positive。 Precision和Recall的概念如下图所示: Precision表示TP与预测边界框数量的比值 Recall表示TP与真实边界框数量的比值 改变不同的置信度阈值,可以获得多组Precision和Recall,Recall放X轴,Precision放Y轴,可以画出一个Precision-Recall曲线,简称P-R
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值