设计模式学习笔记:观察者模式及应用场景

医学影像弹性形变处理 这段代码的主要流程是:读取 DICOM 医学影像,尝试使用 MONAI 进行弹性形变(根据版本适配),如果失败则使用 OpenCV 实现,最后可视化并保存处理结果。这样可以在不同环境下灵活处理医学影像的弹性形变需求。后面会写一篇解释弹性变形方法的短文。 阅读详情

观察者模式(Observer Design Pattern),也叫做发布订阅模式(Publish-Subscribe Design Pattern)、模型-视图(Model-View)模式、源-监听器(Source-Listener)模式、从属者(Dependents)模式。指在对象之间定义一个一对多的依赖,当一个对象状态改变的时候,所有依赖的对象都会自动收到通知。

比如说Redis 中的基于频道的发布订阅就是观察者模式的应用:

一、观察者模式的介绍

观察者模式是一种对象行为型模式,下面就来看看观察者模式的结构及其实现:

1.1 观察者模式的结构

观察者模式结构中主要包括观察目标(Object)和观察者(Observer)主要结构:

Subject
ConcreteSubject
Observer
ConcreteObserver1、ConcreteObserver2
Client

1.2 观察者模式的实现

根据上面的类图,我们可以实现对应的代码。

首先定义一个抽象目标类 Subject ,其中包括增加、注销和通知观察者方法

public abstract class Subject {

    protected List<Observer> observerList = new ArrayList<Observer>();

    /**
     * 增加观察者
     * @param observer 观察者
     */
    public void add(Observer observer) {
        observerList.add(observer);
    }

    /**
     * 注销观察者,从观察者集合中删除一个观察者
     * @param observer 观察者
     */
    public void remove(Observer observer) {
        observerList.remove(observer);
    }

    /**通知观察者*/
    public abstract void notifyObserver();
}

对应具体的目标类 ConcreteSubject

public class ConcreteSubject extends Subject{

    @Override
    public void notifyObserver() {
        System.out.println("遍历观察者:");
        for (Observer observer : observerList) {
            observer.response();
        }
    }
}

此外需要定义抽象观察者 Observer ,它一般定义为一个接口,声明一个 response() 方法,为不同观察者的相应行为定义相同的接口:

public interface Observer {
    /**声明响应方法*/
    void response();
}

具体的观察者实现:

public class ConcreteObserver1 implements Observer{

    @Override
    public void response() {
        System.out.println("我是具体观察者ConcreteObserver1");
    }
}

public class ConcreteObserver2 implements Observer{

    @Override
    public void response() {
        System.out.println("我是具体观察者ConcreteObserver2");
    }
}

最后是客户端测试:

public class Client {
    public static void main(String[] args) {
        Subject concreteSubject = new ConcreteSubject();
        //具体观察者
        Observer concreteObserver1 = new ConcreteObserver1();
        Observer concreteObserver2 = new ConcreteObserver2();
        concreteSubject.add(concreteObserver1);
        concreteSubject.add(concreteObserver2);
        
        concreteSubject.notifyObserver();
    }
}

测试结果:

遍历观察者:
我是具体观察者ConcreteObserver1
我是具体观察者ConcreteObserver2

二、观察者模式的应用场景

在以下情况就可以考虑使用观察者模式:

  1. 一个对象的改变会导致一个或多个对象发生改变,而并不知道具体有多少对象将会发生改变,也不知道这些对象是谁
  2. 当一个抽象模型有两个方面,其中的一个方面依赖于另一个方面时,可将这两者封装在独立的对象中以使他们可以各自独立地改变和复用
  3. 需要在系统中创建一个触发链,使得事件拥有跨域通知(跨越两种观察者的类型)

2.1 观察者模式在java.util包中的应用

观察者模式在JDK中就有典型应用,比如 java.util.Observable 和 java.util.Observer 类。结构如下图所示:

我们可以通过实现具体的 ConcreteObserver 和具体的 ConcreteObservable 完成观察者模式流程

2.2 观察者模式在MVC中的应用

MVC(Modew-View-Controller)架构中也应用了观察者模式,其中模型(Model)可以对应观察者模式中的观察目标,而视图(View)对应于观察者,控制器(Controller)就是中介者模式的应用:

三、观察者模式实战

在本案例中模拟北京小客车指标摇号事件的通知场景(来源于《重学Java设计模式》)

对于通知事件,可以将其分成三个部分: 事件监听 、 事件处理 和 具体的业务流程 ,如下图所示:

对于和核心流程和非核心流程的结构,非核心流程可以是异步的,在MQ以及定时任务的处理下,能够最终保证一致性。

具体代码实现

  1. 事件监听接口及具体实现

这个部分就相当于观察者(Observer)的角色

在接口中定义基本事件类方法 doEvent()

public interface EventListener {

    void doEvent(LotteryResult result);

}

监听事件的具体实现 MessageEventListener (短消息事件)和 MQEventListener (MQ发送事件)

public class MessageEventListener implements EventListener{

    private Logger logger = LoggerFactory.getLogger(MessageEventListener.class);

    @Override
    public void doEvent(LotteryResult result) {
        logger.info("给用户 {} 发送短信通知(短信):{}", result.getuId(), result.getMsg());
    }
}

public class MQEventListener implements EventListener{

    private Logger logger = LoggerFactory.getLogger(MQEventListener.class);

    @Override
    public void doEvent(LotteryResult result) {
        logger.info("记录用户 {} 摇号结果(MQ):{}", result.getuId(), result.getMsg());
    }
}
  1. 事件处理类

该部分就相当于主题(Object)部分

对于不同的事件类型(MQ和Message)进行枚举处理,并提供三个方法: subscribe() 、 unsubscribe() 和 notify() 用于对监听事件的注册和使用:

public class EventManager {

    Map<Enum<EventType>, List<EventListener>> listeners = new HashMap<>();

    public EventManager(Enum<EventType>... operations) {
        for (Enum<EventType> operation : operations) {
            listeners.put(operation, new ArrayList<>());
        }
    }

    public enum EventType {
        MQ,
        Message
    }

    /**
     * 订阅
     * @param eventType 事件类型
     * @param listener  监听
     */
    public void subscribe(Enum<EventType> eventType, EventListener listener) {
        List<EventListener> eventListeners = listeners.get(eventType);
        eventListeners.add(listener);
    }

    /**
     * 取消订阅
     * @param eventType 事件类型
     * @param listener 监听
     */
    public void unsubscribe(Enum<EventType> eventType, EventListener listener) {
        List<EventListener> eventListeners = listeners.get(eventType);
        eventListeners.remove(listener);
    }

    /**
     * 通知
     * @param eventType 事件类型
     * @param result    结果
     */
    public void notify(Enum<EventType> eventType, LotteryResult result) {
        List<EventListener> eventListeners = listeners.get(eventType);
        for (EventListener eventListener : eventListeners) {
            eventListener.doEvent(result);
        }
    }
}
  1. 业务抽象类接口及其实现

使用抽象类的方式实现方法,好处是可以在方法中扩展额外的调用,并提供抽象方法 doDraw ,让继承者去实现具体的逻辑

public abstract class LotteryService {

    private EventManager eventManager;

    public LotteryService() {
        eventManager = new EventManager(EventManager.EventType.MQ, EventManager.EventType.Message);
        eventManager.subscribe(EventManager.EventType.MQ, new MQEventListener());
        eventManager.subscribe(EventManager.EventType.Message, new MessageEventListener());
    }

    public LotteryResult draw(String uId) {
        LotteryResult lotteryResult = doDraw(uId);
        eventManager.notify(EventManager.EventType.MQ, lotteryResult);
        eventManager.notify(EventManager.EventType.Message, lotteryResult);
        return lotteryResult;
    }

    protected abstract LotteryResult doDraw(String uId);
}

public class LotteryServiceImpl extends LotteryService{

    private MinibusTargetService minibusTargetService = new MinibusTargetService();

    @Override
    protected LotteryResult doDraw(String uId) {
        //摇号测试
        String lottery = minibusTargetService.lottery(uId);
        return new LotteryResult(uId, lottery, new Date());
    }
}
  1. 其他的类

摇号服务接口:

/**
 * 小客车指标调控服务
 */
public class MinibusTargetService {

    /**
     * 模拟摇号,但不是摇号算法
     *
     * @param uId 用户编号
     * @return 结果
     */
    public String lottery(String uId) {
        return Math.abs(uId.hashCode()) % 2 == 0 ? "恭喜你,编码".concat(uId).concat("在本次摇号中签") : "很遗憾,编码".concat(uId).concat("在本次摇号未中签或摇号资格已过期");
    }

}

事件信息返回类:

public class LotteryResult {

    private String uId;
    private String msg;
    private Date dateTime;

    //get set constructor... 
}
  1. 测试类
public class ApiTest {

    private Logger logger = LoggerFactory.getLogger(ApiTest.class);

    @Test
    public void test() {
        LotteryServiceImpl lotteryService = new LotteryServiceImpl();
        LotteryResult result = lotteryService.draw("1234567");
        logger.info("摇号结果:{}", JSON.toJSONString(result));
    }
}

测试结果:

11:43:09.284 [main] INFO  c.e.d.event.listener.MQEventListener - 记录用户 1234567 摇号结果(MQ):恭喜你,编码1234567在本次摇号中签
11:43:09.288 [main] INFO  c.e.d.e.l.MessageEventListener - 给用户 1234567 发送短信通知(短信):恭喜你,编码1234567在本次摇号中签
11:43:09.431 [main] INFO  ApiTest - 摇号结果:{"dateTime":1649475789279,"msg":"恭
STM32CUBEMX 使用教程5 — DMA配置 & 串口结合DMA实现数据搬运 DMA(Direct Memory Access),直接存储器访问(或数据搬运),是STM32中很实用的一个外设。DMA 传输数据方式不需要 CPU 参与控制传输,也不用中断处理的方式进行数据搬运处理,纯粹通过硬件为 RAM 与 I/O 设备之间开辟一条直接传送数据的通路,使 CPU 的效率大大提高。 阅读详情

相关推荐

AI 代码生成工具的质量评估体系

基础需求层包括响应速度(Response Time)和界面友好性(UI Friendliness),期望需求层涵盖智能提示(Smart Suggestions)和个性化配置(Personalization),兴奋需求层则涉及多模态交互(Multimodal Interaction)和代码进化(Code Evolution)。在金融领域,代码审计合规性(Compliance Audit)权重应提升至40%,而在Web开发中,API兼容性(API Compatibility)的权重需达到35%。

2503_92418637的博客 3376

设计模式之【观察者模式】,MQ的单机实现雏形

观察者模式(Observer Pattern),又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。定义一种一对多的依赖关系,一个主题对象可被多个观察者对象同时监听,使得每当主题对象状态变化时,所有依赖于它的对象都会得到通知并被自动更新。属于行为型模式。

秃了也弱了 1890

【Python学习日记:PySide6】【持续更新】

说明:PySide6 是 Qt for Python 的一部分,是一个 Python 绑定库,可以用来创建跨平台的 GUI 应用程序。它将 Qt 框架的丰富功能带到了 Python 环境中,允许开发者使用 Python 编写 GUI 应用程序。

XLQ的博客 8049

2 观察者模式

一、定义当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知它的依赖对象。观察者模式属于行为型模式。二、介绍意图:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。主要解决:一个对象状态改变给其他对象通知的问题,而且要考虑到易用和低耦合,保证高度的协作。何时使用:一个对象(目标对...

qq_24828741的博客 239

Windows游戏玩家必看:用Process Lasso优化CPU优先级和核心绑定,告别卡顿

本文为Windows游戏玩家详细介绍了如何使用Process Lasso优化系统性能。通过设置CPU优先级和核心绑定,可以智能管理进程资源,确保游戏获得最高调度权限,有效减少因后台程序干扰或Windows调度机制不完善导致的卡顿与帧数波动,从而提升游戏流畅度与稳定性。

weixin_29299807的博客 2230

别再只调A*算法了!聊聊ROS机器人导航中,OpenCV视觉信息如何与激光雷达数据“打配合”

本文探讨了ROS机器人导航中激光雷达与OpenCV视觉融合的实战策略,揭示了如何通过多模态感知提升导航精度。文章详细介绍了视觉特征到代价地图的转化方法、系统级挑战的工程解决方案,以及融合感知下的路径规划进化,帮助开发者优化机器人导航系统。

weixin_29278805的博客 227

设计模式之观察者模式

观察者模式就是提供一个观察类,当数据有修改时就通知绑定的其他对象。比如redis通知机制、配置中心一些调度算法等等,都运用到了观察者模式,这种模式还是属于行为型模式。

勤于笔记,成于点滴。 408

CRMEB商城系统任意文件下载漏洞(CVE-2024-52726)分析与修复

在Web应用安全领域,API接口安全是保障系统边界安全的核心环节。其原理在于通过签名验证、参数校验等机制,确保请求的合法性与完整性。这项技术的价值在于为系统间数据交互提供安全通道,防止未授权访问和数据泄露。典型的应用场景包括电商系统的对外数据接口、第三方服务集成等。然而,当签名验证逻辑存在缺陷或文件路径处理不当,便会引发严重的安全风险。本文以CRMEB开源商城系统为例,深入剖析其对外API模块中因签名验证绕过和路径遍历导致的任意文件下载漏洞。该漏洞允许攻击者下载服务器敏感文件,如数据库配置文件、日志和源码,

weixin_27722377的博客 378

设计模式:实战观察者模式

简单来讲观察者🕵模式,就是当一个行为发生时传递信息给另外一个用户接收做出相应的处理,两者之间没有直接的耦合关联。例如;狗仔队除了生活中的场景外,在我们编程开发中也会常用到一些观察者的模式或者组件,例如我们经常使用的MQ服务,虽然MQ服务是有一个通知中心并不是每一个类服务进行通知,但整体上也可以算作是观察者模式的思路设计。再比如可能有做过的一些类似事件监听总线,让主线服务与其他辅线业务服务分离,为了使系统降低耦合和增强扩展性,也会使用观察者模式进行处理。

qq_63815371的博客 462

【电源专题】LDO基础——热性能2

对于LDO散热而言,选择合适的元件并不是一件简单的任务。为了实现高效、尺寸得当并成本低的散热解决方案,我们在早期设计阶段就需要确保所有器件都可用并且已经考虑到元件和各种特性。

一点硬件 896

Autosar Dcm配置-App到Boot的跳转及1002回复配置及实现-基于ETAS软件

在软件刷写流程中,上位机(诊断仪)发送1002后,APP检查允许跳转boot后,在特定的ram(软复位不清除)写入指定置后通过触发软件复位来跳转到boot的。在APP跳转到Bootloader时,1002的回复有两种方式,一种是APP直接回复,然后跳转,另一种是APP回复NRC78,然后跳转,在Boot中回复。本文介绍这两种方式的实现。如果是在APP中回复,可以少发一个0x78,整体跳转时间可能会少一些。但是如果诊断在收到5002之后立马请求其他的服务,可能出现boot正在初始化而未正常接收到报文。

赞的博客 1561

设计模式学习笔记:进入观察者模式及应用场景

观察者模式(Observer Design Pattern),也叫做发布订阅模式(Publish-Subscribe Design Pattern)、模型-视图(Model-View)模式、源-监听器(Source-Listener)模式、从属者(Dependents)模式。指在对象之间定义一个一对多的依赖,当一个对象状态改变的时候,所有依赖的对象都会自动收到通知。 比如说Redis 中的基于频道的发布订阅就是观察者模式的应用: 一、观察者模式的介绍 观察者模式是一种对象行为型模式,下面就来看

m0_67645544的博客 156

YOLOv11改进策略【卷积层】| 引入注意力卷积模块RFAConv,关注感受野空间特征 助力yolov11精度提升

RFAConv:创新空间注意力和标准卷积运算感受野空间特征是针对卷积核设计的,根据卷积核大小动态生成。以3×3卷积核为例,它由非重叠滑动窗口组成,每个窗口代表一个感受野滑块。

Limiiiing的博客 1824

《设计模式之美》观察者模式(上):详解各种应用场景 下观察者模式的不同实现方式

王争《设计模式之美》学习笔记 行为型设计模式主要解决的就是“类或对象之间的交互”问题。 一个行为型设计模式,也是在实际的开发中用得比较多的一种模式:观察者模式。 观察者模式会对应不同的代码实现方式: 有同步阻塞的实现方式,也有异步非阻塞的实现方式; 有进程内的实现方式,也有跨进程的实现方式。 原理及应用场景剖析 观察者模式(Observer Design Pattern)也被称为发布订阅模式(Publish-Subscribe Design Patter)。 在对象之间定义一个一对多的依赖,当一

玲珑巫女的学习笔记 282

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

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

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

设计模式学习笔记 - 设计模式与范式 -行为型:1.观察者模式(上)

设计模式要干的事情就是解耦,创建型模式是将创建和使用代码解耦,结构性模式是将不同功能代码解耦,行为性模式是将不同行为解耦,具体到观察者模式,它将观察者和被观察者代码解耦。借助设计模式,我们利用更好的代码结构,将一大坨代码拆分成职责更单一的小类,让其满足开闭原则、高内聚低耦合等特性,依此来控制和应对代码的复杂性,提高代码的可扩展性。

chenjian723122704的专栏 1820

深度学习工具包 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")

【观察者模式】 ——每天一点小知识

🐬观察者模式是一种有用的设计模式,它能够实现对象之间的一对多依赖关系,当一个对象的状态发生改变时,其所有依赖者都会得到通知并自动更新。通过观察者模式,我们可以实现松耦合的对象间通信,提高代码的灵活性和可维护性。

仰望天空,妳我亦是行人. 2300

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

设计模式学习笔记 - 设计模式与范式 -行为型:17.中介模式:什么时候用中介模式?什么时候用观察者模式?

前面讲观察者模式的时候,我们讲到观察者模式的实现方式有很多种。虽然经典的实现方式没法彻底解耦观察者和被观察者,观察者需要注册到被观察者中,被观察者状态更新需要调用观察者的update()方法。但是在跨进程的实现方式中,我们可以利用消息队列实现彻底解耦,观察者和被观察者都只需要跟消息队列交互,观察者完全不知道被观察者的存在,被观察者也完全不知道观察者的存在。本章提到,中介模式也就为了解耦对象之间的交互,所有的参与者都只与中介进行交互。

chenjian723122704的专栏 1247

游戏设计模式学习笔记(4)观察者模式

游戏设计模式学习笔记(4)观察者模式 参考: 《设计模式与游戏完美开发》 《游戏编程模式》(https://github.com/tkchu/Game-Programming-Patterns-CN) 《图说设计模式( Graphic Design Patterns)》(https://github.com/me115/design_patterns) 【游戏设计模式】浅墨_毛星云: https...

l773575310的博客 388

设计模式之二:观察者模式

《Head First设计模式》第二章学习笔记 一、OO基础:      抽象 二、OO原则:      为交互对象之间的松耦合设计而努力 三、观察者模式       观察者模式,又叫发布--订阅模式、模型--视图模式、源--监听器模式或从属者模式。观察者模式定义了对象之间的一对多依赖,这样一来,当一个对象改变状态时,它的所有依赖者都会收到通知并自动更新。主

caihaijiang的专栏 1568

《设计模式》学习笔记7——观察者模式

定义观察者模式是使用频率最高的设计模式之一,也是最容易理解的设计模式之一,这种模式在生活中随处可见。 观察者模式引用书中的定义如下: 观察者模式(Observer Pattern):定义对象之间的一种一对多依赖关系,使得每当一个对象状态发生改变时,其相关依赖对象皆得到通知并被自动更新。观察者模式的别名包括发布-订阅(PublishSubscribe) 模式、模型-视图(Model/View)

程序员涂小哥的技术博客 832

【设计模式——学习笔记】23种设计模式——观察者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现)

讲解观察者模式的思想,介绍其常见的应用场景,举例说明其实现方式

我只管埋头前行,剩下的交给时间。 3560

十、观察者模式——设计模式学习笔记

观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时,会通知所有观察者对象,使它们能够自动更新自己。

L0nginus的博客 452
上一篇: RabbitMQ 补偿机制、消息幂等性解决方案
下一篇: 阿里巴巴首发第2版Java高并发编程(源码+实战+面试题剖析)
Javaesandyou
博客等级 码龄5年 742粉丝 563原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值