UE4 四种加载资源的方式

UE4 四种加载资源的方式

 
 

http://blog.csdn.net/u012385432/article/details/52154737

 
 

在UNITY中,我们加载资源一般是通过Resources.Load(path).即可完成.该方法返回的是Object类型.如果你想要的是材质或者贴图等等,只要价格类型转换的关键字就可以了例如 as Material,则可以返回一个材质的引用…

 
 

在UE4中,加载资源的方式区别较大.经过自己一个下午的摸索,目前发现了这4种资源的加载方式.在UE4中,它的蓝图就大致等于UNTIY中的prefab.所以我们将资源弄成了蓝图的方式来进行加载.

 
 

 
 

 
 

第一种: 如果该蓝图有C++类(或者说是从C++类创建的蓝图),直接进行加载

 
 

ATemp* spawnActor = GetWorld()->SpawnActor<ATemp>(ATemp::StaticClass());

 
 

所有的加载资源并创建到场景中的方式都离不开SpawnActor这一句代码.如果你的蓝图包含了C++类,那么可以直接访问类的StaticClass

 
 

剩下的加载方式均是单纯的加载蓝图,并没有对应的C++类

 
 

 
 

 
 

第二种: 通过ConstructorHelpers来加载

 
 

static ConstructorHelpers::FClassFinder<AActor> bpClass(TEXT(“/Game/BluePrint/TestObj”));

if(bpClass.Class != NULL)

{

GetWorld()->SpawnActor(bpClass.Class);

}

 
 

FClassFinder是一个结构体,其中的Class成员变量是TSubClassof<T>类型的.所以我们只需要SpawnActor(bpClass.Class)就可以生成我们要的东西了

 
 

但是值得一提的是该方法只能在类的构造函数中使用,如果在普通的逻辑代码中嵌套这份代码,很可能引起整个编译器的crash.以下是该代码的具体执行步骤

 
 

 
 

 
 

第三种: 通过FStringAssetReference来加载

 
 

FStringAssetReference asset = “Blueprint’/Game/BluePrint/TestObj.TestObj'”;

UObject* itemObj = asset.ResolveObject();

UBlueprint* gen = Cast<UBlueprint>(itemObj);

if (gen != NULL)

{

AActor* spawnActor = GetWorld()->SpawnActor<AActor>(gen->GeneratedClass);

}*/

 
 

FStringAssetReference类的作用主要是通过一个字符串,找到该字符串所对应的资源.或者通过给定的资源,找到该资源所对应的在项目中的路径,也就是前面所说的字符串

 
 

其中,asset.ResolveObject就是查找字符串对应的资源,返回一个UObejct,我们通过将其转化成UBlueprint类型然后再去的他的GenerateClass即可.

 
 

 
 

 
 

第四种: 通过StaticLoadObject来加载

 
 

UObject* loadObj = StaticLoadObject(UBlueprint::StaticClass(), NULL, TEXT(“Blueprint’/Game/BluePrint/TestObj.TestObj'”));

if (loadObj != nullptr)

{

UBlueprint* ubp = Cast<UBlueprint>(loadObj);

AActor* spawnActor = GetWorld()->SpawnActor<AActor>(ubp->GeneratedClass);

UE_LOG(LogClass, Log, TEXT(“Success”));

}

 
 

原理的话几乎是和第三种是一样的.只是调用的方式不同而已.在这里就不再赘述了.

总结下来,第三种和第四种应该是最通用的.因为第一种要求有对应的蓝图C++类,而第二种又要求一定要是在构造函数中完成(不论是在谁的构造函数都可以,但该方法一定只能在构造函数中调用)…

 
 

想不到一个简单的加载资源也有这么多种方式…我已经给跪了…天呐…

 
 

 
 

Getting Started with VR in Unreal Engine 4

http://www.tomlooman.com/getting-started-with-vr/

 
 

 
 

This guide is for anyone who is looking to get into developing for Virtual Reality projects in Unreal Engine 4. Covering Blueprint, C++, performance considerations and how to set up your VR kits for UE4.

 
 

I highly recommend using the latest release of Unreal Engine 4 as VR is still being improved greatly with each new release.

 
 

A few good places to reference are the official Oculus forums, the official VR documentation pages and the Unreal Engine VR Subforums.

 
 

If you are looking for VR Templates to get you started right away, go to myGitHub Repository. These templates are currently WIP for both C++ and Blueprint with a variety of camera and motion controller features and include the performance optimizations we will discuss in this guide. The official VR Template is currently being developed and will be released as soon as possible!

 
 

 
 

 
 

Setup your VR Device

 
 

For this guide I will assume you have successfully installed your head-mounted display of choice (Visit Oculus Rift Setup or HTC Vive Pre Setup in case you did not). In case you are having difficulties getting your Vive to work, I found this Troubleshooting guide to be helpful.

 
 

Unreal Engine 4 supports all the major devices and you don’t need to perform any hassle to setup your game project for VR. Just make sure that the correct plugins are loaded for your HMD under Edit > Plugins. There are some performance considerations to take into account, we’re covering these later in the guide.

【UE4已经支持所有主流VR设备,一般来说可直接使用,不行的话看一下VR-Plugin里面是否启用。】

 
 


 
 

Before you launch the editor make sure your VR software is running, in the case of the HTC Vive this is the SteamVR app.

【运行editor前确保VR软件开启】

 
 

 
 

 
 

Launching VR Preview

 
 

Testing out your VR set is very straightforward, simply select “VR Preview” from the Play drop-down button. By default the head tracking will work right away without any changes to your existing project or template. I will go into more detail on how to add additional features such as motion controller setup and origin resetting etc. later on in this guide.

【直接VR Preview就可以看到效果了】

 
 


 
 

 
 

 
 

VR Best Practices

 
 

VR is still a relatively unexplored area, and we are learning new things with every day of development. Both Oculus and Epic Games have set up a Best Practices Guide that I recommend you read through and keep in the back of your head while developing games for VR.

【推荐先阅读一下各家的Best Practices Guide】

 
 

 
 

 
 

Using VR in Blueprint

 
 

Using VR in Blueprint is very straightforward and you don’t need a lot of set up to get yourself going.

 
 

You will need a Camera Component and optionally one or two Motion Controllers Components. By default your Camera is already set up for HMD support, if you wish to disable rotation changes from the HMD you can disable “Lock to HMD” in the Component’s properties. For more information on the Motion Controllers you can jump down in this guide or immediately jump to the official documentation page on how to Setup Motion Controllers.

【默认相机就已经启用HMD控制,但是可以选择去掉,motion controller也可以直接加上。】

 
 

Here is a (non-exhaustive list) of the available nodes in Blueprint:

 
 


 
 

To reset your HMD position and/or orientation (With optional Yaw offset):

【重置】

 
 


 
 

To selectively enable features when using VR you can easily check whether your HMD is enabled:

【是否启用Vr的检查】

 
 


 
 

 
 

 
 

SteamVR Chaperone

 
 

The Chaperone component is specific to SteamVR and has easy access to the soft bounds. The soft bounds are represented as an array of Vectors centered around the calibrated HMD’s Origin (0,0,0). The Z component of the Vectors is always zero. You can add this component like any other ActorComponent to your Blueprint as seen below.

 
 


 
 

 
 

 
 

USteamVRChaperoneComponent

 
 

To use the chaperone in C++ open up your ProjectName.Build.cs and add the “SteamVR” module to the PrivateDependencyModuleNames array. See below for a sample.

【C++启用SteamVR模块来开启SteamVR Chaperone】

 
 

using UnrealBuildTool;

 

public class VRFirstPerson : ModuleRules

{

public VRFirstPerson(TargetInfo Target)

{

PublicDependencyModuleNames.AddRange(new string[] { “Core”, “CoreUObject”, “Engine”, “InputCore” });

 

/* VR Required Modules */

PrivateDependencyModuleNames.AddRange(new string[] { “HeadMountedDisplay” , “SteamVR” });

}

}

 
 

 
 

 
 

Setup Motion Controllers

 
 

The official documentation has a good introduction on Motion Controller setup and input handling, so if your VR Device supports motion controllers I recommend following along with the documentation. For a practical example check out my VR Templates on GitHub.

【官方文档和我的例子里面都有好的demo可以直接学习使用】

 
 

If you’re having trouble aligning your Motion Controllers with the Camera, simply use a SceneComponent as “VROrigin”, this is especially helpful when the root component has an undesirable pivot like the CapsuleComponent in a Character Blueprint.

【建议使用VR的时候相关内容成立一个场景的独立组件,如下图的结构】

 
 


 
 

 
 

 
 

 
 

Using VR in C++

 
 

As of 4.11 not all functionality is exposed to Blueprint, if you are looking to do more advanced custom setups you might need to dig into C++ to adjust a few settings. Check out the IHeadMountedDisplay.h for a look at the available functions. Certain plugins add additional features likeSteamVRChaperoneComponent but are specific to a single device.

【UE4没有将所有的功能都暴露在blueprint里面,因此对于高级功能还是要使用C++来处理, IHeadMountedDisplay.h 展示了可用功能。】

 
 

 
 

 
 

Required Modules & Includes

 
 

If you wish to access the HMD features through C++ you need to include the“HeadMountedDisplay” Module in your ProjectName.Build.cs file you can find in your Visual Studio solution explorer. Here is an example of the build file from the VRFirstPerson project.

【首先一样要导入相关模块,下面是第一人称VR游戏的例子】

 
 

using UnrealBuildTool;

 

public class VRFirstPerson : ModuleRules

{

public VRFirstPerson(TargetInfo Target)

{

PublicDependencyModuleNames.AddRange(new string[] { “Core”, “CoreUObject”, “Engine”, “InputCore” });

 

/* VR Module */

PrivateDependencyModuleNames.AddRange(new string[] { “HeadMountedDisplay” });

 

// …

}

}

 

To use HMD features or the motion controller component, make sure you include the following header files.

【还有相关头文件】

 
 

/* VR Includes */

#include “HeadMountedDisplay.h”

#include “MotionControllerComponent.h”

 
 

 
 

 
 

 
 

Performance Considerations

 
 

For the whole VR experience to look smooth, your game needs to run on 75 hz (Oculus DK2) or even 90 hz. (HTC Vive and Oculus CV1) depending on your device. To see your current framerate type in “stat fps” or “stat unit” (for more detailed breakdown) in your console when running the game.

 
 

 
 

 
 

CPU Profiling

 
 

Your game might be CPU or GPU bound, to find out you need to measure (a quick way is to use “stat unit”). With the complexity of current gen games and engines it’s near impossible to make good guesses on what’s bottlenecking your performance so use the tools at your disposal! Bob Tellez wrote a blog post on CPU Profiling with Unreal Engine 4 and it’s a good place to get started.

【关于UE4 VR CPU方面的剖析可以看看】

 
 

 
 

 
 

GPU Profiling

 
 

To capture a single frame with GPU timings press Ctrl+Shift+, or type in “profilegpu” in the console. This command dumps accurate timings of the GPU, you will find that certain processes are a heavy burden on the framerate (Ambient Occlusion is one common example) when using VR.

【Ctrl+Shift+, 来显示单帧GPU渲染时间,通过这可以来分析性能相关问题。】

 
 


 
 

The GPU Profiling & Performance and Profiling docs are a good place to learn about profiling your game.

【相关文档】

 
 

While profiling you might stumble(绊倒) on other costly features depending on your scene and project. One example is the Translucent Lighting Volume you may not need but even when unused it adds a static cost to your scene, check out this

 AnswerHub post by Daniel Wright for more info on how to disable this feature. All that is left for you to do is measure and test, there is no single configuration that is perfect for all projects.

【有些无用渲染特征可以关闭,如何关闭渲染feature详见上文】

 
 

The developers from FATED came up with a great list of tips in their quest for optimized VR. A few examples they mention are to disable HZB Occlusion Culling (r.HZBOcclusion 0), Motion Blur (r.DefaultFeature.MotionBlur=False) and Lens Flares (r.DefaultFeature.LensFlare=False). The commands do not persist through multiple sessions, so you should add (or search and replace) them in your /Config/DefaultEngine.ini config file although most of these settings are available through Edit > Project Settings… > Rendering.

【要关闭哪些相关VR无用渲染设置可以见这份tips。】

 
 

Another great optimization to consider is the Instanced Stereo Rendering, we’ll talk about that next.

 
 

 
 

 
 

Instanced Stereo Rendering

 
 

The latest 4.11 release introduces Instanced Stereo Rendering, check the video below for a comparison video of how that works.

【新版支持的一个非常关键的渲染能力】

 
 

https://www.youtube.com/watch?v=uTUwKC7GXjo

(“Basically, we’re utilizing hardware instancing to draw both eyes simultaneously with a single draw call and pass through the render loop. This cuts down render thread CPU time significantly and also improves GPU performance. Bullet Train was seeing ~15 – 20% CPU improvement on the render thread and ~7 – 10% improvement on the GPU.” – Ryan Vance.)

 
 

To enable this feature in 4.11 and above, go to your Project Settings and look for “Instanced Stereo” under the Rendering category.

【参加下图来开启/关闭该功能】

 
 


 
 

 
 

 
 

Disable Heavy Post-Processors

 
 

Certain post-processing effects are very costly in VR like Ambient Occlusion. Others may even become an annoyance in VR like Lens Flares as they may break your immersion of being present in the scene and instead looking through a camera. These are easy examples to get started and see how it affects your game and performance.

【很多非常耗性能的后处理工作需要关闭】

 
 

To disable post processing features on a project level, go to Edit > Project Settings > Rendering. You can do the same thing in post-processing volumes. Keep in mind that post-processing volumes can override the project-wide settings specified below.

【怎么做,参考下图】

 
 


 
 

 
 

 
 

Reduce Scene Complexity

 
 

With current gen hardware it’s really difficult to stay on your 90 fps target. You may need to revisit your previous traditional constraints and look at your scene complexity like dynamic shadows, atmospheric smoke effects and polycount of meshes.

【减少场景复杂度是提高性能的一大利器。】

 
 

It’s important to minimize overdraw to keep performance at a maximum. Lots of translucent surfaces and/or particle effects can easily cause your framerate to tank. To visualize the current shader complexity / overdraw press Alt+8 in your viewport (Alt+4 to return to default view). Look at the bottom picture from the Elemental Demo to get an idea of how much the atmospheric effects can impact your framerate (green = good, red = bad, white hot = extremely bad at about 2000 shader instructions per pixel)

【Alt+4 default view; Alt+8 visualize the current shader complexity / overdraw. 查看overdraw的性能,绿色表示好。】

 
 

Dynamic shadows and lights have a huge impact on performance too. Bake as much lighting as you can to keep the per-frame cost as low as possible.

【动态光照也是一个性能问题】

 
 


 
 

 
 

 
 

 
 

List of Rendering Commands

 
 

The excellent talk by Nick Whiting and Nick Donaldson contains a list of render commands to use for GPU optimization in VR. You can find the list below. I recommend watching their talk regardless as it contains great info on the basics of Virtual Reality in general.

【这文章包含一系列的渲染命令来做用于VR渲染优化,强烈建议看看。】

 
 

To test out these commands hit ~ (Tilde) to open the command console. Once you settled on a command to be included for your project, you can add them to your configuration in /Config/DefaultEngine.ini under [/Script/Engine.RendererSettings]. Tip: Check if the command exists in the list before adding it yourself.

【相关设置你可以加入你的代码工程设置,做法如上述。】

 
 

r.SeparateTranslucency=0

r.HZBOcclusion=0

r.FinishCurrentFrame=1

r.MotionBlurQuality=0

r.PostProcessAAQuality=3

r.BloomQuality=1

r.EyeAdaptionQuality=0

r.AmbientOcclusionLevels=0

r.DepthOfFieldQuality=0

r.SceneColorFormat=2

r.TranslucentLightingVolume 0

r.TranslucencyVolumeBlur=0

r.TranslucencyLightingVolumeDim=4

r.MaxAnisotropy=8

r.LensFlareQuality=0

r.SceneColorFringeQuality=0

r.FastBlurThreshold=0

r.SSR.MaxRoughness=0

r.SSR.Quality=0

r.rhicmdbypass=0

r.TiledReflectionEnvironmentMinimumCount=10

 
 

 
 

 
 

Troubleshooting

 
 

  •  
     

    Vive Specific (Non-PRE editions): Once you launched the editor, SteamVR may state “Not Ready” this means something may be overlapping and preventing the Compositor screen to run at more than 60 FPS causing jittering and motion sickness. More information and workaround for this issue can be found on this AnswerHub Thread! The next iteration of Vive devices (Vive PRE) no longer have this issue as they moved to direct mode for the displays, for this make sure you updated your graphics drivers to support direct mode.

     
     


     
     

     
     

     
     

     
     

    References

     
     

  • Official Documentation Main Page
  • VR Cheat Sheet
  • Unreal Engine VR Subforums
  • Unreal Engine VR Playlist
  •  
     

    Hopefully this guide has helped you get started with Virtual Reality project!

    If you have a question or feel that I missed something important, let me know by leaving a reply below! To stay in touch, follow me on Twitter!

     
     

     
     

     
     

     
     

     
     

     
     

     
     

     
     

     
     

     
     

     
     

     
     

     
     

     
     

     
     

     
     

     
     

     
     

     
     

Machine Learning Foundations 1: The Learning Problem


 
 

课程基本信息

 
 


 
 

机器学习 学习的两条路径

 
 

理论:数学之美,但是不会用

方法:直接一个一个例子使用,但是不知道该在什么情况下用什么。

 
 


 
 

这门课里面是从基础切入。

每一个学习机器学习的人都因该会的东西。

不代表简单。

 
 

想听一个故事一样听课:

从问题出发,什么时候用得上机器学习,为什么这时候会用机器学习,机器学习是怎么样做的,怎么样让机器学习的更好。

 
 


 
 

NTU课程安排:

 
 

15-17周,每周两小时。

流程图表示的是学生专业分布。

 
 

Coursear课程安排:

 
 

前八周基础,后八周另开一门课讲应用。

从黑板教学变成投影片教学。

 
 


 
 

测验小问题。

 
 


 
 

答案:XXXV

 
 


 
 

开始讲第一部分:

 
 

我们什么时候用机器学习?

 
 

 
 


 
 

到底什么是学习?

 
 

学习是从观察出发,经过脑袋的转化过程,最后变成有用的技能技巧。

机器学习就是模拟上面的学习过程。电脑通过对数据的观察,来变成电脑的处理技巧。

 
 


 
 

技巧是什么?

对于某种表现的增进。

 
 

机器学习的过程就是从数据出发,通过运算得到某种表现的增进。

 
 

例子:电脑通过对股票数据的学习,来获得股票分析的增进,告诉你怎么炒股赚钱。

 
 

在这个定义之下,我们为什么要使用机器学习?

 
 


 
 

这张图里面是什么?

 
 

大家都知道是树,那么我们怎么去定义树?

 
 

如果我们要让机器认知到树,那么我们就必须去定义树的规则。而我们自己去手动的定义这个问题告诉电脑,然后电脑根据这个定义做分析,这个工作量几乎不可能实现。

而作为人的话,比如小孩是自己通过观察去了解到这是树,而机器学习就是来模仿着一个过程,让机器自己去学习了解这棵树,这会比较可行。

 
 


 
 

机器学习有如下方向应用:

 
 

有的系统很难去定义规则,人对其相关工作了解有限:比如火星车会遇到的问题。

人对其规则难以定义和表述:视觉和听觉

人想都没想过的事情:股票高频交易

个性化的提供服务。

 
 


 
 

机器学习的三个关键:

 
 

用来判断这个问题是否适合使用机器学习。

 
 

  1. 有某一种表现可以增进,有学习目标。
  2. 我们不知道怎样写下规则。
  3. 我们要有数据资料。

 
 


 
 

小测验:这些例子是否适合机器学习。

 
 


 
 

答案:XXVX

 
 

第一个表现难以增进,第二个有规则容易看出来,第四个没有数据资料。

 
 


 
 

机器学习应用:衣食住行 四大领域

 
 

从twitter上分析出餐厅好坏

学习怎样搭配衣服好看

预测房子的能源消耗

自动辨识交通信号灯,提升准确率

 
 


 
 

再来例子:教育

 
 

线上答题,系统自动知道学生会了什么,还不会什么,提高再学习效率。

 
 

解决方法:

正确率 = if ( 学生等级 > 题目难度 )

然后通过已有以分类资料来判断

 
 

当年台大拿下比赛第一

 
 


 
 

最后一个例子:娱乐

 
 

推荐系统

推荐给使用者更喜欢的电影

 
 

Netfilx 美国线上最大的电影租借公司

分享数据来让大家比赛,提升推荐解决方案

Yahoo music 也做了类似方法

 
 


 
 

我们怎么决定喜不喜欢这部电影

 
 

一种解决方案:

 
 

喜好 约等于 电影特征组合

人:描述成一串特征数字

电影:相同描述成一串特征数字

内积分数越高则表示会越喜欢

 
 

11 年台大又拿了第一名

 
 


 
 

小测验:哪个领域用不到机器学习

 
 


 
 

答案是都用得到

 
 

机器学习完整流程

 
 


 
 

接下来讲机器学习比较具体的长什么样子,就是机器学习完整流程。

 
 

这边举个例子是银行对信用卡使用者的分析

 
 

上面是一张申请表,机器学习希望通过这些数据来决定要不要给这个人发信用卡。

 
 


 
 

符号表示方法

 
 

X : 输入(申请人)

Y : 答案(要不要发卡)

F : 目标函数(目标,但是得不到)

D : 数据资料

G : 假说函数(机器学习学到的函数,理想就是等于F),然后用G来做判断

 
 

最后是机器学习做法的符号化表示

 
 


 
 

详细过程

 
 

数据资料 -> 机器学习演算法 -> 得到G(fg越像越好)

 
 

G 一般长什么样呢?

 
 


 
 

举三个G的例子:

年收入大于80万的给信用卡

负债大于十万的给信用卡

工作年限小于两年的给信用卡


所有的称H

 
 

机器学习演算法A:

从上面的一堆假设里面找出一个最符合当前已知数据的,当作G

 
 

机器学习模型:A & H

 
 


 
 

机器学习具体定义:

 
 

从资料出发,算出G要很接近期望的f

 
 


 
 

小测验:哪个是哪个表示

 
 


 
 

答案 2

 
 

机器学习和相关领域

 
 


 
 

Data mining:通过数据找出一些有趣的事情

 
 

比较两者定义

 
 

如果 有趣的事情 = f 则 两者一致

如果 有趣的事情 related to f 则相互帮助

DM 通常关注于有效的快速的计算大数据

 
 

两者密不可分

 
 


 
 

AI:通过计算做一些聪明的表现

 
 

机器学习是实现人工智能的一种方法

 
 


 
 

统计学:通过数据做推论

 
 

统计是实现机器学习的一种方法

 
 


 
 

小测验:3是对的

 
 


 
 

总结:这里讲了四个问题

定义

应用

描述

与其他领域的关系

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

Caffe 训练自有数据

走完这个就知道怎么去完整的使用caffe训练自己的数据了。

 
 

参考:

http://www.jianshu.com/p/607f1e51e3ab

http://blog.csdn.net/qqlu_did/article/details/47131549

 
 

步骤:

 
 

  1. 原始数据准备

存放目录下的原始数据


首先去下载,然后将train/detect分别放在不同的文件夹里面

然后通过Matlab来生成Label文件

文件格式为:【文件名 标签】注意train的标签必须是0开始,detect的标签全为0

 
 

  1. 用于处理的中间文件生成

 
 

首先执行


来转换数据格式,得到:


 
 

然后执行


来求mean,得到:


 
 

这边要注意的是上面两个文件的编写,主要就是修改路径和文件名。

 
 

  1. 建立网络模型和运行

 
 

首先要建立学习模型,就是编写 solver.prototxt/train_val.prototxt 两个文件。

可以去如下目录运用别人的学习模型考过来直接用。


这里同样要注意的是参数和路径的修改。

 
 

最后直接运行:

 
 

.\bin\compute_image_mean.exe .\data\img_train_lmdb .\data\mean.binaryproto

 
 

此句也要注意改路径。

 
 

打日志运行:


 
 

问题:

 
 

  1. 数据问题

 
 


 
 

是图片尺寸不对,不是 256*256

 
 

注意创建 db 数据的时候要开启resize, 默认是关闭的。

 
 


 
 

 
 

  1. 参数问题

     
     


 
 

test_iter: 100

 
 

这个要与test layer中的batch_size结合起来理解。mnist数据中测试样本总数为10000,一次性执行全部数据效率很低,因此我们将测试数据分成几个批次来执行,每个批次的数量就是batch_size。假设我们设置batch_size为100,则需要迭代100次才能将10000个数据全部执行完。因此test_iter设置为100。执行完一次全部数据,称之为一个epoch

 
 

test_interval: 500

 
 

测试间隔。也就是每训练500次,才进行一次测试。

 
 

base_lr: 0.01

lr_policy: “inv”

gamma: 0.0001

power: 0.75

 
 

这四行可以放在一起理解,用于学习率的设置。只要是梯度下降法来求解优化,都会有一个学习率,也叫步长。base_lr用于设置基础学习率,在迭代的过程中,可以对基础学习率进行调整。怎么样进行调整,就是调整的策略,由lr_policy来设置。

 
 

– fixed:   保持base_lr不变.

– step:    如果设置为step,则还需要设置一个stepsize, 返回 base_lr * gamma ^ (floor(iter / stepsize)),其中iter表示当前的迭代次数

– exp:   返回base_lr * gamma ^ iter, iter为当前迭代次数

– inv:   如果设置为inv,还需要设置一个power, 返回base_lr * (1 + gamma * iter) ^ (- power)

– multistep: 如果设置为multistep,则还需要设置一个stepvalue。这个参数和step很相似,step是均匀等间隔变化,而multistep则是根据 stepvalue值变化

– poly:    学习率进行多项式误差, 返回 base_lr (1 – iter/max_iter) ^ (power)

– sigmoid: 学习率进行sigmod衰减,返回 base_lr ( 1/(1 + exp(-gamma * (iter – stepsize))))

 
 

 
 

momentum :0.9

 
 

上一次梯度更新的权重,具体可参看下一篇文章。

 
 

type: SGD

 
 

优化算法选择。这一行可以省掉,因为默认值就是SGD。总共有六种方法可选择,在本文的开头已介绍。

 
 

weight_decay: 0.0005

 
 

权重衰减项,防止过拟合的一个参数。

 
 

display: 100

 
 

每训练100次,在屏幕上显示一次。如果设置为0,则不显示。

 
 

max_iter: 20000

 
 

最大迭代次数。这个数设置太小,会导致没有收敛,精确度很低。设置太大,会导致震荡,浪费时间。

 
 

snapshot: 5000

snapshot_prefix: “examples/mnist/lenet”

 
 

快照。将训练出来的model和solver状态进行保存,snapshot用于设置训练多少次后进行保存,默认为0,不保存。snapshot_prefix设置保存路径。

还可以设置snapshot_diff,是否保存梯度值,默认为false,不保存。

也可以设置snapshot_format,保存的类型。有两种选择:HDF5 和BINARYPROTO ,默认为BINARYPROTO

 
 

solver_mode: CPU

 
 

设置运行模式。默认为GPU,如果你没有GPU,则需要改成CPU,否则会出错。

 
 

 
 

 
 

 
 

 
 

 
 

 
 

Caffe Notes

Caffe 文件结构:

 
 

http://blog.csdn.net/thystar/article/details/50052707


 
 

这里,最重要的三个文件夹就是include, tools, src。在源码解读中会对里面的文件代码一一介绍,这里给出src文件的结构:

 
 


src中的每个.cpp文件对应include文件中的头文件。

 
 

在编译完成后,会生成build文件夹。这个文件的目标文件指向一个debug或者release文件夹。这里建议用debug编译,这样在调试代码时可以跟到caffe的内部。只要在Makefile.config中改一下就好。

 
 

 
 

 
 

caffe的三级结构:Blobs,Layers,Nets

 
 

http://blog.csdn.net/thystar/article/details/50675076

 
 


 
 

深度网络是一个复杂的模型,caffe定义了一个层与层之间连接的网络模型。这个网络定义了从输入层到损失的所有模型。caffe使用blobs结构存储,交换和处理网络中正向和反向迭代时的数据和导数信息,blob是Caffe的标准数组结构,它提供了一个统一的内存接口。Layer是Caffe模型和计算的基本单元。Net是一系列的Layer和其连接的集合,Blob详细描述了信息是如何在Layer和net中存储和交换的。

 
 

solving:是求解方法,分别配置解耦模型和优化方法

 
 

1. Blob存储与交换

 
 

Blob是caffe中负责数据传递和处理的包,并且提供了在CPU与GPU之间同步处理的功能。从数学角度看,Blob是C语言风格的一个连续存数的N维数组。

 
 

Caffe利用Blobs存储和交换数据,Blobs提供了统一的内存接口存储某种类型的数据,如批处理的图像数据,模型参数和用与优化算法的导数。

 
 

Blobs可以根据CPU主机和GPU设备的需要,屏蔽CPU/GPU计算和混合操作中的开销,主机和设备的内存按需求分配(lazily),以提高内存利用率。

 
 

对于批处理的图片来说,Blobs常规的维度为:图像数据的个数N * 通道数K * 图像高度H * 图像宽度W。Blob按行存储, 这使得它最后/最右面的维度更新的最快。比如,在一个4维的blob中,位置为(n,k,h,w)的值的物理位置为((n * K + k) * H + h) * W + w.

 
 

Number/N是每批处理数据的规模,批量处理数据有利于提高设备处理和交换数据的吞吐率。在Imagenet上训练数据每批有256张图像,则N=256.

 
 

Channel/K是特征维度,对于RGB图像K=3.

 
 

虽然在Caffe在用于图像数据过程中,Blob都是4维的,但是它完全可以用于非图像数据。例如,如果你仅需要类似于传统多层感知机那样的全连接网络,使用2维的blobs(形式为(N,D)) , 然后调用InnerProdectLayer(全连接层)即可。

 
 

Blob的维度参数根据层的类型和配置而变化,对于由96个规模为11*11,输入为3通道的滤波器构成的卷积层,blob的维度为96*3×11*11,对于一个输入是1024维,输出是1000维的内几层和全连接层,blob的维度是1000*1024.

 
 

对于一些特定的数据,自己设计输入工具或数据层是有必要的,但是,一旦数据准备完毕,各种层模块会帮你完成剩下的工作。

 
 

 
 

实现细节:

 
 

对于blob中的数据,我们通常会关心它的值和梯度,因此,blob存储了两块数据内容:data和diff。前者是通过网络的普通数据,后者是网络反向计算得到的梯度。

 
 

而且,因为数据既可以存储在CPU上,又可以存储在GPU上,因而有两种不同的访问方式:静态方式,不改变数值,动态方式,改变数值。

 
 


const Dtype* cpu_data() const;

Dtype* mutable_cpu_data();

 
 

这么设计是为了用SyncedMem类来同步CPU与GPU上的数值,以隐藏同步细节,最小化传送数据。一个准则是,如果你不想改变数值,就一直用常数调用,不要在你的项目中存储指针,每层操作blob时,调用相应的函数获取它的指针,因为SyncedMem需要用这种方式确定何时需要复制数据。

 
 

实际上,使用GPU时,Caffe中的CPU 代码先从磁盘加载到blob,调用一个(GPU)设备核使GPU进行计算, 再将算好的blob数据送入下一层,忽略了底层的细节,同时又能维持高效的运算。一旦所有的层都有GPU实现,那么所有中间数据和梯度都会保存在GPU上。

 
 

下面的例子解释blub何时复制数据:

 
 


// Assuming that data are on the CPU initially, and we have a blob.假定数据在CPU上进行初始化,我们有一个blob

const Dtype* foo;

Dtype* bar;

foo = blob.gpu_data(); // data copied cpu->gpu.数据从cpu复制到gpu

foo = blob.cpu_data(); // no data copied since both have up-to-date contents.没有数据复制,两者都有最新的内容

bar = blob.mutable_gpu_data(); // no data copied.没有数据复制

// … some operations …一些操作

bar = blob.mutable_gpu_data(); // no data copied when we are still on GPU. 没有数据拷贝,依旧在gpu

foo = blob.cpu_data(); // data copied gpu->cpu, since the gpu side has modified the data 数据从gpu复制到cpu,因为gpu端已经修改了数据

foo = blob.gpu_data(); // no data copied since both have up-to-date contents没有数据拷贝,两边都是最新内容

bar = blob.mutable_cpu_data(); // still no data copied.没有数据拷贝

bar = blob.mutable_gpu_data(); // data copied cpu->gpu.数据从cpu到gpu

bar = blob.mutable_cpu_data(); // data copied gpu->cpu.数据从gpu到cpu

 
 

 
 

 
 

 
 

2. Layer : 计算和连接

 
 

这一层是非常重要的模型,是执行计算的基本单元, Layers可以进行的计算有:convolve filters(卷积滤波), pool(池化),inner products(内积), 及一些非线性运算如rectified-linear(限制线性运算),sigmoid及元素级的数据转换,normalize(归一化),数据加载,计算损失,如softmax和hinge。

 
 


 
 

这一层通过bottom(底部)连接层接收数据,通过top(顶部)连接层输出数据

 
 

每个类型的层都定义了三种重要运算:setup, forward, 和backward.

 
 

Setup: 在模型初始化时,初始化层和它的连接

Forward: 从bottom给定的输入计算输出,传到top层中

Backward: 给定输出层的梯度,计算相对于输入层的梯度,并传到bottom层,一个有参的layer需要计算相对于各个参数的梯度并存储。

 
 

特别的,Forward和Backward函数有CPU和GPU两种执行方式。如果你没有执行GPU版本,layer会转为作为备选的CPU方式,这会增加额外的数据传送成本,但是对于一些快速实验还是很方便的(尽管输入数据要由gpu到cpu,之后输出数据从gpu回到cpu)。

 
 

Layers承担了整个网络的两个核心操作: 前向传播,接收输入计算输出;反向传播,接收关于输出的梯度,计算参数的梯度并反向传播给前面的层,由此组成了每个layer的前向和反向通道。

 
 

由于caffe网络的组合性和其代码的模块化,定义layer是很容易的,只要定义好setup,forward,backward,就可以将layer接入到网络中。

 
 

 
 

 
 

  1. Net的定义和操作:

 
 

net通过组合和自动微分,定义了一个函数和其对应的梯度。通过各个层的输出计算这个函数,执行给定的任务。并通过组合各个层的反向传播过程计算学习任务中损失函数的梯度,caffe模型是一种端到端的机器学习引擎。

 
 

net是由一系列层组成的有向无环图,Caffe保留了图中所有层的中间值以确保前向和反向迭代的正确性。一个典型的net开始于数据(data)层,从磁盘中加载数据,结束于损失(loss)层,计算目标任务,如分类和重构。

 
 

net模型定义在一个纯文本模型语言中,有一系列的层和它们的连接构成。一个简单的逻辑回归定义如下:

 
 


 
 

其网络结构定义为:

 
 


 
 

模型通过Net::Init()初始化,初始化主要做两件事情:通过创建blobs和layers搭建整个网络的DAG图; 调用layers的Setup()函数。初始化时会有一系列的记录,例如整个网络的结构是否正确构建。同时,Net在初始化阶段会将其日志答应在INFO中:

 
 


 
 

注意:caffe中网络的构件与设备无关,回想之前解释过的blobs和layers是为了从模型定义中隐藏实现细节的,网络构建完成之后,通过设置Caffe::mode()和Caffe::set_mode(),网络将在CPU或GPU中运行。CPU和GPU的实现结果相同,CPU和GPU可以无缝切换并且独立于模型定义

 
 

 
 

 
 

Model格式

 
 

Caffe的模型定义在纯文本的协议上(prototxt),学习好的模型被序列化到二进制protocol buffer(binaryproto).caffemodel文件中。

 
 

模型格式用protobuf语言定义在caffe.proto文件中。这部分也会在笔记中解释。

 
 

 
 

 
 

 
 

前向传播和反向传播

 
 

http://blog.csdn.net/thystar/article/details/51244234

 
 

 
 

前向传播和反向传播是计算神经网络非常重要的部分。

 
 


 
 

考虑一个简单的逻辑回归分类问题

 
 

前向传播:通过网络的输入计算输出结果的过程,在前向传播中,caffe整合每一层的计算得到整个模型的计算函数,这个过程是个自底向上的过程,如图:

 
 


 
 

数据x通过通过内积层得到g(x),然后通过softmax得到h(g(x))和损失函数(softmax loss)fw(x).

 
 

反向传播网络:根据损失计算梯度,在反向传播过程中,Caffe通过自动求导计算逆向组合每一层的梯度得到整个模型的梯度,在反向传播中,这个过程是自顶向下的。如图:

 
 


反向过程由loss开始,根据输出计算梯度dfw/dh (fw对h求导), 模型中其余各层的梯度根据链式法则计算。每层的参数:如INNER_PRODUCT层,在反馈过程中对参数计算梯度dfw/dWip.

 
 

你只需要定义好模型,这些计算就可以立即执行,caffe已经定义好的前向传播和反向传播的执行方法。

 
 

Net::Forward()和Net::Backward()实现整个网络的前向与后向的传播,Layer::Forward和Layer::Backward()计算每一层的前后向的传播

 
 

每一层都有backward_{cpu,gpu}和backward{cpu,gpu}方法适应不同的计算模式。但是,一个层仅能使用其中的一种模式

 
 

Solver优化一个模型,首先通过forward计算输出和损失,然后通过backward生成模型的梯度,让后根据梯度和权值更新最小话损失函数,Solver,Net和Layer间的分离保证了caffe的模块化设计和开源。

 
 

 
 

 
 

loss function

 
 

http://blog.csdn.net/thystar/article/details/51248272

 
 

与大多数的机器学习算法一样,caffe的学习也是由loss function驱动的(或者叫error,cost,objective function)。损失函数的目标是,将参数(就是网络中的权值和偏置)映射到一个能够度量参数”不好程度”的标量中,因此,其目标就是让这个标量最小化(其实就是调整参数,是的损失函数的值最小)。

 
 

在caffe中,通过前向传播计算损失,每一层由一系列的输入(bottom)blobs产生一系列的输出(top),某些层的输出可以用于损失函数,一类典型的多分类任务的损失函数是SoftmaxWithLoss函数,其定义如下:

 
 


 
 

在SoftmaxWithLoss函数中,top blob是一个标量值,它是整个mni-batch损失的平均值(由预测标签和真实标签计算得到)

 
 

 
 

Loss weights

 
 

如果一个网络由多个层可以产生损失(比如,一个网络使用SoftmaxWithLoss对输入数据分类,同时也使用EuclideanLoss层重构网络), loss weights可以用来给定两个损失的重要性.

 
 

按惯例 , caffe中后缀为loss的层均用于损失函数, 其他层单纯的用于中间计算。但是,可以通过添加一个loss_weight: <float>字段将任意层定义为一个loss。对于后缀为loss的层,该层的第一个top blob的loss_weight默认为1,其余层默认为0。因此上面的SoftmaxWithLoss层的定义等价于:

 
 


 
 

但是,对于能反向传播的层,可以给定一个非0的loss_weight,例如,如果需要,正则化网络中某些层的中间值。对于有关联损失的非孤立的输出,其损失可以简单通过所有blob的求和计算的出

 
 

caffe中整个网络的损失可以通过对整个权值损失求和得到,其伪代码如下:

 
 


 
 

 
 

 
 

mnist数据集的训练

 
 

http://blog.csdn.net/thystar/article/details/50470325

 
 

怎么运行在此不讲,主要看代码。

 
 

1. 准备数据

 
 

get_mnist.sh

 
 

用于获取数据,主要是靠wget的使用。

 
 


 
 

/examples/mnist/create_mnist.sh

 
 

#生成数据,这个脚本的作用是将数据转换成lmdb格式或leveldb格式,具体如下:

 
 


 
 

convert_mnist_data.bin是由convert_minst_data.cpp编译生成的可执行文件,这个编译过程就是在caffe安装的时候完成的,这个函数接受四个参数:

 
 

$DATA/train-images-idx3-ubyte: 手写数字源文件

$DATA/train-labels-idx1-ubyte: 手写数字标签文件

$EXAMPLE/mnist_train_${BACKEND} : 转换后数据的存储位置

–backend=${BACKEND} : 宏定义,转换数据的格式lmdb或leveldb

 
 

注:convert_mnist_data.cpp及用到的其他文件在下一篇中介绍

 
 

 
 

2. 网络模型

 
 

这个实验中使用的模型是LeNet,其模型结构如下:

 
 


 
 

这个网络包含两个卷积层,两个池化层,两个全连接层,最后一层用于分类

 
 

其结构定义在:$CAFFE_ROOT/examples/mnist/lenet_train_test.prototxt中,图示如下

 
 


 
 

 
 

对于这个文档的了解,需要查看caffe.proto相关的内容

 
 

首先,给出网络名称

 
 


 
 

数据层

 
 

接着,是数据层的写入

 
 

这里,我们从之前创建的lmdb文件夹中读入数据

 
 


 
 

文档中还有另一个数据层,用于测试阶段

 
 

卷积层

 
 


 
 

池化层

 
 


 
 

全连接层

 
 


 
 

非线性层

 
 


 
 

准确率层

 
 


 
 

损失估计层

 
 


 
 

 
 

3.模型优化文件

 
 

这个文件在$CAFFE_ROOT/examples/mnist/lenet_solver.prototxt,配置一些参数信息等

 
 


 
 

 
 

接下来就是执行训练

 
 

在caffe根目录下输入:


 
 

执行过程

首先,程序读取lenet_solver.prototxt和lenet_train_test.prototxt这两个配置文件。

之后,紧跟着创建每层网络。

接下来,开始计算反馈网络。

之后,输出测试网络和创建过程。

这一步完成后,开始优化参数

当代码运行到这里时,进入迭代优化过程

待运行结束,输出结果:


其中,#0:为准确度, #1:为损失

 
 

 
 

 
 

CIFAR-10 tutorial

 
 

 
 

这是caffe官网中Examples中的第三个例子,链接地址:

http://caffe.berkeleyvision.org/gathered/examples/cifar10.html

 
 

这个例子重现了Alex Krizhevsky的cuda-convnet中的结果,具体的模型定义、参数、训练步骤等都是按照cuda-convnet中的进行设置的。

 
 

数据集描述:CIFAR-10数据集包含60000张32*32的彩色图像,包含10类,每类6000张图片,50000张训练样本图片,10000张测试样本图片。 图片类型:airplane, bird, car, cat, deer, dog, horse, monkey, ship, truck.

 
 

下面进入训练阶段

 
 

1. 获取数据:

 
 

./data/cifar10/get_cifar10.sh

./examples/cifar10/create_cifar10.sh

 
 

还是要根据本地环境改一下内容,就能跑起来。

 
 

2. 使用模型:

 
 

网络结构模型





 
 

对于学习率的影响,在Simon Haykin的《神经网络与及其学习》中说道(中文版p86):反向传播算法提供使用最速下降方法在权值空间计算得到的轨迹的一种近似,使用的参数越小,从一次迭代到下一次迭代的网络突触权值的变化量就越小,轨迹在权值空间就越光滑,然而,这种改进是以减慢学习速度为代价的。另一方面,如果学习率的值太大,学习速度加快,就可能使网络的权值变化量不稳定。

 
 

 
 

3. 训练

 
 

执行

 
 

./examples/cifar10/train_quick.sh

训练数据,输出形式类似与mnist训练的形式,这里不重复。

 
 

训练结果的正确率大约在75%

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

Use Caffe windows(Microsoft)

windows下安装使用微软版本的Caffe。

 
 

下载安装微软官方版

https://github.com/BVLC/caffe/tree/windows

 
 

按照其说明安装:

  1. 拉下源码
  2. 下载安装Cuda和cuDNN
  3. .\windows\CommonSettings.props.example 将后面的.example去掉启用配置
  4. 配置设置:

    主要是改两项:python/matlab设置

    还要注意的是可能会有报错,其中一个是去掉某行注释,具体问题具体搜索。

  5. 直接Build就可以成功了,libcaffe编译成功后再编译caffe,所有编译成功和运行需要的dll文件都会存储在CAFFE_ROOT\Build\x64\Release 下

 
 

然后跑例子 mnist:

这边特别注意的就是原来的 .sh 是为linux准备的,因此在windows上要费些周折

  1. 拉资源:先到data\mnist\目录下下载资源,windows上.sh不能直接跑wget,那就看代码找出其要下载的包手动下下来,或者使用windows版本的wget来下来得到如下:


然后请手动解压并注意文件名


  1. 将下载下来的mnist数据转换为lmdb格式

    打开CAFFE_ROOT/windows/Caffe.sln ,生成convert_mnist_data 项目(Release,x64)


  2. 然后去examples/mnist目录下执行create_mnist.sh来生成最终的可以快速读写的文件,下图两个文件夹就是生成的结果。

注意create_mnist.sh需要做一些修改

将 BUILD=build/examples/mnist 改为 BUILD=Build/x64/Release

将 执行文件 .bat 改为 .exe


  1. 然后就可以真正执行数据训练了

    在CAFFE_ROOT 下新建一个文本文件,命名为run_mnist.bat

    内容如下

     
     

    .\Build\x64\Release\caffe.exe train –solver=examples/mnist/lenet_solver.prototxt

    pause

     
     

    运行 run_mnist.bat , 即开始训练网络,训练过程中可以看到训练的loss和测试的accuracy,最终结果的识别率在99%以上

 
 

参考:

http://blog.csdn.net/tsyccnh/article/details/51671872

http://blog.csdn.net/tsyccnh/article/details/51673474

 
 

如何调适的说明,也就是通过VS来启动的方式:

http://blog.csdn.net/tsyccnh/article/details/51679121

 
 

extract_features 项目使用:

http://blog.csdn.net/tsyccnh/article/details/51682573

 
 

如何保存日志,以及可视化日志内容

http://blog.csdn.net/tsyccnh/article/details/51692463

 
 

补充:pycaffe编译依赖需要的python扩展库安装:

命令行:

conda install –yes numpy scipy matplotlib scikit-image pip

pip install protobuf

不搞这个python不能正确编译使用。

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

Book Note – Deep Learning

http://blog.csdn.net/zouxy09/article/details/8775360

 
 

一、概述

 
 

       Artificial Intelligence,也就是人工智能,就像长生不老和星际漫游一样,是人类最美好的梦想之一。虽然计算机技术已经取得了长足的进步,但是到目前为止,还没有一台电脑能产生”自我”的意识。是的,在人类和大量现成数据的帮助下,电脑可以表现的十分强大,但是离开了这两者,它甚至都不能分辨一个喵星人和一个汪星人。

 
 

       图灵(图灵,大家都知道吧。计算机和人工智能的鼻祖,分别对应于其著名的”图灵机”和”图灵测试”)在 1950 年的论文里,提出图灵试验的设想,即,隔墙对话,你将不知道与你谈话的,是人还是电脑。这无疑给计算机,尤其是人工智能,预设了一个很高的期望值。但是半个世纪过去了,人工智能的进展,远远没有达到图灵试验的标准。这不仅让多年翘首以待的人们,心灰意冷,认为人工智能是忽悠,相关领域是”伪科学”。

 
 

        但是自 2006 年以来,机器学习领域,取得了突破性的进展。图灵试验,至少不是那么可望而不可及了。至于技术手段,不仅仅依赖于云计算对大数据的并行处理能力,而且依赖于算法。这个算法就是,Deep Learning。借助于 Deep Learning 算法,人类终于找到了如何处理”抽象概念”这个亘古难题的方法。

 
 


 
 

       20126月,《纽约时报》披露了Google Brain项目,吸引了公众的广泛关注。这个项目是由著名的斯坦福大学的机器学习教授Andrew Ng和在大规模计算机系统方面的世界顶尖专家JeffDean共同主导,用16000CPU Core的并行计算平台训练一种称为”深度神经网络”(DNNDeep Neural Networks)的机器学习模型(内部共有10亿个节点。这一网络自然是不能跟人类的神经网络相提并论的。要知道,人脑中可是有150多亿个神经元,互相连接的节点也就是突触数更是如银河沙数。曾经有人估算过,如果将一个人的大脑中所有神经细胞的轴突和树突依次连接起来,并拉成一根直线,可从地球连到月亮,再从月亮返回地球),在语音识别和图像识别等领域获得了巨大的成功。

 
 

       项目负责人之一Andrew称:”我们没有像通常做的那样自己框定边界,而是直接把海量数据投放到算法中,让数据自己说话,系统会自动从数据中学习。”另外一名负责人Jeff则说:”我们在训练的时候从来不会告诉机器说:’这是一只猫。’系统其实是自己发明或者领悟了”猫”的概念。”

 
 


 
 

       201211月,微软在中国天津的一次活动上公开演示了一个全自动的同声传译系统,讲演者用英文演讲,后台的计算机一气呵成自动完成语音识别、英中机器翻译和中文语音合成,效果非常流畅。据报道,后面支撑的关键技术也是DNN,或者深度学习(DLDeepLearning)。

 
 

       20131月,在百度年会上,创始人兼CEO李彦宏高调宣布要成立百度研究院,其中第一个成立的就是”深度学习研究所”(IDLInstitue of Deep Learning)。

 
 


 
 

       为什么拥有大数据的互联网公司争相投入大量资源研发深度学习技术。听起来感觉deeplearning很牛那样。那什么是deep learning?为什么有deep learning?它是怎么来的?又能干什么呢?目前存在哪些困难呢?这些问题的简答都需要慢慢来。咱们先来了解下机器学习(人工智能的核心)的背景。

 
 

 
 

 
 

二、背景

 
 

      机器学习(Machine Learning)是一门专门研究计算机怎样模拟或实现人类的学习行为,以获取新的知识或技能,重新组织已有的知识结构使之不断改善自身的性能的学科。机器能否像人类一样能具有学习能力呢?1959年美国的塞缪尔(Samuel)设计了一个下棋程序,这个程序具有学习能力,它可以在不断的对弈中改善自己的棋艺。4年后,这个程序战胜了设计者本人。又过了3年,这个程序战胜了美国一个保持8年之久的常胜不败的冠军。这个程序向人们展示了机器学习的能力,提出了许多令人深思的社会问题与哲学问题(呵呵,人工智能正常的轨道没有很大的发展,这些什么哲学伦理啊倒发展的挺快。什么未来机器越来越像人,人越来越像机器啊。什么机器会反人类啊,ATM是开第一枪的啊等等。人类的思维无穷啊)。

 
 

        机器学习虽然发展了几十年,但还是存在很多没有良好解决的问题:

 
 


 
 

        例如图像识别、语音识别、自然语言理解、天气预测、基因表达、内容推荐等等。目前我们通过机器学习去解决这些问题的思路都是这样的(以视觉感知为例子):

 
 


 
 

        从开始的通过传感器(例如CMOS)来获得数据。然后经过预处理、特征提取、特征选择,再到推理、预测或者识别。最后一个部分,也就是机器学习的部分,绝大部分的工作是在这方面做的,也存在很多的paper和研究。

 
 

        而中间的三部分,概括起来就是特征表达。良好的特征表达,对最终算法的准确性起了非常关键的作用,而且系统主要的计算和测试工作都耗在这一大部分。但,这块实际中一般都是人工完成的。靠人工提取特征。

 
 


 
 

       截止现在,也出现了不少NB的特征(好的特征应具有不变性(大小、尺度和旋转等)和可区分性):例如Sift的出现,是局部图像特征描述子研究领域一项里程碑式的工作。由于SIFT对尺度、旋转以及一定视角和光照变化等图像变化都具有不变性,并且SIFT具有很强的可区分性,的确让很多问题的解决变为可能。但它也不是万能的。

 
 


 
 

       然而,手工地选取特征是一件非常费力、启发式(需要专业知识)的方法,能不能选取好很大程度上靠经验和运气,而且它的调节需要大量的时间。既然手工选取特征不太好,那么能不能自动地学习一些特征呢?答案是能!Deep Learning就是用来干这个事情的,看它的一个别名UnsupervisedFeature Learning,就可以顾名思义了,Unsupervised的意思就是不要人参与特征的选取过程。

 
 

       那它是怎么学习的呢?怎么知道哪些特征好哪些不好呢?我们说机器学习是一门专门研究计算机怎样模拟或实现人类的学习行为的学科。好,那我们人的视觉系统是怎么工作的呢?为什么在茫茫人海,芸芸众生,滚滚红尘中我们都可以找到另一个她(因为,你存在我深深的脑海里,我的梦里
我的心里
我的歌声里……)。人脑那么NB,我们能不能参考人脑,模拟人脑呢?(好像和人脑扯上点关系的特征啊,算法啊,都不错,但不知道是不是人为强加的,为了使自己的作品变得神圣和高雅。)

 
 

        近几十年以来,认知神经科学、生物学等等学科的发展,让我们对自己这个神秘的而又神奇的大脑不再那么的陌生。也给人工智能的发展推波助澜。

 
 

 
 

 
 

三、人脑视觉机理

 
 

       1981 年的诺贝尔医学奖,颁发给了 David Hubel(出生于加拿大的美国神经生物学家)
TorstenWiesel,以及 Roger Sperry。前两位的主要贡献,是”发现了视觉系统的信息处理”:可视皮层是分级的:

 
 


 
 

        我们看看他们做了什么。1958 年,DavidHubel Torsten Wiesel JohnHopkins University,研究瞳孔区域与大脑皮层神经元的对应关系。他们在猫的后脑头骨上,开了一个3 毫米的小洞,向洞里插入电极,测量神经元的活跃程度。

 
 

      然后,他们在小猫的眼前,展现各种形状、各种亮度的物体。并且,在展现每一件物体时,还改变物体放置的位置和角度。他们期望通过这个办法,让小猫瞳孔感受不同类型、不同强弱的刺激。

 
 

       之所以做这个试验,目的是去证明一个猜测。位于后脑皮层的不同视觉神经元,与瞳孔所受刺激之间,存在某种对应关系。一旦瞳孔受到某一种刺激,后脑皮层的某一部分神经元就会活跃。经历了很多天反复的枯燥的试验,同时牺牲了若干只可怜的小猫,David Hubel Torsten Wiesel 发现了一种被称为”方向选择性细胞(Orientation Selective Cell)”的神经元细胞。当瞳孔发现了眼前的物体的边缘,而且这个边缘指向某个方向时,这种神经元细胞就会活跃。

 
 

       这个发现激发了人们对于神经系统的进一步思考。神经中枢大脑的工作过程,或许是一个不断迭代、不断抽象的过程。

 
 

       这里的关键词有两个,一个是抽象,一个是迭代。从原始信号,做低级抽象,逐渐向高级抽象迭代。人类的逻辑思维,经常使用高度抽象的概念。

 
 

        例如,从原始信号摄入开始(瞳孔摄入像素 Pixels),接着做初步处理(大脑皮层某些细胞发现边缘和方向),然后抽象(大脑判定,眼前的物体的形状,是圆形的),然后进一步抽象(大脑进一步判定该物体是只气球)。

 
 


 
 

 
 

      这个生理学的发现,促成了计算机人工智能,在四十年后的突破性发展。

 
 

      总的来说,人的视觉系统的信息处理是分级的。从低级的V1区提取边缘特征,再到V2区的形状或者目标的部分等,再到更高层,整个目标、目标的行为等。也就是说高层的特征是低层特征的组合,从低层到高层的特征表示越来越抽象,越来越能表现语义或者意图。而抽象层面越高,存在的可能猜测就越少,就越利于分类。例如,单词集合和句子的对应是多对一的,句子和语义的对应又是多对一的,语义和意图的对应还是多对一的,这是个层级体系。

 
 

      敏感的人注意到关键词了:分层。而Deep learningdeep是不是就表示我存在多少层,也就是多深呢?没错。那Deep learning是如何借鉴这个过程的呢?毕竟是归于计算机来处理,面对的一个问题就是怎么对这个过程建模?

 
 

       因为我们要学习的是特征的表达,那么关于特征,或者说关于这个层级特征,我们需要了解地更深入点。所以在说Deep Learning之前,我们有必要再啰嗦下特征(呵呵,实际上是看到那么好的对特征的解释,不放在这里有点可惜,所以就塞到这了)。

 
 

 
 

 
 

四、关于特征

 
 

        特征是机器学习系统的原材料,对最终模型的影响是毋庸置疑的。如果数据被很好的表达成了特征,通常线性模型就能达到满意的精度。那对于特征,我们需要考虑什么呢?

 
 

4.1、特征表示的粒度

 
 

        学习算法在一个什么粒度上的特征表示,才有能发挥作用?就一个图片来说,像素级的特征根本没有价值。例如下面的摩托车,从像素级别,根本得不到任何信息,其无法进行摩托车和非摩托车的区分。而如果特征是一个具有结构性(或者说有含义)的时候,比如是否具有车把手(handle),是否具有车轮(wheel),就很容易把摩托车和非摩托车区分,学习算法才能发挥作用。

 
 


 
 


 
 

4.2、初级(浅层)特征表示

 
 

        既然像素级的特征表示方法没有作用,那怎样的表示才有用呢?

 
 

        1995 年前后,Bruno Olshausen David Field 两位学者任职 Cornell University,他们试图同时用生理学和计算机的手段,双管齐下,研究视觉问题。

 
 

        他们收集了很多黑白风景照片,从这些照片中,提取出400个小碎片,每个照片碎片的尺寸均为 16×16 像素,不妨把这400个碎片标记为 S[i], i = 0,.. 399。接下来,再从这些黑白风景照片中,随机提取另一个碎片,尺寸也是 16×16 像素,不妨把这个碎片标记为 T

 
 

        他们提出的问题是,如何从这400个碎片中,选取一组碎片,S[k], 通过叠加的办法,合成出一个新的碎片,而这个新的碎片,应当与随机选择的目标碎片 T,尽可能相似,同时,S[k] 的数量尽可能少。用数学的语言来描述,就是:

 
 

        Sum_k (a[k] * S[k]) –> T,     其中 a[k] 是在叠加碎片 S[k] 时的权重系数。

 
 

        为解决这个问题,Bruno Olshausen David Field 发明了一个算法,稀疏编码(Sparse Coding)。

 
 

        稀疏编码是一个重复迭代的过程,每次迭代分两步:

 
 

1)选择一组 S[k],然后调整 a[k],使得Sum_k (a[k] * S[k]) 最接近 T

 
 

2)固定住 a[k],在 400 个碎片中,选择其它更合适的碎片S'[k],替代原先的 S[k],使得Sum_k (a[k] * S'[k]) 最接近 T

 
 

        经过几次迭代后,最佳的 S[k] 组合,被遴选出来了。令人惊奇的是,被选中的 S[k],基本上都是照片上不同物体的边缘线,这些线段形状相似,区别在于方向。

 
 

        Bruno Olshausen David Field 的算法结果,与 David Hubel Torsten Wiesel 的生理发现,不谋而合!

 
 

        也就是说,复杂图形,往往由一些基本结构组成。比如下图:一个图可以通过用64种正交的edges(可以理解成正交的基本结构)来线性表示。比如样例的x可以用1-64edges中的三个按照0.8,0.3,0.5的权重调和而成。而其他基本edge没有贡献,因此均为0

 
 


 
 

        另外,大牛们还发现,不仅图像存在这个规律,声音也存在。他们从未标注的声音中发现了20种基本的声音结构,其余的声音可以由这20种基本结构合成。

 
 


 
 


 
 

4.3、结构性特征表示

 
 

        小块的图形可以由基本edge构成,更结构化,更复杂的,具有概念性的图形如何表示呢?这就需要更高层次的特征表示,比如V2V4。因此V1看像素级是像素级。V2V1是像素级,这个是层次递进的,高层表达由底层表达的组合而成。专业点说就是基basisV1取提出的basis是边缘,然后V2层是V1层这些basis的组合,这时候V2区得到的又是高一层的basis。即上一层的basis组合的结果,上上层又是上一层的组合basis……(所以有大牛说Deep learning就是”搞基”,因为难听,所以美其名曰Deep learning或者Unsupervised Feature Learning

 
 


 
 

        直观上说,就是找到make sense的小patch再将其进行combine,就得到了上一层的feature,递归地向上learning feature

 
 

        在不同object上做training是,所得的edge basis 是非常相似的,但object partsmodels 就会completely different了(那咱们分辨car或者face是不是容易多了):

 
 


 
 

        从文本来说,一个doc表示什么意思?我们描述一件事情,用什么来表示比较合适?用一个一个字嘛,我看不是,字就是像素级别了,起码应该是term,换句话说每个doc都由term构成,但这样表示概念的能力就够了嘛,可能也不够,需要再上一步,达到topic级,有了topic,再到doc就合理。但每个层次的数量差距很大,比如doc表示的概念->topic(千万量级)->term10万量级)->word(百万量级)。

 
 

        一个人在看一个doc的时候,眼睛看到的是word,由这些word在大脑里自动切词形成term,在按照概念组织的方式,先验的学习,得到topic,然后再进行高层次的learning

 
 

 
 

4.4、需要有多少个特征?

 
 

       我们知道需要层次的特征构建,由浅入深,但每一层该有多少个特征呢?

 
 

任何一种方法,特征越多,给出的参考信息就越多,准确性会得到提升。但特征多意味着计算复杂,探索的空间大,可以用来训练的数据在每个特征上就会稀疏,都会带来各种问题,并不一定特征越多越好。

 
 


 
 

       好了,到了这一步,终于可以聊到Deep learning了。上面我们聊到为什么会有Deep learning(让机器自动学习良好的特征,而免去人工选取过程。还有参考人的分层视觉处理系统),我们得到一个结论就是Deep learning需要多层来获得更抽象的特征表达。那么多少层才合适呢?用什么架构来建模呢?怎么进行非监督训练呢?

 
 

 
 

五、Deep Learning的基本思想
 

       假设我们有一个系统S,它有n层(S1,…Sn),它的输入是I,输出是O,形象地表示为: I =>S1=>S2=>…..=>Sn => O,如果输出O等于输入I,即输入I经过这个系统变化之后没有任何的信息损失(呵呵,大牛说,这是不可能的。信息论中有个”信息逐层丢失”的说法(信息处理不等式),设处理a信息得到b,再对b处理得到c,那么可以证明:ac的互信息不会超过ab的互信息。这表明信息处理不会增加信息,大部分处理会丢失信息。当然了,如果丢掉的是没用的信息那多好啊),保持了不变,这意味着输入I经过每一层Si都没有任何的信息损失,即在任何一层Si,它都是原有信息(即输入I)的另外一种表示。现在回到我们的主题Deep Learning,我们需要自动地学习特征,假设我们有一堆输入I(如一堆图像或者文本),假设我们设计了一个系统S(有n层),我们通过调整系统中参数,使得它的输出仍然是输入I,那么我们就可以自动地获取得到输入I的一系列层次特征,即S1,…, Sn

 
 

       对于深度学习来说,其思想就是对堆叠多个层,也就是说这一层的输出作为下一层的输入。通过这种方式,就可以实现对输入信息进行分级表达了。

 
 

       另外,前面是假设输出严格地等于输入,这个限制太严格,我们可以略微地放松这个限制,例如我们只要使得输入与输出的差别尽可能地小即可,这个放松会导致另外一类不同的Deep Learning方法。上述就是Deep Learning的基本思想。

 
 

 
 

 
 

六、浅层学习(Shallow Learning)和深度学习(Deep Learning

 
 

       浅层学习是机器学习的第一次浪潮。

 
 

       20世纪80年代末期,用于人工神经网络的反向传播算法(也叫Back Propagation算法或者BP算法)的发明,给机器学习带来了希望,掀起了基于统计模型的机器学习热潮。这个热潮一直持续到今天。人们发现,利用BP算法可以让一个人工神经网络模型从大量训练样本中学习统计规律,从而对未知事件做预测。这种基于统计的机器学习方法比起过去基于人工规则的系统,在很多方面显出优越性。这个时候的人工神经网络,虽也被称作多层感知机(Multi-layer Perceptron),但实际是种只含有一层隐层节点的浅层模型。

 
 

        20世纪90年代,各种各样的浅层机器学习模型相继被提出,例如支撑向量机(SVMSupport Vector Machines)、 Boosting、最大熵方法(如LRLogistic Regression)等。这些模型的结构基本上可以看成带有一层隐层节点(如SVMBoosting),或没有隐层节点(如LR)。这些模型无论是在理论分析还是应用中都获得了巨大的成功。相比之下,由于理论分析的难度大,训练方法又需要很多经验和技巧,这个时期浅层人工神经网络反而相对沉寂。

 
 

        深度学习是机器学习的第二次浪潮。

 
 

        2006年,加拿大多伦多大学教授、机器学习领域的泰斗Geoffrey Hinton和他的学生RuslanSalakhutdinov在《科学》上发表了一篇文章,开启了深度学习在学术界和工业界的浪潮。这篇文章有两个主要观点:1)多隐层的人工神经网络具有优异的特征学习能力,学习得到的特征对数据有更本质的刻画,从而有利于可视化或分类;2)深度神经网络在训练上的难度,可以通过”逐层初始化”(layer-wise pre-training)来有效克服,在这篇文章中,逐层初始化是通过无监督学习实现的。

 
 

        当前多数分类、回归等学习方法为浅层结构算法,其局限性在于有限样本和计算单元情况下对复杂函数的表示能力有限,针对复杂分类问题其泛化能力受到一定制约。深度学习可通过学习一种深层非线性网络结构,实现复杂函数逼近,表征输入数据分布式表示,并展现了强大的从少数样本集中学习数据集本质特征的能力。(多层的好处是可以用较少的参数表示复杂的函数)

 
 


 
 

 
 

 
 

七、Deep learningNeural Network

 
 

        深度学习是机器学习研究中的一个新的领域,其动机在于建立、模拟人脑进行分析学习的神经网络,它模仿人脑的机制来解释数据,例如图像,声音和文本。深度学习是无监督学习的一种。

 
 

        深度学习的概念源于人工神经网络的研究。含多隐层的多层感知器就是一种深度学习结构。深度学习通过组合低层特征形成更加抽象的高层表示属性类别或特征,以发现数据的分布式特征表示。

 
 

       Deep learning本身算是machine learning的一个分支,简单可以理解为neural network的发展。大约二三十年前,neural network曾经是ML领域特别火热的一个方向,但是后来确慢慢淡出了,原因包括以下几个方面:

 
 

1)比较容易过拟合,参数比较难tune,而且需要不少trick

 
 

2)训练速度比较慢,在层次比较少(小于等于3)的情况下效果并不比其它方法更优;

 
 

       所以中间有大约20多年的时间,神经网络被关注很少,这段时间基本上是SVMboosting算法的天下。但是,一个痴心的老先生Hinton,他坚持了下来,并最终(和其它人一起BengioYann.lecun等)提成了一个实际可行的deep learning框架。

 
 

        Deep learning与传统的神经网络之间有相同的地方也有很多不同。

 
 

        二者的相同在于deep learning采用了神经网络相似的分层结构,系统由包括输入层、隐层(多层)、输出层组成的多层网络,只有相邻层节点之间有连接,同一层以及跨层节点之间相互无连接,每一层可以看作是一个logistic regression模型;这种分层结构,是比较接近人类大脑的结构的。

 
 


 
 

        而为了克服神经网络训练中的问题,DL采用了与神经网络很不同的训练机制。传统神经网络中,采用的是back propagation的方式进行,简单来讲就是采用迭代的算法来训练整个网络,随机设定初值,计算当前网络的输出,然后根据当前输出和label之间的差去改变前面各层的参数,直到收敛(整体是一个梯度下降法)。而deep learning整体上是一个layer-wise的训练机制。这样做的原因是因为,如果采用back propagation的机制,对于一个deep network7层以上),残差传播到最前面的层已经变得太小,出现所谓的gradient diffusion(梯度扩散)。这个问题我们接下来讨论。

 
 

 
 

八、Deep learning训练过程

 
 

8.1、传统神经网络的训练方法为什么不能用在深度神经网络

 
 

       BP算法作为传统训练多层网络的典型算法,实际上对仅含几层网络,该训练方法就已经很不理想。深度结构(涉及多个非线性处理单元层)非凸目标代价函数中普遍存在的局部最小是训练困难的主要来源。

 
 

BP算法存在的问题:

 
 

1)梯度越来越稀疏:从顶层越往下,误差校正信号越来越小;

 
 

2)收敛到局部最小值:尤其是从远离最优区域开始的时候(随机值初始化会导致这种情况的发生);

 
 

3)一般,我们只能用有标签的数据来训练:但大部分的数据是没标签的,而大脑可以从没有标签的的数据中学习;

 
 

 
 

8.2deep learning训练过程

 
 

       如果对所有层同时训练,时间复杂度会太高;如果每次训练一层,偏差就会逐层传递。这会面临跟上面监督学习中相反的问题,会严重欠拟合(因为深度网络的神经元和参数太多了)。

 
 

       2006年,hinton提出了在非监督数据上建立多层神经网络的一个有效方法,简单的说,分为两步,一是每次训练一层网络,二是调优,使原始表示x向上生成的高级表示r和该高级表示r向下生成的x’尽可能一致。方法是:

 
 

1)首先逐层构建单层神经元,这样每次都是训练一个单层网络。

 
 

2)当所有层训练完后,Hinton使用wake-sleep算法进行调优。

 
 

       将除最顶层的其它层间的权重变为双向的,这样最顶层仍然是一个单层神经网络,而其它层则变为了图模型。向上的权重用于”认知”,向下的权重用于”生成”。然后使用Wake-Sleep算法调整所有的权重。让认知和生成达成一致,也就是保证生成的最顶层表示能够尽可能正确的复原底层的结点。比如顶层的一个结点表示人脸,那么所有人脸的图像应该激活这个结点,并且这个结果向下生成的图像应该能够表现为一个大概的人脸图像。Wake-Sleep算法分为醒(wake)和睡(sleep)两个部分。

 
 

1wake阶段:认知过程,通过外界的特征和向上的权重(认知权重)产生每一层的抽象表示(结点状态),并且使用梯度下降修改层间的下行权重(生成权重)。也就是”如果现实跟我想象的不一样,改变我的权重使得我想象的东西就是这样的”。

 
 

2sleep阶段:生成过程,通过顶层表示(醒时学得的概念)和向下权重,生成底层的状态,同时修改层间向上的权重。也就是”如果梦中的景象不是我脑中的相应概念,改变我的认知权重使得这种景象在我看来就是这个概念”。

 
 

deep learning训练过程具体如下:

 
 

1)使用自下上升非监督学习(就是从底层开始,一层一层的往顶层训练):

 
 

       采用无标定数据(有标定数据也可)分层训练各层参数,这一步可以看作是一个无监督训练过程,是和传统神经网络区别最大的部分(这个过程可以看作是feature learning过程):

 
 

       具体的,先用无标定数据训练第一层,训练时先学习第一层的参数(这一层可以看作是得到一个使得输出和输入差别最小的三层神经网络的隐层),由于模型capacity的限制以及稀疏性约束,使得得到的模型能够学习到数据本身的结构,从而得到比输入更具有表示能力的特征;在学习得到第n-1层后,将n-1层的输出作为第n层的输入,训练第n层,由此分别得到各层的参数;

 
 

2)自顶向下的监督学习(就是通过带标签的数据去训练,误差自顶向下传输,对网络进行微调):

 
 

       基于第一步得到的各层参数进一步fine-tune整个多层模型的参数,这一步是一个有监督训练过程;第一步类似神经网络的随机初始化初值过程,由于DL的第一步不是随机初始化,而是通过学习输入数据的结构得到的,因而这个初值更接近全局最优,从而能够取得更好的效果;所以deep learning效果好很大程度上归功于第一步的feature learning过程。

 
 

 
 

九、Deep Learning的常用模型或者方法

 
 

9.1AutoEncoder自动编码器

 
 

        Deep Learning最简单的一种方法是利用人工神经网络的特点,人工神经网络(ANN)本身就是具有层次结构的系统,如果给定一个神经网络,我们假设其输出与输入是相同的,然后训练调整其参数,得到每一层中的权重。自然地,我们就得到了输入I的几种不同表示(每一层代表一种表示),这些表示就是特征。自动编码器就是一种尽可能复现输入信号的神经网络。为了实现这种复现,自动编码器就必须捕捉可以代表输入数据的最重要的因素,就像PCA那样,找到可以代表原信息的主要成分。

 
 

       具体过程简单的说明如下:

 
 

1)给定无标签数据,用非监督学习学习特征:

 
 



       在我们之前的神经网络中,如第一个图,我们输入的样本是有标签的,即(input, target),这样我们根据当前输出和targetlabel)之间的差去改变前面各层的参数,直到收敛。但现在我们只有无标签数据,也就是右边的图。那么这个误差怎么得到呢?

 
 


 
 

        如上图,我们将input输入一个encoder编码器,就会得到一个code,这个code也就是输入的一个表示,那么我们怎么知道这个code表示的就是input呢?我们加一个decoder解码器,这时候decoder就会输出一个信息,那么如果输出的这个信息和一开始的输入信号input是很像的(理想情况下就是一样的),那很明显,我们就有理由相信这个code是靠谱的。所以,我们就通过调整encoderdecoder的参数,使得重构误差最小,这时候我们就得到了输入input信号的第一个表示了,也就是编码code了。因为是无标签数据,所以误差的来源就是直接重构后与原输入相比得到。

 
 


 
 

2)通过编码器产生特征,然后训练下一层。这样逐层训练:

 
 

       那上面我们就得到第一层的code,我们的重构误差最小让我们相信这个code就是原输入信号的良好表达了,或者牵强点说,它和原信号是一模一样的(表达不一样,反映的是一个东西)。那第二层和第一层的训练方式就没有差别了,我们将第一层输出的code当成第二层的输入信号,同样最小化重构误差,就会得到第二层的参数,并且得到第二层输入的code,也就是原输入信息的第二个表达了。其他层就同样的方法炮制就行了(训练这一层,前面层的参数都是固定的,并且他们的decoder已经没用了,都不需要了)。

 
 


 
 

3)有监督微调:

 
 

      经过上面的方法,我们就可以得到很多层了。至于需要多少层(或者深度需要多少,这个目前本身就没有一个科学的评价方法)需要自己试验调了。每一层都会得到原始输入的不同的表达。当然了,我们觉得它是越抽象越好了,就像人的视觉系统一样。

 
 

       到这里,这个AutoEncoder还不能用来分类数据,因为它还没有学习如何去连结一个输入和一个类。它只是学会了如何去重构或者复现它的输入而已。或者说,它只是学习获得了一个可以良好代表输入的特征,这个特征可以最大程度上代表原输入信号。那么,为了实现分类,我们就可以在AutoEncoder的最顶的编码层添加一个分类器(例如罗杰斯特回归、SVM等),然后通过标准的多层神经网络的监督训练方法(梯度下降法)去训练。

 
 

        也就是说,这时候,我们需要将最后层的特征code输入到最后的分类器,通过有标签样本,通过监督学习进行微调,这也分两种,一个是只调整分类器(黑色部分):

 
 


 
 

       另一种:通过有标签样本,微调整个系统:(如果有足够多的数据,这个是最好的。end-to-end learning端对端学习)

 
 


 
 

       一旦监督训练完成,这个网络就可以用来分类了。神经网络的最顶层可以作为一个线性分类器,然后我们可以用一个更好性能的分类器去取代它。

 
 

       在研究中可以发现,如果在原有的特征中加入这些自动学习得到的特征可以大大提高精确度,甚至在分类问题中比目前最好的分类算法效果还要好!

 
 

        AutoEncoder存在一些变体,这里简要介绍下两个:

 
 

Sparse AutoEncoder稀疏自动编码器:

 
 

      当然,我们还可以继续加上一些约束条件得到新的Deep Learning方法,如:如果在AutoEncoder的基础上加上L1Regularity限制(L1主要是约束每一层中的节点中大部分都要为0,只有少数不为0,这就是Sparse名字的来源),我们就可以得到Sparse AutoEncoder法。

 
 


 
 

       如上图,其实就是限制每次得到的表达code尽量稀疏。因为稀疏的表达往往比其他的表达要有效(人脑好像也是这样的,某个输入只是刺激某些神经元,其他的大部分的神经元是受到抑制的)。

 
 

Denoising AutoEncoders降噪自动编码器:

 
 

        降噪自动编码器DA是在自动编码器的基础上,训练数据加入噪声,所以自动编码器必须学习去去除这种噪声而获得真正的没有被噪声污染过的输入。因此,这就迫使编码器去学习输入信号的更加鲁棒的表达,这也是它的泛化能力比一般编码器强的原因。DA可以通过梯度下降算法去训练。

 
 


 
 

 
 

9.2Sparse Coding稀疏编码

 
 

       如果我们把输出必须和输入相等的限制放松,同时利用线性代数中基的概念,即O = a11 + a22+….+ ann Φi是基,ai是系数,我们可以得到这样一个优化问题:

 
 

Min |I – O|,其中I表示输入,O表示输出。

 
 

       通过求解这个最优化式子,我们可以求得系数ai和基Φi,这些系数和基就是输入的另外一种近似表达。

 
 


 
 

       因此,它们可以用来表达输入I,这个过程也是自动学习得到的。如果我们在上述式子上加上L1Regularity限制,得到:

 
 

Min |I – O| + u*(|a1| + |a2| + … + |an |)

 
 

        这种方法被称为Sparse Coding。通俗的说,就是将一个信号表示为一组基的线性组合,而且要求只需要较少的几个基就可以将信号表示出来。”稀疏性”定义为:只有很少的几个非零元素或只有很少的几个远大于零的元素。要求系数 ai 是稀疏的意思就是说:对于一组输入向量,我们只想有尽可能少的几个系数远大于零。选择使用具有稀疏性的分量来表示我们的输入数据是有原因的,因为绝大多数的感官数据,比如自然图像,可以被表示成少量基本元素的叠加,在图像中这些基本元素可以是面或者线。同时,比如与初级视觉皮层的类比过程也因此得到了提升(人脑有大量的神经元,但对于某些图像或者边缘只有很少的神经元兴奋,其他都处于抑制状态)。

 
 

         稀疏编码算法是一种无监督学习方法,它用来寻找一组”超完备”基向量来更高效地表示样本数据。虽然形如主成分分析技术(PCA)能使我们方便地找到一组”完备”基向量,但是这里我们想要做的是找到一组”超完备”基向量来表示输入向量(也就是说,基向量的个数比输入向量的维数要大)。超完备基的好处是它们能更有效地找出隐含在输入数据内部的结构与模式。然而,对于超完备基来说,系数ai不再由输入向量唯一确定。因此,在稀疏编码算法中,我们另加了一个评判标准”稀疏性”来解决因超完备而导致的退化(degeneracy)问题。(详细过程请参考:UFLDL Tutorial稀疏编码

 
 


 
 

       比如在图像的Feature Extraction的最底层要做Edge Detector的生成,那么这里的工作就是从Natural Imagesrandomly选取一些小patch,通过这些patch生成能够描述他们的”基”,也就是右边的8*8=64basis组成的basis,然后给定一个test patch, 我们可以按照上面的式子通过basis的线性组合得到,而sparse matrix就是a,下图中的a中有64个维度,其中非零项只有3个,故称”sparse”

 
 

       这里可能大家会有疑问,为什么把底层作为Edge Detector呢?上层又是什么呢?这里做个简单解释大家就会明白,之所以是Edge Detector是因为不同方向的Edge就能够描述出整幅图像,所以不同方向的Edge自然就是图像的basis了……而上一层的basis组合的结果,上上层又是上一层的组合basis……(就是上面第四部分的时候咱们说的那样)

 
 

       Sparse coding分为两个部分:

 
 

1Training阶段:给定一系列的样本图片[x1, x 2, …],我们需要学习得到一组基[Φ1, Φ2, …],也就是字典。

 
 

       稀疏编码是k-means算法的变体,其训练过程也差不多(EM算法的思想:如果要优化的目标函数包含两个变量,如L(W, B),那么我们可以先固定W,调整B使得L最小,然后再固定B,调整W使L最小,这样迭代交替,不断将L推向最小值。EM算法可以见我的博客:”从最大似然到EM算法浅解)。

 
 

       训练过程就是一个重复迭代的过程,按上面所说,我们交替的更改aΦ使得下面这个目标函数最小。

 
 


 
 

      每次迭代分两步:

 
 

a)固定字典Φ[k],然后调整a[k],使得上式,即目标函数最小(即解LASSO问题)。

 
 

b)然后固定住a [k],调整Φ [k],使得上式,即目标函数最小(即解凸QP问题)。

 
 

      不断迭代,直至收敛。这样就可以得到一组可以良好表示这一系列x的基,也就是字典。

 
 

2Coding阶段:给定一个新的图片x,由上面得到的字典,通过解一个LASSO问题得到稀疏向量a。这个稀疏向量就是这个输入向量x的一个稀疏表达了。

 
 


 
 

例如

 
 


 
 


9.3Restricted Boltzmann Machine (RBM)限制波尔兹曼机

 
 

       假设有一个二部图,每一层的节点之间没有链接,一层是可视层,即输入数据层(v),一层是隐藏层(h),如果假设所有的节点都是随机二值变量节点(只能取0或者1值),同时假设全概率分布p(v,h)满足Boltzmann 分布,我们称这个模型是Restricted BoltzmannMachine (RBM)

 
 


 
 

       下面我们来看看为什么它是Deep Learning方法。首先,这个模型因为是二部图,所以在已知v的情况下,所有的隐藏节点之间是条件独立的(因为节点之间不存在连接),即p(h|v)=p(h1|v)…p(hn|v)。同理,在已知隐藏层h的情况下,所有的可视节点都是条件独立的。同时又由于所有的vh满足Boltzmann 分布,因此,当输入v的时候,通过p(h|v) 可以得到隐藏层h,而得到隐藏层h之后,通过p(v|h)又能得到可视层,通过调整参数,我们就是要使得从隐藏层得到的可视层v1与原来的可视层v如果一样,那么得到的隐藏层就是可视层另外一种表达,因此隐藏层可以作为可视层输入数据的特征,所以它就是一种Deep Learning方法。

 
 


 
 

       如何训练呢?也就是可视层节点和隐节点间的权值怎么确定呢?我们需要做一些数学分析。也就是模型了。

 
 


 
 

        联合组态(jointconfiguration)的能量可以表示为:

 
 


 
 

        而某个组态的联合概率分布可以通过Boltzmann 分布(和这个组态的能量)来确定:

 
 


 
 

      因为隐藏节点之间是条件独立的(因为节点之间不存在连接),即:

 
 


 
 

      然后我们可以比较容易(对上式进行因子分解Factorizes)得到在给定可视层v的基础上,隐层第j个节点为1或者为0的概率:

 
 


 
 

       同理,在给定隐层h的基础上,可视层第i个节点为1或者为0的概率也可以容易得到:

 
 


 
 

       给定一个满足独立同分布的样本集:D={v(1), v(2),…, v(N)},我们需要学习参数θ={W,a,b}

 
 

       我们最大化以下对数似然函数(最大似然估计:对于某个概率模型,我们需要选择一个参数,让我们当前的观测样本的概率最大):

 
 


 
 

        也就是对最大对数似然函数求导,就可以得到L最大时对应的参数W了。

 
 


 
 

       如果,我们把隐藏层的层数增加,我们可以得到Deep Boltzmann Machine(DBM);如果我们在靠近可视层的部分使用贝叶斯信念网络(即有向图模型,当然这里依然限制层中节点之间没有链接),而在最远离可视层的部分使用Restricted Boltzmann Machine,我们可以得到DeepBelief NetDBN)。

 
 


 
 

9.4Deep Belief Networks深信度网络

 
 

        DBNs是一个概率生成模型,与传统的判别模型的神经网络相对,生成模型是建立一个观察数据和标签之间的联合分布,对P(Observation|Label) P(Label|Observation)都做了评估,而判别模型仅仅而已评估了后者,也就是P(Label|Observation)。对于在深度神经网络应用传统的BP算法的时候,DBNs遇到了以下问题:

 
 

1)需要为训练提供一个有标签的样本集;

2)学习过程较慢;

3)不适当的参数选择会导致学习收敛于局部最优解。

 
 


 
 

       DBNs由多个限制玻尔兹曼机(Restricted Boltzmann Machines)层组成,一个典型的神经网络类型如图三所示。这些网络被”限制”为一个可视层和一个隐层,层间存在连接,但层内的单元间不存在连接。隐层单元被训练去捕捉在可视层表现出来的高阶数据的相关性。

 
 

       首先,先不考虑最顶构成一个联想记忆(associative memory)的两层,一个DBN的连接是通过自顶向下的生成权值来指导确定的,RBMs就像一个建筑块一样,相比传统和深度分层的sigmoid信念网络,它能易于连接权值的学习。

 
 

       最开始的时候,通过一个非监督贪婪逐层方法去预训练获得生成模型的权值,非监督贪婪逐层方法被Hinton证明是有效的,并被其称为对比分歧(contrastive divergence)。

 
 

       在这个训练阶段,在可视层会产生一个向量v,通过它将值传递到隐层。反过来,可视层的输入会被随机的选择,以尝试去重构原始的输入信号。最后,这些新的可视的神经元激活单元将前向传递重构隐层激活单元,获得h(在训练过程中,首先将可视向量值映射给隐单元;然后可视单元由隐层单元重建;这些新可视单元再次映射给隐单元,这样就获取新的隐单元。执行这种反复步骤叫做吉布斯采样)。这些后退和前进的步骤就是我们熟悉的Gibbs采样,而隐层激活单元和可视层输入之间的相关性差别就作为权值更新的主要依据。

 
 

       训练时间会显著的减少,因为只需要单个步骤就可以接近最大似然学习。增加进网络的每一层都会改进训练数据的对数概率,我们可以理解为越来越接近能量的真实表达。这个有意义的拓展,和无标签数据的使用,是任何一个深度学习应用的决定性的因素。

 
 


 
 

       在最高两层,权值被连接到一起,这样更低层的输出将会提供一个参考的线索或者关联给顶层,这样顶层就会将其联系到它的记忆内容。而我们最关心的,最后想得到的就是判别性能,例如分类任务里面。

 
 

       在预训练后,DBN可以通过利用带标签数据用BP算法去对判别性能做调整。在这里,一个标签集将被附加到顶层(推广联想记忆),通过一个自下向上的,学习到的识别权值获得一个网络的分类面。这个性能会比单纯的BP算法训练的网络好。这可以很直观的解释,DBNsBP算法只需要对权值参数空间进行一个局部的搜索,这相比前向神经网络来说,训练是要快的,而且收敛的时间也少。

 
 

       DBNs的灵活性使得它的拓展比较容易。一个拓展就是卷积DBNsConvolutional Deep Belief Networks(CDBNs))。DBNs并没有考虑到图像的2维结构信息,因为输入是简单的从一个图像矩阵一维向量化的。而CDBNs就是考虑到了这个问题,它利用邻域像素的空域关系,通过一个称为卷积RBMs的模型区达到生成模型的变换不变性,而且可以容易得变换到高维图像。DBNs并没有明确地处理对观察变量的时间联系的学习上,虽然目前已经有这方面的研究,例如堆叠时间RBMs,以此为推广,有序列学习的dubbed temporal convolutionmachines,这种序列学习的应用,给语音信号处理问题带来了一个让人激动的未来研究方向。

 
 

       目前,和DBNs有关的研究包括堆叠自动编码器,它是通过用堆叠自动编码器来替换传统DBNs里面的RBMs。这就使得可以通过同样的规则来训练产生深度多层神经网络架构,但它缺少层的参数化的严格要求。与DBNs不同,自动编码器使用判别模型,这样这个结构就很难采样输入采样空间,这就使得网络更难捕捉它的内部表达。但是,降噪自动编码器却能很好的避免这个问题,并且比传统的DBNs更优。它通过在训练过程添加随机的污染并堆叠产生场泛化性能。训练单一的降噪自动编码器的过程和RBMs训练生成模型的过程一样。

 
 

 
 

9.5Convolutional Neural Networks卷积神经网络

 
 

       卷积神经网络是人工神经网络的一种,已成为当前语音分析和图像识别领域的研究热点。它的权值共享网络结构使之更类似于生物神经网络,降低了网络模型的复杂度,减少了权值的数量。该优点在网络的输入是多维图像时表现的更为明显,使图像可以直接作为网络的输入,避免了传统识别算法中复杂的特征提取和数据重建过程。卷积网络是为识别二维形状而特殊设计的一个多层感知器,这种网络结构对平移、比例缩放、倾斜或者共他形式的变形具有高度不变性。

 
 

       CNNs是受早期的延时神经网络(TDNN)的影响。延时神经网络通过在时间维度上共享权值降低学习复杂度,适用于语音和时间序列信号的处理。

 
 

       CNNs是第一个真正成功训练多层网络结构的学习算法。它利用空间关系减少需要学习的参数数目以提高一般前向BP算法的训练性能。CNNs作为一个深度学习架构提出是为了最小化数据的预处理要求。在CNN中,图像的一小部分(局部感受区域)作为层级结构的最低层的输入,信息再依次传输到不同的层,每层通过一个数字滤波器去获得观测数据的最显著的特征。这个方法能够获取对平移、缩放和旋转不变的观测数据的显著特征,因为图像的局部感受区域允许神经元或者处理单元可以访问到最基础的特征,例如定向边缘或者角点。

 
 

1)卷积神经网络的历史

 
 

       1962HubelWiesel通过对猫视觉皮层细胞的研究,提出了感受野(receptive field)的概念,1984年日本学者Fukushima基于感受野概念提出的神经认知机(neocognitron)可以看作是卷积神经网络的第一个实现网络,也是感受野概念在人工神经网络领域的首次应用。神经认知机将一个视觉模式分解成许多子模式(特征),然后进入分层递阶式相连的特征平面进行处理,它试图将视觉系统模型化,使其能够在即使物体有位移或轻微变形的时候,也能完成识别。

 
 

       通常神经认知机包含两类神经元,即承担特征抽取的S-元和抗变形的C-元。S-元中涉及两个重要参数,即感受野与阈值参数,前者确定输入连接的数目,后者则控制对特征子模式的反应程度。许多学者一直致力于提高神经认知机的性能的研究:在传统的神经认知机中,每个S-元的感光区中由C-元带来的视觉模糊量呈正态分布。如果感光区的边缘所产生的模糊效果要比中央来得大,S-元将会接受这种非正态模糊所导致的更大的变形容忍性。我们希望得到的是,训练模式与变形刺激模式在感受野的边缘与其中心所产生的效果之间的差异变得越来越大。为了有效地形成这种非正态模糊,Fukushima提出了带双C-元层的改进型神经认知机。

 
 

       Van OoyenNiehuis为提高神经认知机的区别能力引入了一个新的参数。事实上,该参数作为一种抑制信号,抑制了神经元对重复激励特征的激励。多数神经网络在权值中记忆训练信息。根据Hebb学习规则,某种特征训练的次数越多,在以后的识别过程中就越容易被检测。也有学者将进化计算理论与神经认知机结合,通过减弱对重复性激励特征的训练学习,而使得网络注意那些不同的特征以助于提高区分能力。上述都是神经认知机的发展过程,而卷积神经网络可看作是神经认知机的推广形式,神经认知机是卷积神经网络的一种特例。
 

2)卷积神经网络的网络结构

 
 

      卷积神经网络是一个多层的神经网络,每层由多个二维平面组成,而每个平面由多个独立神经元组成。

 
 


 
 

       图:卷积神经网络的概念示范:输入图像通过和三个可训练的滤波器和可加偏置进行卷积,滤波过程如图一,卷积后在C1层产生三个特征映射图,然后特征映射图中每组的四个像素再进行求和,加权值,加偏置,通过一个Sigmoid函数得到三个S2层的特征映射图。这些映射图再进过滤波得到C3层。这个层级结构再和S2一样产生S4。最终,这些像素值被光栅化,并连接成一个向量输入到传统的神经网络,得到输出。

 
 

       一般地,C层为特征提取层,每个神经元的输入与前一层的局部感受野相连,并提取该局部的特征,一旦该局部特征被提取后,它与其他特征间的位置关系也随之确定下来;S层是特征映射层,网络的每个计算层由多个特征映射组成,每个特征映射为一个平面,平面上所有神经元的权值相等。特征映射结构采用影响函数核小的sigmoid函数作为卷积网络的激活函数,使得特征映射具有位移不变性。

 
 

       此外,由于一个映射面上的神经元共享权值,因而减少了网络自由参数的个数,降低了网络参数选择的复杂度。卷积神经网络中的每一个特征提取层(C-层)都紧跟着一个用来求局部平均与二次提取的计算层(S-层),这种特有的两次特征提取结构使网络在识别时对输入样本有较高的畸变容忍能力。

 
 

3)关于参数减少与权值共享

 
 

      上面聊到,好像CNN一个牛逼的地方就在于通过感受野和权值共享减少了神经网络需要训练的参数的个数。那究竟是啥的呢?

 
 

下图左:如果我们有1000×1000像素的图像,有1百万个隐层神经元,那么他们全连接的话(每个隐层神经元都连接图像的每一个像素点),就有1000x1000x1000000=10^12个连接,也就是10^12个权值参数。然而图像的空间联系是局部的,就像人是通过一个局部的感受野去感受外界图像一样,每一个神经元都不需要对全局图像做感受,每个神经元只感受局部的图像区域,然后在更高层,将这些感受不同局部的神经元综合起来就可以得到全局的信息了。这样,我们就可以减少连接的数目,也就是减少神经网络需要训练的权值参数的个数了。如下图右:假如局部感受野是10×10,隐层每个感受野只需要和这10×10的局部图像相连接,所以1百万个隐层神经元就只有一亿个连接,即10^8个参数。比原来减少了四个0(数量级),这样训练起来就没那么费力了,但还是感觉很多的啊,那还有啥办法没?

 
 


 
 

       我们知道,隐含层的每一个神经元都连接10×10个图像区域,也就是说每一个神经元存在10×10=100个连接权值参数。那如果我们每个神经元这100个参数是相同的呢?也就是说每个神经元用的是同一个卷积核去卷积图像。这样我们就只有多少个参数??只有100个参数啊!!!亲!不管你隐层的神经元个数有多少,两层间的连接我只有100个参数啊!亲!这就是权值共享啊!亲!这就是卷积神经网络的主打卖点啊!亲!(有点烦了,呵呵)也许你会问,这样做靠谱吗?为什么可行呢?这个……共同学习。

 
 

       好了,你就会想,这样提取特征也忒不靠谱吧,这样你只提取了一种特征啊?对了,真聪明,我们需要提取多种特征对不?假如一种滤波器,也就是一种卷积核就是提出图像的一种特征,例如某个方向的边缘。那么我们需要提取不同的特征,怎么办,加多几种滤波器不就行了吗?对了。所以假设我们加到100种滤波器,每种滤波器的参数不一样,表示它提出输入图像的不同特征,例如不同的边缘。这样每种滤波器去卷积图像就得到对图像的不同特征的放映,我们称之为Feature Map。所以100种卷积核就有100Feature Map。这100Feature Map就组成了一层神经元。到这个时候明了了吧。我们这一层有多少个参数了?100种卷积核x每种卷积核共享100个参数=100×100=10K,也就是1万个参数。才1万个参数啊!亲!(又来了,受不了了!)见下图右:不同的颜色表达不同的滤波器。

 
 


 
 

       嘿哟,遗漏一个问题了。刚才说隐层的参数个数和隐层的神经元个数无关,只和滤波器的大小和滤波器种类的多少有关。那么隐层的神经元个数怎么确定呢?它和原图像,也就是输入的大小(神经元个数)、滤波器的大小和滤波器在图像中的滑动步长都有关!例如,我的图像是1000×1000像素,而滤波器大小是10×10,假设滤波器没有重叠,也就是步长为10,这样隐层的神经元个数就是(1000×1000 )/ (10×10)=100×100个神经元了,假设步长是8,也就是卷积核会重叠两个像素,那么……我就不算了,思想懂了就好。注意了,这只是一种滤波器,也就是一个Feature Map的神经元个数哦,如果100Feature Map就是100倍了。由此可见,图像越大,神经元个数和需要训练的权值参数个数的贫富差距就越大。

 
 


 
 

      需要注意的一点是,上面的讨论都没有考虑每个神经元的偏置部分。所以权值个数需要加1 。这个也是同一种滤波器共享的。

 
 

      总之,卷积网络的核心思想是将:局部感受野、权值共享(或者权值复制)以及时间或空间亚采样这三种结构思想结合起来获得了某种程度的位移、尺度、形变不变性。

 
 

4)一个典型的例子说明

 
 

       一种典型的用来识别数字的卷积网络是LeNet-5效果和paper等见这)。当年美国大多数银行就是用它来识别支票上面的手写数字的。能够达到这种商用的地步,它的准确性可想而知。毕竟目前学术界和工业界的结合是最受争议的。

 
 


 
 

      那下面咱们也用这个例子来说明下。

 
 


 
 

        LeNet-5共有7层,不包含输入,每层都包含可训练参数(连接权重)。输入图像为32*32大小。这要比Mnist数据库(一个公认的手写数据库)中最大的字母还大。这样做的原因是希望潜在的明显特征如笔画断电或角点能够出现在最高层特征监测子感受野的中心。

 
 

        我们先要明确一点:每个层有多个Feature Map,每个Feature Map通过一种卷积滤波器提取输入的一种特征,然后每个Feature Map有多个神经元。

 
 

        C1层是一个卷积层(为什么是卷积?卷积运算一个重要的特点就是,通过卷积运算,可以使原信号特征增强,并且降低噪音),由6个特征图Feature Map构成。特征图中每个神经元与输入中5*5的邻域相连。特征图的大小为28*28,这样能防止输入的连接掉到边界之外(是为了BP反馈时的计算,不致梯度损失,个人见解)。C1156个可训练参数(每个滤波器5*5=25unit参数和一个bias参数,一共6个滤波器,共(5*5+1)*6=156个参数),共156*(28*28)=122,304个连接。

 
 

       S2层是一个下采样层(为什么是下采样?利用图像局部相关性的原理,对图像进行子抽样,可以减少数据处理量同时保留有用信息),有614*14的特征图。特征图中的每个单元与C1中相对应特征图的2*2邻域相连接。S2层每个单元的4个输入相加,乘以一个可训练参数,再加上一个可训练偏置。结果通过sigmoid函数计算。可训练系数和偏置控制着sigmoid函数的非线性程度。如果系数比较小,那么运算近似于线性运算,亚采样相当于模糊图像。如果系数比较大,根据偏置的大小亚采样可以被看成是有噪声的”或”运算或者有噪声的”与”运算。每个单元的2*2感受野并不重叠,因此S2中每个特征图的大小是C1中特征图大小的1/4(行和列各1/2)。S2层有12个可训练参数和5880个连接。

 
 


 
 

图:卷积和子采样过程:卷积过程包括:用一个可训练的滤波器fx去卷积一个输入的图像(第一阶段是输入的图像,后面的阶段就是卷积特征map了),然后加一个偏置bx,得到卷积层Cx。子采样过程包括:每邻域四个像素求和变为一个像素,然后通过标量Wx+1加权,再增加偏置bx+1,然后通过一个sigmoid激活函数,产生一个大概缩小四倍的特征映射图Sx+1

 
 

       所以从一个平面到下一个平面的映射可以看作是作卷积运算,S-层可看作是模糊滤波器,起到二次特征提取的作用。隐层与隐层之间空间分辨率递减,而每层所含的平面数递增,这样可用于检测更多的特征信息。

 
 

       C3层也是一个卷积层,它同样通过5×5的卷积核去卷积层S2,然后得到的特征map就只有10×10个神经元,但是它有16种不同的卷积核,所以就存在16个特征map了。这里需要注意的一点是:C3中的每个特征map是连接到S2中的所有6个或者几个特征map的,表示本层的特征map是上一层提取到的特征map的不同组合(这个做法也并不是唯一的)。(看到没有,这里是组合,就像之前聊到的人的视觉系统一样,底层的结构构成上层更抽象的结构,例如边缘构成形状或者目标的部分)。

 
 

       刚才说C3中每个特征图由S2中所有6个或者几个特征map组合而成。为什么不把S2中的每个特征图连接到每个C3的特征图呢?原因有2点。第一,不完全的连接机制将连接的数量保持在合理的范围内。第二,也是最重要的,其破坏了网络的对称性。由于不同的特征图有不同的输入,所以迫使他们抽取不同的特征(希望是互补的)。

 
 

      例如,存在的一个方式是:C3的前6个特征图以S23个相邻的特征图子集为输入。接下来6个特征图以S24个相邻特征图子集为输入。然后的3个以不相邻的4个特征图子集为输入。最后一个将S2中所有特征图为输入。这样C3层有1516个可训练参数和151600个连接。

 
 

       S4层是一个下采样层,由165*5大小的特征图构成。特征图中的每个单元与C3中相应特征图的2*2邻域相连接,跟C1S2之间的连接一样。S4层有32个可训练参数(每个特征图1个因子和一个偏置)和2000个连接。

 
 

       C5层是一个卷积层,有120个特征图。每个单元与S4层的全部16个单元的5*5邻域相连。由于S4层特征图的大小也为5*5(同滤波器一样),故C5特征图的大小为1*1:这构成了S4C5之间的全连接。之所以仍将C5标示为卷积层而非全相联层,是因为如果LeNet-5的输入变大,而其他的保持不变,那么此时特征图的维数就会比1*1大。C5层有48120个可训练连接。

 
 

        F6层有84个单元(之所以选这个数字的原因来自于输出层的设计),与C5层全相连。有10164个可训练参数。如同经典神经网络,F6层计算输入向量和权重向量之间的点积,再加上一个偏置。然后将其传递给sigmoid函数产生单元i的一个状态。

 
 

      最后,输出层由欧式径向基函数(Euclidean Radial Basis Function)单元组成,每类一个单元,每个有84个输入。换句话说,每个输出RBF单元计算输入向量和参数向量之间的欧式距离。输入离参数向量越远,RBF输出的越大。一个RBF输出可以被理解为衡量输入模式和与RBF相关联类的一个模型的匹配程度的惩罚项。用概率术语来说,RBF输出可以被理解为F6层配置空间的高斯分布的负log-likelihood。给定一个输入模式,损失函数应能使得F6的配置与RBF参数向量(即模式的期望分类)足够接近。这些单元的参数是人工选取并保持固定的(至少初始时候如此)。这些参数向量的成分被设为-11。虽然这些参数可以以-11等概率的方式任选,或者构成一个纠错码,但是被设计成一个相应字符类的7*12大小(即84)的格式化图片。这种表示对识别单独的数字不是很有用,但是对识别可打印ASCII集中的字符串很有用。

 
 

      使用这种分布编码而非更常用的”1 of N”编码用于产生输出的另一个原因是,当类别比较大的时候,非分布编码的效果比较差。原因是大多数时间非分布编码的输出必须为0。这使得用sigmoid单元很难实现。另一个原因是分类器不仅用于识别字母,也用于拒绝非字母。使用分布编码的RBF更适合该目标。因为与sigmoid不同,他们在输入空间的较好限制的区域内兴奋,而非典型模式更容易落到外边。

 
 

        RBF参数向量起着F6层目标向量的角色。需要指出这些向量的成分是+1-1,这正好在F6 sigmoid的范围内,因此可以防止sigmoid函数饱和。实际上,+1-1sigmoid函数的最大弯曲的点处。这使得F6单元运行在最大非线性范围内。必须避免sigmoid函数的饱和,因为这将会导致损失函数较慢的收敛和病态问题。

 
 

5)训练过程

 
 

        神经网络用于模式识别的主流是有指导学习网络,无指导学习网络更多的是用于聚类分析。对于有指导的模式识别,由于任一样本的类别是已知的,样本在空间的分布不再是依据其自然分布倾向来划分,而是要根据同类样本在空间的分布及不同类样本之间的分离程度找一种适当的空间划分方法,或者找到一个分类边界,使得不同类样本分别位于不同的区域内。这就需要一个长时间且复杂的学习过程,不断调整用以划分样本空间的分类边界的位置,使尽可能少的样本被划分到非同类区域中。

 
 

       卷积网络在本质上是一种输入到输出的映射,它能够学习大量的输入与输出之间的映射关系,而不需要任何输入和输出之间的精确的数学表达式,只要用已知的模式对卷积网络加以训练,网络就具有输入输出对之间的映射能力。卷积网络执行的是有导师训练,所以其样本集是由形如:(输入向量,理想输出向量)的向量对构成的。所有这些向量对,都应该是来源于网络即将模拟的系统的实际”运行”结果。它们可以是从实际运行系统中采集来的。在开始训练前,所有的权都应该用一些不同的小随机数进行初始化。”小随机数”用来保证网络不会因权值过大而进入饱和状态,从而导致训练失败;”不同”用来保证网络可以正常地学习。实际上,如果用相同的数去初始化权矩阵,则网络无能力学习。

 
 

       训练算法与传统的BP算法差不多。主要包括4步,这4步被分为两个阶段:

 
 

第一阶段,向前传播阶段:

 
 

a)从样本集中取一个样本(X,Yp),将X输入网络;

 
 

b)计算相应的实际输出Op

 
 

      在此阶段,信息从输入层经过逐级的变换,传送到输出层。这个过程也是网络在完成训练后正常运行时执行的过程。在此过程中,网络执行的是计算(实际上就是输入与每层的权值矩阵相点乘,得到最后的输出结果):

 
 

          Op=Fn(…(F2F1XpW1W2)…)Wn

 
 

第二阶段,向后传播阶段

 
 

a)算实际输出Op与相应的理想输出Yp的差;

 
 

b)按极小化误差的方法反向传播调整权矩阵。

 
 

 
 

6)卷积神经网络的优点

 
 

        卷积神经网络CNN主要用来识别位移、缩放及其他形式扭曲不变性的二维图形。由于CNN的特征检测层通过训练数据进行学习,所以在使用CNN时,避免了显式的特征抽取,而隐式地从训练数据中进行学习;再者由于同一特征映射面上的神经元权值相同,所以网络可以并行学习,这也是卷积网络相对于神经元彼此相连网络的一大优势。卷积神经网络以其局部权值共享的特殊结构在语音识别和图像处理方面有着独特的优越性,其布局更接近于实际的生物神经网络,权值共享降低了网络的复杂性,特别是多维输入向量的图像可以直接输入网络这一特点避免了特征提取和分类过程中数据重建的复杂度。

 
 

        流的分类方式几乎都是基于统计特征的,这就意味着在进行分辨前必须提取某些特征。然而,显式的特征提取并不容易,在一些应用问题中也并非总是可靠的。卷积神经网络,它避免了显式的特征取样,隐式地从训练数据中进行学习。这使得卷积神经网络明显有别于其他基于神经网络的分类器,通过结构重组和减少权值将特征提取功能融合进多层感知器。它可以直接处理灰度图片,能够直接用于处理基于图像的分类。

 
 

       卷积网络较一般神经网络在图像处理方面有如下优点: a)输入图像和网络的拓扑结构能很好的吻合;b)特征提取和模式分类同时进行,并同时在训练中产生;c)权重共享可以减少网络的训练参数,使神经网络结构变得更简单,适应性更强。

 
 

7)小结

 
 

       CNNs中这种层间联系和空域信息的紧密关系,使其适于图像处理和理解。而且,其在自动提取图像的显著特征方面还表现出了比较优的性能。在一些例子当中,Gabor滤波器已经被使用在一个初始化预处理的步骤中,以达到模拟人类视觉系统对视觉刺激的响应。在目前大部分的工作中,研究者将CNNs应用到了多种机器学习问题中,包括人脸识别,文档分析和语言检测等。为了达到寻找视频中帧与帧之间的相干性的目的,目前CNNs通过一个时间相干性去训练,但这个不是CNNs特有的。

 
 

        呵呵,这部分讲得太啰嗦了,又没讲到点上。没办法了,先这样的,这样这个过程我还没有走过,所以自己水平有限啊,望各位明察。需要后面再改了,呵呵。

 
 

 
 

十、总结与展望

 
 

1Deep learning总结

 
 

      深度学习是关于自动学习要建模的数据的潜在(隐含)分布的多层(复杂)表达的算法。换句话来说,深度学习算法自动的提取分类需要的低层次或者高层次特征。高层次特征,一是指该特征可以分级(层次)地依赖其他特征,例如:对于机器视觉,深度学习算法从原始图像去学习得到它的一个低层次表达,例如边缘检测器,小波滤波器等,然后在这些低层次表达的基础上再建立表达,例如这些低层次表达的线性或者非线性组合,然后重复这个过程,最后得到一个高层次的表达。

 
 

       Deep learning能够得到更好地表示数据的feature,同时由于模型的层次、参数很多,capacity足够,因此,模型有能力表示大规模数据,所以对于图像、语音这种特征不明显(需要手工设计且很多没有直观物理含义)的问题,能够在大规模训练数据上取得更好的效果。此外,从模式识别特征和分类器的角度,deep learning框架将feature和分类器结合到一个框架中,用数据去学习feature,在使用中减少了手工设计feature的巨大工作量(这是目前工业界工程师付出努力最多的方面),因此,不仅仅效果可以更好,而且,使用起来也有很多方便之处,因此,是十分值得关注的一套框架,每个做ML的人都应该关注了解一下。

 
 

       当然,deep learning本身也不是完美的,也不是解决世间任何ML问题的利器,不应该被放大到一个无所不能的程度。

 
 

2Deep learning未来

 
 

       深度学习目前仍有大量工作需要研究。目前的关注点还是从机器学习的领域借鉴一些可以在深度学习使用的方法,特别是降维领域。例如:目前一个工作就是稀疏编码,通过压缩感知理论对高维数据进行降维,使得非常少的元素的向量就可以精确的代表原来的高维信号。另一个例子就是半监督流行学习,通过测量训练样本的相似性,将高维数据的这种相似性投影到低维空间。另外一个比较鼓舞人心的方向就是evolutionary programming approaches(遗传编程方法),它可以通过最小化工程能量去进行概念性自适应学习和改变核心架构。

 
 

Deep learning还有很多核心的问题需要解决:

 
 

1)对于一个特定的框架,对于多少维的输入它可以表现得较优(如果是图像,可能是上百万维)?

 
 

2)对捕捉短时或者长时间的时间依赖,哪种架构才是有效的?

 
 

3)如何对于一个给定的深度学习架构,融合多种感知的信息?

 
 

4)有什么正确的机理可以去增强一个给定的深度学习架构,以改进其鲁棒性和对扭曲和数据丢失的不变性?

 
 

5)模型方面是否有其他更为有效且有理论依据的深度模型学习算法?

 
 

       探索新的特征提取模型是值得深入研究的内容。此外有效的可并行训练算法也是值得研究的一个方向。当前基于最小批处理的随机梯度优化算法很难在多计算机中进行并行训练。通常办法是利用图形处理单元加速学习过程。然而单个机器GPU对大规模数据识别或相似任务数据集并不适用。在深度学习应用拓展方面,如何合理充分利用深度学习在增强传统学习算法的性能仍是目前各领域的研究重点。

 
 

 
 

十一、参考文献和Deep Learning学习资源持续更新……

 
 

       先是机器学习领域大牛的微博:@余凯_西二旗民工;@老师木;@梁斌penny@张栋_机器学习;@邓侃;@大数据皮东;@djvu9……

 
 

 
 

1Deep Learning

http://deeplearning.net/

2Deep Learning Methods for Vision

http://cs.nyu.edu/~fergus/tutorials/deep_learning_cvpr12/

3Neural Network for Recognition of Handwritten Digits[Project]

http://www.codeproject.com/Articles/16650/Neural-Network-for-Recognition-of-Handwritten-Digi

4Training a deep autoencoder or a classifier on MNIST digits

http://www.cs.toronto.edu/~hinton/MatlabForSciencePaper.html

5Ersatzdeep neural networks in the cloud

http://www.ersatz1.com/

6Deep Learning

http://www.cs.nyu.edu/~yann/research/deep/

7Invited talk “A Tutorial on Deep Learning” by Dr. Kai Yu (余凯)

http://vipl.ict.ac.cn/News/academic-report-tutorial-deep-learning-dr-kai-yu

8CNN – Convolutional neural network class

http://www.mathworks.cn/matlabcentral/fileexchange/24291

9Yann LeCun’s Publications

http://yann.lecun.com/exdb/publis/index.html#lecun-98

10 LeNet-5, convolutional neural networks

http://yann.lecun.com/exdb/lenet/index.html

11 Deep Learning 大牛Geoffrey E. Hinton’s HomePage

http://www.cs.toronto.edu/~hinton/

12Sparse coding simulation software[Project]

http://redwood.berkeley.edu/bruno/sparsenet/

13Andrew Ng’s homepage

http://robotics.stanford.edu/~ang/

14stanford deep learning tutorial

http://deeplearning.stanford.edu/wiki/index.php/UFLDL_Tutorial

15)「深度神经网络」(deep neural network)具体是怎样工作的

http://www.zhihu.com/question/19833708?group_id=15019075#1657279

16A shallow understanding on deep learning

http://blog.sina.com.cn/s/blog_6ae183910101dw2z.html

17Bengio’s Learning Deep Architectures for AI

 http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf

18andrew ng’s talk video:

http://techtalks.tv/talks/machine-learning-and-ai-via-brain-simulations/57862/

19cvpr 2012 tutorial

http://cs.nyu.edu/~fergus/tutorials/deep_learning_cvpr12/tutorial_p2_nnets_ranzato_short.pdf

20Andrew ng清华报告听后感

http://blog.sina.com.cn/s/blog_593af2a70101bqyo.html

21Kai YuCVPR12 Tutorial on Deep Learning Sparse Coding

22Honglak LeeDeep Learning Methods for Vision

23Andrew Ng Machine Learning and AI via Brain simulations

24Deep Learning 2,3

http://blog.sina.com.cn/s/blog_46d0a3930101gs5h.html

25deep learning这件小事……

http://blog.sina.com.cn/s/blog_67fcf49e0101etab.html

26Yoshua Bengio, U. MontrealLearning Deep Architectures

27Kai YuA Tutorial on Deep Learning

28Marc’Aurelio RanzatoNEURAL NETS FOR VISION

29Unsupervised feature learning and deep learning

http://blog.csdn.net/abcjennifer/article/details/7804962

30)机器学习前沿热点–Deep Learning

http://elevencitys.com/?p=1854

31)机器学习——深度学习(Deep Learning)

http://blog.csdn.net/abcjennifer/article/details/7826917

32)卷积神经网络

http://wenku.baidu.com/view/cd16fb8302d276a200292e22.html

33)浅谈Deep Learning的基本思想和方法

http://blog.csdn.net/xianlingmao/article/details/8478562

34)深度神经网络

http://blog.csdn.net/txdb/article/details/6766373

35Google的猫脸识别:人工智能的新突破

http://www.36kr.com/p/122132.html

36)余凯,深度学习机器学习的新浪潮,Technical News程序天下事

http://blog.csdn.net/datoubo/article/details/8577366

37Geoffrey HintonUCLTutorial on: Deep Belief Nets

38Learning Deep Boltzmann Machines

http://web.mit.edu/~rsalakhu/www/DBM.html

39Efficient Sparse Coding Algorithm

http://blog.sina.com.cn/s/blog_62af19190100gux1.html

40Itamar Arel, Derek C. Rose, and Thomas P. Karnowski Deep Machine Learning—A New Frontier in Artificial Intelligence Research

41Francis Quintal LauzonAn introduction to deep learning

42Tutorial on Deep Learning and Applications

43Boltzmann神经网络模型与学习算法

http://wenku.baidu.com/view/490dcf748e9951e79b892785.html

44Deep Learning Knowledge Graph 引爆大数据革命

http://blog.sina.com.cn/s/blog_46d0a3930101fswl.html

45)……

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

GPU Gems – Animation in the “Dawn” Demo

4.1 Introduction

 
 

“Dawn” is a demonstration(示范) that was created by NVIDIA Corporation to introduce the GeForce FX product line and illustrate how a high-level language (such as HLSL or Cg) could be used to create a realistic human character. The vertex shaders deform a high-resolution mesh through indexed skinning and morph targets, and they provide setup for the lighting model used in the fragment shaders. The skin and wing fragment shaders offer both range and detail that could not have been achieved before the introduction of advanced programmable graphics hardware. See Figure 4-1.

【Dawn是Nvidia新产品中怎样将HLSL应用于真人角色的示范,主要涉及Vertex shader用于morphing, fragment shader用于光照。】

 
 


Figure 4-1 A Screen Capture of the Real-Time Dawn

 
 

This chapter discusses how programmable graphics hardware was used to accelerate the animation of the Dawn character in the demo.

【这里讲的就是如何使用图形硬件编程来加速Draw的角色动画。】

 
 

 
 

 
 

4.2 Mesh Animation

 
 

Traditionally, mesh animation has been prohibitively expensive for complex meshes because it was performed on the CPU, which was already burdened with physical simulation, artificial intelligence, and other computations required by today’s applications. Newer graphics hardware has replaced the traditional fixed-function pipeline with programmable vertex and fragment shaders, and it can now alleviate some of that burden from the CPU.

【传统的网格动画开销非常贵因为局限于CPU顶点计算,而CPU还承担其他的大量的工作,新的图形硬件带来的vertex/fragment shader可以分担部分CPU工作。】

 
 

Sometimes it is still necessary to perform such operations on the CPU. Many stencil-based shadow volume techniques must traverse the transformed mesh in order to find the silhouette edges, and the generation of the dynamic shadow frustum is often best done on the CPU (see Chapter 9, “Efficient Shadow Volume Rendering”). In scenes where the character is drawn multiple times per frame into shadow buffers, glow buffers, and other such temporary surfaces, it may be better to perform the deformations on the CPU if the application becomes vertex-limited. Deciding whether to perform mesh deformations on the CPU or on the GPU should be done on a per-application or even on a per-object basis.

【有时候还是需要将网格动画计算放在CPU执行,因为像体阴影需要实时去找到阴影遮挡关系来计算阴影,这些工作是在CPu上面做的。当一个character需要很多次的去渲染到模版/texture的时候就比较不适合使用GPU运算。】

 
 

The modeling, texturing, and animation of the Dawn character were done primarily in Alias Systems’ Maya package. We therefore based our mesh animation methods on the tool set the software provides. We have since created a similar demo (“Dusk,” used to launch the GeForce FX 5900) in discreet’s 3ds max package, using the same techniques; these methods are common to a variety of modeling packages and not tied to any single workflow. The methods used in these two demos are (indexed) skinning, where vertices are influenced by a weighted array of matrices, and weighted morph targets, used to drive the emotions on Dawn’s face.

【dawn美术资源来源于maya,用于这里的morphing demo】

 
 

 
 

4.3 Morph Targets

 
 

Using morph targets is a common way to represent complex mesh deformation, and the NVIDIA demo team has created a variety of demos using this technique. The “Zoltar” demo and the “Yeah! The Movie” demo (content provided by Spellcraft Studio) started with 30 mesh interpolants per second, then removed mesh keys based on an accumulated error scheme. This allowed us to reduce the file size and the memory footprint—up to two-thirds of the original keys could be removed with little to no visible artifacts. In this type of mesh interpolation, there are only two interpolants active at any given time, and they are animated sequentially.

【morphing 常用于网格变形,nvidia也做过很多相关demo。】

 
 

Alternatively, morph targets can be used in parallel. Dawn is a standard example of how this approach can be useful. Beginning with a neutral head (27,000 triangles), our artist created 50 copies of that head and modeled them into an array of morph targets, as shown in Figure 4-2. Approximately 30 of those heads corresponded to emotions (such as happy, sad, thoughtful, and so on), and 20 more were modifiers (such as left eyebrow up, right eyebrow up, smirk, and so on). In this style of animation, the morph target weights will probably not add to 1, because you may have (0.8 * happy + 1.0 * ear_wiggle), for example—Dawn is a fairy, after all.

【另外,morph target也可是并行的。Dawn 的头包含27000个三角形,做了50个头来作为morph的target array。下图展示了一些,最终morphing的结果可以是多个morph target的加权和。】

 
 


Figure 4-2 Emotional Blend Targets (Blend Shapes)

 
 

Although such complex emotional faces could have been made entirely of blends of more elemental modifiers, our artist found it more intuitive to model the face in the pose he desired, because it is hard to model an element such as an eyebrow creasing, without seeing how the eyes, cheeks, and mouth work together. This combination also helps with hardware register limitations, described later.

【要合成复杂的表情动画还是非常难的,最终的结果要看是否自然,是否会出一些明显的错误是不被允许的。譬如眼睛突出来这样的人不可能会有的行为,要加以约束,如何处理约束后面会讲。】

 
 

 
 

4.3.1 Morph Targets in a High-Level Language

 
 

Luckily, the implementation of morph targets in HLSL or Cg is simple. Assuming that vertexIn is our structure containing per-vertex data, applying morph targets in a linear or serial fashion is easy:

【幸运的是硬件实现morpg target很简单,首先来看先后时间位置的差值做法会是如下。】

 
 

float4 position = (1.0f – interp) * vertexIn.prevPositionKey + interp * vertexIn.nextPositionKey;

 
 

In this code, interp is a constant input parameter in the shader, but prevPositionKey and nextPositionKey are the positions at the prior time and next time, respectively. When applying morph targets in parallel, we find the spatial difference between the morph target and the neutral pose, which results in a difference vector. We then weight that difference vector by a scalar. The result is that a weight of 1.0 will apply the per-vertex offsets to achieve that morph target, but each morph target can be applied separately. The application of each morph target is just a single “multiply-add” instruction:

【interp 是常数输入值,prevPositionKey/nextPositionKey 是前后时刻的位置。同一时间多个morph target做法也是类似,如下加权平均。】

 
 

// vertexIn.positionDiffN = position morph target N – neutralPosition

 
 

float4 position = neutralPosition;

position += weight0 * vertexIn.positionDiff0;

position += weight1 * vertexIn.positionDiff1;

position += weight2 * vertexIn.positionDiff2;

 
 

 
 

4.3.2 Morph Target Implementation

 
 

We wanted our morph targets to influence both the vertex position and the basis (that is, the normal, binormal, and tangent) so that they might influence the lighting performed in the fragment shader. At first it would seem that one would just execute the previous lines for position, normal, binormal, and tangent, but it is easy to run out of vertex input registers. When we wrote the “Dawn” and “Dusk” demos, the GPU could map a maximum of 16 per-vertex input attributes. The mesh must begin with the neutral position, normal, binormal, texture coordinate, bone weights, and bone indices (described later), leaving 10 inputs open for morph targets. We might have mapped the tangent as well, but we opted to take the cross product of the normal and binormal in order to save one extra input.

【我们想要morph target影响顶点位置和basis,相应的影响fragment shader的光照性能。这里要注意的是GPU寄存器的数量是有限的,除去渲染要用的寄存器剩下的就是morph可以使用的寄存器。只用normal,binormal就可以,可以叉乘得到tengent,节约寄存器。】

 
 

Because each difference vector takes one input, we might have 10 blend shapes that influence position, five blend shapes that influence position and normal, three position-normal-binormal blend shapes, or two position-normal-binormal-tangent blend shapes. We ultimately chose to have our vertex shader apply five blend shapes that modified the position and normal. The vertex shader would then orthonormalize the neutral tangent against the new normal (that is, subtract the collinear elements of the new normal from the neutral tangent and then normalize) and take the cross product for the binormal. Orthonormalization is a reasonable approximation for meshes that do not twist around the surface normal:

【每一个vector作为一个输入,通过blend都会影响到最终的position。我们最终选的方案是应用五个shape blend出最终的shape。计算新的tangent如下:】

 
 

// assumes normal is the post-morph-target result

// normalize only needed if not performed in fragment shader

 
 

float3 tangent = vertexIn.neutralTangent – dot(vertexIn.neutralTangent, normal) * normal;

tangent = normalize(tangent);

 
 

Thus, we had a data set with 50 morph targets, but only five could be active (that is, with weight greater than 0) at any given time. We did not wish to burden the CPU with copying data into the mesh every time a different blend shape became active, so we allocated a mesh with vertex channels for neutralPosition, neutralNormal, neutralBinormal, textureCoord, and 50 * (positionDiff, NormalDiff). On a per-frame basis, we merely changed the names of the vertex input attributes so that those that should be active became the valid inputs and those that were inactive were ignored. For each frame, we would find those five position and normal pairs and map those into the vertex shader, allowing all other vertex data to go unused.

【因此我们有了50个morph目标但是只能在同一时刻激活使用5个。我们不希望每一次做差值都需要重新拷贝这五个目标的数据,因此我们为mesh分配相关的vertex channel包括neutralPosition…信息。在每一帧的基础上,我们只是改变vertex input的属性名字来决定其是否激活,在进行计算。】

 
 

Note that the .w components of the positionDiff and normalDiff were not really storing any useful interpolants. We took advantage of this fact and stored a scalar self-occlusion term in the .w of the neutralNormal and the occlusion difference in each of the normal targets. When extracting the resulting normal, we just used the .xyz modifier to the register, which allowed us to compute a dynamic occlusion term that changed based on whether Dawn’s eyes and mouth were open or closed, without any additional instructions. This provided for a soft shadow used in the lighting of her skin (as described in detail in Chapter 3, “Skin in the ‘Dawn’ Demo”).

【positionDiff/normalDiff 的 .w 分量在差值中用不到,我们根据这个来让这个值存储遮蔽信息,这样就可以做到跟据w判读是否启用这里的.xyz,节省空间时间。】

 
 

On the content-creation side, our animator had no difficulty remaining within the limit of five active blend shapes, because he primarily animated between three or so emotional faces and then added the elemental modifiers for complexity. We separated the head mesh from the rest of the body mesh because we did not want the added work of doing the math or storing the zero difference that, say, the happy face would apply to Dawn’s elbow. The result remained seamless—despite the fact that the head was doing morph targets and skinning while the body was doing just skinning—because the outermost vertices of the face mesh were untouched by any of the emotional blend shapes. They were still modified by the skinning described next, but the weights were identical to the matching vertices in the body mesh. This ensured that no visible artifact resulted.

【在内容创建的部分,其实五个差值已经足够用来差出目标效果了。我们这里切分出头和身体,一般身体不参与这里的运算驱动。】

 
 

 
 

4.4 Skinning

 
 

Skinning is a method of mesh deformation in which each vertex of that mesh is assigned an array of matrices that act upon it along with weights (that should add up to 1.0) that describe how bound to that matrix the vertex should be. For example, vertices on the bicep may be acted upon only by the shoulder joint, but a vertex on the elbow may be 50 percent shoulder joint and 50 percent elbow joint, becoming 100 percent elbow joint for vertices beyond the curve of the elbow.

【蒙皮就是骨骼驱动网格数据,就是去定义一个mesh顶点怎样根据其骨骼权重差值得到新的位置。】

 
 

Preparing a mesh for skinning usually involves creating a neutral state for the mesh, called a bind pose. This pose keeps the arms and legs somewhat separated and avoids creases as much as possible, as shown in Figure 4-3. First, we create a transform hierarchy that matches this mesh, and then we assign matrix influences based on distance—usually with the help of animation tools, which can do this reasonably well. Almost always, the result must be massaged to handle problems around shoulders, elbows, hips, and the like. This skeleton can then be animated through a variety of techniques. We used a combination of key-frame animation, inverse kinematics, and motion capture, as supported in our content-creation tool.

【准备好一些bind pose,就是预定义的一些关键帧,这些关键帧就是人为的去除一些不自然的情况。然后的做法就是上述的蒙皮得到变形网格。】

 
 


Figure 4-3 Dawn’s Bind Pose

 
 

A skinned vertex is the weighted summation of that vertex being put through its active joints, or:

【公式描述:vertex最终位置由joint的加权乘结果得到,存在矩阵乘法是因为骨骼间的继承关系。】

 
 


 
 

Conceptually, this equation takes the vertex from its neutral position into a weighted model space and back into world space for each matrix and then blends the results. The concatenated 


 matrices are stored as constant parameters, and the matrix indices and weights are passed as vertex properties. The application of four-bone skinning looks like this:

【上面的计算存在在模型空间完成计算,然后结果再应用到世界空间这一个过程。实现如下】

 
 

float4 skin(float4x4 bones[98],

float4 boneWeights0,

float4 boneIndices0)

{

float4 result = boneWeights0.x * mul(bones[boneIndices.x], position);

result = result + boneWeights0.y * mul(bones[boneIndices.y],

position);

result = result + boneWeights0.z * mul(bones[boneIndices.z],

position);

result = result + boneWeights0.w * mul(bones[boneIndices.w],

position);

return result;

}

 
 

In the “Dawn” demo, we drive a mesh of more than 180,000 triangles with a skeleton of 98 bones. We found that four matrices per vertex was more than enough to drive the body and head, so each vertex had to have four bone indices and four bone weights stored as vertex input attributes (the last two of the 16 xyzw vertex registers mentioned in Section 4.3.2). We sorted bone weights and bone indices so that we could rewrite the vertex shader to artificially truncate the number of bones acting on the vertex if we required higher vertex performance. Note that if you do this, you must also rescale the active bone weights so that they continue to add up to 1.

【在 Dawn 的例子中,我们的网格超过 180000 三角形, 骨骼有 98 根。 我们发现一个顶点被四根骨头驱动就已经足够了,这里就是这么应用的,在这里要注意的一点是要保证权重合为一。】

 
 

4.4.1 Accumulated Matrix Skinning

 
 

When skinning, one must apply the matrix and its bind pose inverse not only to the position, but also to the normal, binormal, and tangent for lighting to be correct. If your hierarchy cannot assume that scales are the same across x, y, and z, then you must apply the inverse transpose of this concatenated matrix. If scales are uniform, then the inverse is the transpose, so the matrix remains unchanged. Nonuniform scales create problems in a variety of areas, so our engine does not permit them.

【skin的时候,我们不仅仅要对pose应用matrix, 其他信息一样要这么做。 一定要注意 uniform scale是必要的。】

 
 

If we call the skin function from the previous code, we must call mul for each matrix for each vertex property. In current hardware, multiplying a point by a matrix is implemented as four dot products and three adds, and vector-multiply is three dot products and two adds. Thus, four-bone skinning of position, normal, binormal, and tangent results in:

【统计一下四骨头驱动那些信息的计算量:一个顶点乘上矩阵就是下面第一个小括号的计算量,再乘上四个顶点共88条指令。】

 
 


 
 

An unintuitive technique that creates the sum of the weighted matrices can be trivially implemented in HLSL or Cg as follows:

【GPU处理矩阵运算:】

 
 

float4x4 accumulate_skin(float4x4 bones[98],

 

float4 boneWeights0,

float4 boneIndices0)

{

float4x4 result = boneWeights0.x * bones[boneIndices0.x];

result = result + boneWeights0.y * bones[boneIndices0.y];

result = result + boneWeights0.z * bones[boneIndices0.z];

result = result + boneWeights0.w * bones[boneIndices0.w];

return result;

}

 
 

Although this technique does burn instructions to build the accumulated matrix (16 multiplies and 12 adds), it now takes only a single matrix multiply to skin a point or vector. Skinning the same properties as before costs:

【这样可以减少总数的指令】

 
 


 
 

 
 

4.5 Conclusion

 
 

It is almost always beneficial to offload mesh animation from the CPU and take advantage of the programmable vertex pipeline offered by modern graphics hardware. Having seen the implementation of skinning and morph targets using shaders, however, it is clear that the inner loops are quite easy to implement using Streaming SIMD Extensions (SSE) instructions and the like, and that in those few cases where it is desirable to remain on the CPU, these same techniques work well.

 
 

In the case of the “Dawn” demo, morph targets were used to drive only the expressions on the head. If we had had more time, we would have used morph targets all over the body to solve problems with simple skinning. Even a well-skinned mesh has the problem that elbows, knees, and other joints lose volume when rotated. This is because the mesh bends but the joint does not get “fatter” to compensate for the pressing of flesh against flesh. A morph target or other mesh deformation applied either before or after the skinning step could provide this soft, fleshy deformation and create a more realistic result. We have done some work on reproducing the variety of mesh deformers provided in digital content-creation tools, and we look forward to applying them in the future.

【废话不翻译了。】

 
 

【这里没有很值得让人记住的技术点,最主要的贡献在于N的显卡的能力强大到如此大计算量的蒙皮人物也能跑的起来,如此复杂的avatar实际应用价值有限,GPU蒙皮的优化方案的效果理论上都达不到50%的优化,实际效果应该更加不如人意。】

 
 

4.6 References

 
 

Alias Systems. Maya 5.0 Devkit. <installation_directory>/devkit/animEngine/

 
 

Alias Systems. Maya 5.0 Documentation.

 
 

Eberly, David H. 2001. 3D Game Engine Design, pp. 356–358. Academic Press.

 
 

Gritz, Larry, Tony Apodaca, Matt Pharr, Dan Goldman, Hayden Landis, Guido Quaroni, and Rob Bredow. 2002. “RenderMan in Production.” Course 16, SIGGRAPH 2002.

 
 

Hagland, Torgeir. 2000. “A Fast and Simple Skinning Technique.” In Game Programming Gems, edited by Mark DeLoura. Charles River Media.

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

SIGGRAPH 15 – The Real-time Volumetric Cloudscapes of Horizon: Zero Dawn


 
 

Forslides with proper formatting and video/audio use the PPTX version.

 
 

The following was presented at SIGGRAPH 2015 as part of the Advances in Real-time rendering Course. http://advances.realtimerendering.com

 
 

Authors: Andrew Schneider –Principal FX Artist, Nathan Vos –Principal Tech Programmer

 
 


 
 

Thank you for coming.

 
 

Over the next half hour I am going to be breaking down and explaining the cloud system for Horizon Zero Dawn.

【接下来介绍cloud system】

 
 

As Natasha mentioned, my background is in Animated film VFX, with experience programming for voxel systems including clouds.

【作者原来是做动画电影特效的,有voxel system基础】

 
 

This was co-developed between myself and a programmer named Nathan Vos. He could not be here today, but his work is an important part of what we were able to achieve with this.

 
 

Horizon was just announced at E3 this year, and this is the first time that we are sharing some of our new tech with the community. What you are seeing here renders in about 2 milliseconds, takes 20 mbof ram and completely replaces our asset based cloud solutions in previous games.

 
 

Before I dive into our approach and justification for those 2 milliseconds, let me give you a little background to explain why we ended up developing a procedural volumetric system for skies in the first place.

【现讲一下使用procedural volumetric system for skies的背景】

 
 

In the past, Guerrilla has been known for the KILLZONE series of games, which are first person shooters .

 
 


 
 

FPS usually restrict the player to a predefined track, which means that we could hand place elements like clouds using billboards and highly detailed sky domes to create a heavily art directed sky.

【FPS经常限制玩家在一个预定的轨道上,因此像云这样的系统使用高质量的天空盒和billboard就可以了。】

 
 

These domes and cards were built in Photoshop by one artist using stock photography. As Time of day was static in the KILLZONE series, we could pre-bake our lighting to one set of images, which kept ram usage and processing low.

【上面这个demo就是这干的】

 
 

By animating these dome shaderswe could create some pretty detailed and epic sky scapesfor our games.

 
 

Horizon is a very different kind of game…

【Horizon 则是一款非常不一样的游戏】

 
 


 
 

Horizon trailer (Horizon 预告片)

 
 


 
 

So, from that you could see that we have left the world of Killzonebehind.

【从这你可以看到我们放弃了killzone的世界构造做法】

 
 

【horizon特点】

•Horizon is a vastly open world where you can prettymuch go anywhere that you see, including the tops of mountains.【超大自由世界随意走动,包括山顶】

•Since this is a living real world, we simulate the spinning of the earth by having a time of day cycle.【模拟的昼夜循环系统】

•Weather is part of the environment so it will be changing and evolving as well.【天气系统】

•There’s lots of epic scenery: Mountains, forests, plains, and lakes.【史诗般的风景:山,平原,湖泊,森林】

•Skies are a big part of the landscape of horizon. They make up half of the screen. Skies are also are a very important part of storytelling as well as world building.【天空是非常重要的一个部分,一般都占有了屏幕的一半来显示,也是非常重要的故事推进背景元素。】

 
 


 
 

They are used to tell us where we are, when we are, and they can also be used as thematic devices in storytelling.

【天空可以告诉你在哪,什么时候等信息】

 
 


 
 

For Horizon, we want the player to really experience the world we are building. So we decided to try something bold. We prioritized some goals for our clouds.

【我们希望玩家在我们创造的虚拟世界中有真实的体验,因此我们打算做一些大胆的尝试,我们给clouds列了下面这些目标】

 
 

•Artdirect-able【美术可以直接编辑】

•Realistic Representing multiple cloud types【真实的描述多变的云的形状】

•Integrate with weather【整合天气】

•Evolve in some way【存在演变方式】

•And of course, they needed to be Epic!【美】

 
 


 
 

Realistic CG clouds are not an easy nut to crack. So, before we tried to solve the whole problem of creating a sky full them, we thought it would be good to explore different ways to make and light individual cloud assets.

【realistic CG云并不是一件容易啃的骨头。因此在开始处理这个问题前,我们首先浏览目前的所有云的制作方法。】

 
 


 
 

Our earliestsuccessful modeling approach was to use a custom fluid solver to grow clouds. The results were nice, but this was hard for artists to control if they had not had any fluid simulation experience. Guerrilla is a game studio after all.

【流体模拟的方法:效果不错,但是美术很难去独立控制实现】

 
 


 
 

We ended up modeling clouds from simple shapes,

Voxelizing them and then ?

Running them through our fluid solver ?

Until we got a cloud like shape .

【我们最后做了个云的模型,像飞船】

 
 


 
 

And then we developed a lighting model that we used to pre-compute primary and secondary scattering,

•Ill get into our final lighting model a little later, but the result you see here is computed on the cpuin Houdini in 10 seconds.

【然后我们使用预计算的一二级散射开发了一个cloud模型,这个模型的预渲染花了10秒!】

 
 


 
 

We explored 3 ways to get these cloud assets into game.

【我们探索了三种方式来使得云加入游戏】

 
 

•For the first, we tried to treat our cloud as part of the landscape, literally modeling them as polygons from our fluid simulations and baking the lighting data using spherical harmonics. This only worked for the thick clouds and not whispyones …

【第一种是多边形对象的方式,只适合厚厚的云层和不形变的云】

 
 


 
 

So, we though we should try to enhance the billboard approach to support multiple orientations and times of day . We succeeded but we found that we couldn’t easily re-produce inter cloud shadowing. So…

【billboard的方式,不能处理阴影】

 
 


 
 

•We tried rendering all of our voxel clouds as one cloud set to produce sky domes that could also blend into the atmosphere over depth. Sort of worked.

【尝试把所有的voxel cloud按照深度排序被大气blend,当作一个整体看作是天空穹顶。】

 
 

•At this point we took a step back to evaluate what didn’t work. None of the solutions made the clouds evolve over time. There was not a good way to make clouds pass overhead. And there was high memory usage and overdraw for all methods.

【然后回过头来看,voxel clouds对最终结果没有做出贡献占大部分,pass overhead严重,性能非常不好,不是一种好的选择】

 
 

•So maybe a traditional asset based approach was not the way to go.

【因此传统的方法不是一种好的选择】

 
 


 
 

Well, What about voxel clouds?

OK we are crazy we are actually considering voxel clouds now…

As you can imagine this idea was not very popular with the programmers.

【接下来我们疯了,考虑体素云,一般来说这不是一个好选择,原因如下:】

 
 

Volumetrics are traditionally very expensive

With lots of texture reads

Ray marches

Nested loops

【原因】

 
 

However, there are many proven methods for fast, believable volumetric lighting

There is convincing work to use noise to model clouds . I can refer you to the 2012 Production Volume Rendering course.

Could we solve the expense somehow and benefit from all of the look advantages of volumetrics?

【然而,可以做出令人惊艳的效果,也有一些方法在改进效率。这方法的成败就在于效率的处理能否达到要求。】

 
 


 
 

Our first test was to stack up a bunch of polygons in front of the camera and sample 3d Perlin noise with them. While extremely slow, This was promising, but we want to represent multiple clouds types not just these bandy clouds.

【我们首先测试的方法是在相机前堆了一堆多边形对它们取sample,超级慢,而且我们不希望只有这样的罗圈云。】

 
 


 
 

So we went into Houdini and generated some tiling 3d textures out of the simulated cloud shapes. Using Houdini’s GL extensions, we built a prototype GL shader to develop a cloud system and lighting model.

【然后我们采用Houdini来生成3D纹理,利用 Houdini’s GL extensions来开发一个cloud system和光照模型】

【Houdini软件介绍 https://zh.wikipedia.org/wiki/Houdini

 
 


 
 

In The end, with a LOT of hacks, we got very close to mimicking our reference. However, it all fell apart when we put the clouds in motion. It also took 1 second per frame to compute. For me coming from animated vfx, this was pretty impressive, but my colleagues were still not impressed.

【最终加上其他一些东西我们得到的效果和真实效果已经非常相似,但是在云的运动过程中模块感强烈,而且渲染一张需要一秒,这还是不够】

 
 

So I thought, Instead of explicitly defining clouds with pre-determined shapes, what if we could develop some good noises at lower resolutions that have the characteristics we like and then find a way to blend between them based on a set of rules. There has been previous work like this but none of it came close to our look goals.

【因此,不采用明确的已经预定义的云的形状的组合,而是通过noise产生特征并通过一定的方法混合来获得云的形状】

 
 


 
 

This brings us to the clouds system for horizon. To explain it better I have broken it down into 4 sections: Modeling, Lighting, Rendering and Optimization.

【cloud system工作流分成四个阶段:modeling, lighting, rendering, optimization】

 
 

Before I get into how we modeled the cloud scapes, it would be good to have a basic understanding of what clouds are and how they evolve into different shapes.

【了解一下自然界云的形状的情况】

 
 


 
 

Classifying clouds helped us better communicate what we were talking about and Define where we would draw them.

【这有助于让我们知道把特定的云画在哪里】

The basic cloud types are as follows.【基本的云形状】

•The stratoclouds including stratus, cumulus and stratocumulus【云分类】

•The alto clouds, which are those bandy or puffy clouds above the stratolayer【层云(低)】

•And the cirroclouds those big arcing bands and little puffs in the upper atmosphere.【卷云(中)】

•Finally there is the granddaddy of all cloud types, the Cumulonimbus clouds which go high into the atmosphere.【积雨云(高)】

•For comparison, mount Everest is above 8,000 meters.【设定最高高度8000m】

 
 


 
 

After doing research on cloud types, we had a look into the forces that shape them. The best source we had was a book from 1961 by two meteorologists, called “The Clouds” as creatively as research books from the 60’s were titled. What it lacked in charm it made up for with useful empirical results and concepts that help with modeling a cloud system.

【做云类型的研究之后,我们去看一下塑造clouds的力量。来源是1961年的一本由两位气象学家写的书。它弥补了造型云系相关的概念成果对我们有所帮助。】

 
 

§Density increases at lower temperatures【低温下密度增加】

§Temperature decreases over altitude【海拔下降温度升高】

§High densities precipitate as rain or snow【高密度沉淀为雨雪】

§Wind direction varies over altitude【不同海拔高度的风】

§They rise with heat from the earth【保温作用】

§Dense regions make round shapes as they rise【密度决定形状】

§Light regions diffuse like fog【漫反射性质像雾一样】

§Atmospheric turbulence further distorts clouds.【大气湍流进一步扭曲了云】

 
 

These are all abstractions that are useful when modeling clouds

【这些对于构造云系统非常有用】

 
 


 
 

Our modeling approach uses ray marching to produce clouds.

【我们的模型使用光线跟踪生产云。】

 
 

We march from the camera and sample noises and a set of gradients to define our cloud shapes using a sampler

【我们通过sampler来确定云的形状】

 
 


 
 

In a ray march you use a sampler to…

 
 

Build up an alpha channel….

And calculate lighting

【sampler用来确定alpha值和光照计算】

 
 


 
 

There are many examples of real-time volume clouds on the internet. The usual approach involves drawing them in a height zone above the camera using something called fBm, Fractal Brownian Motion(分形布朗运动). This is done by layering Perlin noises of different frequencies until you get something detailed.

【网络上很多的体素云的例子,大部分是在相机的上半部分采用FBM绘制,就是分层perlin noise直到达到满意效果】

 
 

(pause)

 
 

This noise is then usually combined somehow with a gradient to define a change in cloud density over height

【这种noise通过梯度合并的方式来处理云的密度岁高度变化的问题】

 
 


 
 

This makes some very nice but very procedural looking clouds.

What’s wrong?

There are no larger governing shapes or visual cues as to what is actually going on here. We don’t feel the implied evolution of the clouds from their shapes.

【这样的结果非常的程序化的感觉】

【问题在于没有给与真实的存在于那空间的感觉,我们感受不到云的形状的演变趋势。】

 
 


 
 

By contrast, in this photograph we can tell what is going on here. These clouds are rising like puffs of steam from a factory. Notice the round shapes at the tops and whispyshapes at the bottoms.

【相反,在照片中我们能感受到云的运动方向,还有注意照片中底部和顶部的云的不同】

 
 


 
 

This fBm approach has some nice whispy shapes, but it lacks those bulges and billows that give a sense of motion. We need to take our shader beyond what you would find on something like Shader Toy.

【FBm方法可以带来云的稀疏的分布和形状,但是没有那种跌宕起伏的运动感,这是我们想要解决的问题。】

 
 


 
 

These billows, as Ill call them?

…are packed, sometimes taking on a cauliflower shape.

Since Perlin noise alone doesn’s cut it, we developed our own layered noises.

【云很多的时候,需要这种菜花状,这个perlin noise做不到,我们开发了自己的layered noises】

 
 


 
 

Worley noise was introduced in 1996 by Steven Worley and is often used for caustics and water effects. If it is inverted as you see here:

It makes tightly packed billow shapes.

We layered it like the standard Perlin fBm approach

【Worley noise 是这种紧凑的枕头形状,我们首先把它层次化了】

 
 

Then we used it as an offset to dilate Perlin noise. this allowed us to keep the connectedness of Perlin noise but add some billowy shapes to it.

We referred to this as Perlin-Worley noise

【然后混合Perlin noise做offset,效果如下】

 
 


 
 

In games, it is often best for performance to store noises as tiling 3d textures.

【游戏中一般都是用生成好的3D noise textures,为了性能】

 
 

You want to keep texture reads to a minimum?

And keep the resolutions as small as possible.

In our case we have compressed our noises to?

two 3d textures?

And 1 2d texture.

【分辨率:够用的最小化处理】

 
 


 
 

The first 3d Texture…

 
 

has 4 channels…

it is 128^3 resolution…

The first channel is the Perlin-Worley noise I just described.

The other 3 are Worley noise at increasing frequencies. Like in the standard approach, This 3d texture is used to define the base shape for our clouds.

【第一层情况】

 
 


 
 

Our second 3d texture…

 
 

has 3 channels…

it is 32^3 resolution…

and uses Worley noise at increasing frequencies. This texture is used to add detail to the base cloud shape defined by the first 3d noise.

【第二层:降低分辨率】

 
 


 
 

Our 2D texture…

 
 

has 3 channels…

it is 128^2 resolution…

and uses curl noise. Which is non divergent and is used to fake fluid motion. We use this noise to distort our cloud shapes and add a sense of turbulence.

【2D纹理存储情况】

 
 


 
 

Recall that the standard solution calls for a height gradient to change the noise signal over altitude. Instead of 1, we use…

【回想下前面讲到的网络上的标准方法通过梯度改变noise signal来实现海拔的考虑。我们这边也是这么采用的】

 
 

3 mathematical presets that represent the major low altitude…

cloud types when we blend between them at the sample position.

We also have a value telling us how much cloud coverage we want to have at the sample position. This is a value between zero and 1.

【3表示低空,预设;云形状会根据所在位置混合,这里主要说的应该是高度不同不混合,同时这个值也就决定了云层间的覆盖关系】

 
 


 
 

What we are looking at on the right side of the screen is a view rotated about 30 degrees above the horizon. We will be drawing clouds per the standard approach in a zone above the camera.

【右边是仰角三十度仰看的天空,下面在这视角下绘制云。】

 
 

First, we build a basic cloud shape by sampling our first 3dTexture and multiplying it by our height signal.

【首先我们绘制基本的云的形状通过 sampling 前面的3dtexture 乘上 高度信号,见PPT公式。】

 
 

The next step is to multiply the result by the coverage and reduce density at the bottoms of the clouds.

【然后是乘上coverage来减少云的密度】

 
 


 
 

This ensures that the bottoms will be whispy and it increases the presence of clouds in a more natural way. Remember that density increases over altitude. Now that we have our base cloud shape, we add details.

【这样就有了一个比较自然的基本的云的情况,下面添加细节】

 
 


 
 

The next step is to…

 
 

erode the base cloud shape by subtracting the second 3d texture at the edges of the cloud.

Little tip, If you invert the Worley noise at the base of the clouds you get some nice whispy shapes.

【通过第二层的3D texture来侵蚀云层的形状,小技巧说的是你可以直接取反来做侵蚀效果同样好。】

 
 

We also distort this second noise texture by our 2d curl noise to fake the swirly distortions from atmospheric turbulence as you can see here…

【我们同时使用2D 纹理噪音来模拟大气流动带来的云层扭曲】

 
 


 
 

Here’s that it looks like in game. I’m adjusting the coverage signal to make them thicker and then transitioning between the height gradients for cumulus to stratus.

【游戏中的效果,coverage调整的是云层的厚度,height gradient调整的是高度】

 
 

Now that we have decent stationary clouds we need to start working on making them evolve as part of our weather system.

【现在我们的云本身已经差不多了,我们要把它搞进我们的天气系统】

 
 


 
 

These two controls, cloud coverage and cloud type are a FUNCTION of our weather system.

【控制一:云的覆盖程度】

 
 

There is an additional control for Precipitation that we use to draw rain clouds.

【控制二:降水量值用来控制rain cloud的绘制量】

 
 


 
 

Here in this image you can see a little map down in the lower left corner. This represents the weather settings that drive the clouds over our section of world map. The pinkish white pattern you see is the output from our weather system. Red is coverage, Green is precipitation and blue is cloud type.

【左下角的小图表示当前世界天气驱动的云层设置,您所看到的粉红色相间的花纹是从我们的天气系统的输出。红色是Coverage,绿色是降水,蓝色是云的类型。】

 
 

The weather system modulates these channels with a simulation that progresses during gameplay. The image here has Cumulus rain clouds directly overhead (white) and regular cumulus clouds in the distance. We have controls to bias the simulation to keep things art direct-able in a general sense.

【这个图就是可视化的天气系统和云的渲染的接口】

 
 


 
 

The default condition is a combination of cumulus and stratus clouds. The areas that are more red have less of the blue signal, making them stratus clouds. You can see them in the distance at the center bottom of the image.

【默认情况是积云和层云的组合,图中大红色的区域】

 
 


 
 

The precipitation signal transitions the map from whatever it is to cumulonimbus clouds at 70% coverage

【积雨云覆盖超过7成自动启动降雨信号】

 
 


 
 

The precipitation control not only adjusts clouds but it creates rain effects. In this video I am increasing the chance of precipitation gradually to 100%

【降雨信号同时启动雨的特效】

 
 


 
 

If we increase the wind speed and make sure that there is a chance of rain, we can get Storm clouds rolling in and starting to drop rain on us. This video is sped up, for effect, btw. Ahhh… Nature Sounds.

【增加了风的效果加上下雨,我们获得的是暴风雨的效果】

 
 


 
 

We also use our weather system to make sure that clouds are the horizon are always interesting and poke above mountains.

【我们还保证天边总是有云的】

 
 

We draw the cloudscapes with in a 35,000 meter radius around the player….

and Starting at a distance of 15,000 meters…

we start transitioning to cumulus clouds at around 50% coverage.

【我们绘制一个cloudscapes 半径为35000米绕在用户周围,距离用户15000米的时候开始过渡到50%覆盖率的积云】

 
 


 
 

This ensures that there is always some variety and ‘epicness’ to the clouds on the horizon.

So, as you can see, the weather system produces some nice variation in cloud type and coverage.

【这保证了天边总是有云的而且云的类型也符合自然效果】

 
 


 
 

In the case of the e3 trailer, We overrode the signals from the weather system with custom textures. You can see the corresponding textures for each shot in the lower left corner. We painted custom skies for each shot in this manner.

【e3 trailer上面的例子的做法:自定义右下角云图】

 
 


 
 

So to sum up our modeling approach…

【总结一下自家的方法】

 
 

we follow the standard ray-march/ sampler framework but we build the clouds with two levels of detail

a low frequency cloud base shape and high frequency detail and distortion

Our noises are custom and made from Perlin, Worley and Curl noise

We use a set of presets for each cloud type to control density over height and cloud coverage

These are driven by our weather simulation or by custom textures for use with cut scenes and it is all animated in a given wind direction.

 
 


 
 

Cloud lighting is a very well researched area in computer graphics. The best results tend to come from high numbers of samples. In games, when you ask what the budget will be for lighting clouds, you might very well be told “Zero”. We decided that we would need to examine the current approximation techniques to reproduce the 3 most important lighting effects for us.

【cloud lighting是一个非常好的研究领域,因为可以得到很好的效果,但是大量的sample带来的计算量巨大,需要找到很好的近似方法来应用于游戏这样的real time rendering领域】

 
 


 
 

The directional scattering(散射) or luminous(发光) quality of clouds…

The sliver lining when you look toward the sun through a cloud…

And the dark edges visible on clouds when you look away from the sun.

【解释一下光学效应:云会发生散射从而可以看到云的黑边,透过云看到阳光则会感受到云在发光一样的效果】

 
 

The first two have standard solutions but the third is something we had to solve ourselves.

【实现方案:下面先介绍两种标准解决方案,最后第三种是我们的方案】

 
 


 
 

When light enters a cloud

The majority of the light rays spend their time refracting off of water droplets and ice inside of the cloud before heading to our eyes.

【一束光射入云层到你眼睛之间大部分时间都花在了水滴间的折射】

 
 

(pause)

By the time the light ray finally exits the cloud it could have been out scattered absorbed by the cloud or combined with other light rays in what is called in-scattering.

【最终射出的光线能量集合了射入的去掉散射掉的再加上其他光线散射过来的同一方向的能量】

 
 

In film vfx we can afford to spend time gathering light and accurately reproducing this, but in games we have to use approximations. These three behaviors can be thought of as probabilities and there is a Standard way to approximate the result you would get.

【特效电影就是这么实打实的来算的,但是我们游戏中必须采用近似计算,下面介绍方法。】

 
 


 
 

Beer’s law states that we can determine the amount of light reaching a point based on the optical thickness of the medium that it travels through. With Beers law, we have a basic way to describe the amount of light at a given point in the cloud.

 
 

If we substitute energy for transmittance ad depth in the cloud for thickness, and draw this out you can see that energy exponentially decreases over depth. This forms the foundation of our lighting model.
 

【Beer’s law:揭示的是云层厚度和能量损失的关系,这是我们采用的光照模型的基础】

 
 


 
 

but there is a another component contributing to the light energy at a point. It is the probability of light scattering forward or backward in the cloud. This is responsible for the silver lining in clouds, one of our look goals.

【影响最终结果的还有,云层前后表面的散射】

 
 


 
 

In clouds, there is a higher probability of light scattering forward. This is called Anisotropic scattering.

【光线进入云层时存在 各向异性散射】

 
 

In 1941, the Henyey-Greenstein model was developed to help astronomers with light calculations at galactic scales, but today it is used to reliably reproduce Anisotropy in cloud lighting.

【Henyey-Greenstein model: 最初用于天文学的测量,这里用于云的各向异性的亮度处理】

 
 


 
 

Each time we sample light energy, we multiply it by The Henyey-Greenstein phase function.

【每一时刻我们sample light energy,把它应用于Henyey-Greenstein phase function】

 
 


 
 

Here you can see the result. On the left is Just the beers law portion of our lighting model. On the right we have applied the Henyey-Greenstein phase function. Notice that the clouds are brighter around the sun on the right.

【效果展示:左边只是beer’s law的效果,右边加上Henyey-Greenstein phase function处理后的效果】

 
 


 
 

But we are still missing something important, something that is often forgotten. The dark edges on clouds. This is something that is not as well documented with solutions so we had to do a thought experiment to understand what was going on.

【但是我们还是忘了很多重要的部分。云层的黑边,我们不得不去看看怎么解决】

 
 


 
 

Think back to the random walk of a light ray through a cloud.

【考虑一随机光线怎样通过云层】

 
 

If we compare a point inside of the cloud to one near the surface, the one inside would receive more in scattered light. In other words, Cloud material, if you want to call it that, is a collector for light. The deeper you are in the surface of a cloud, the more potential there is for gathered light from nearby regions until the light begins to attenuate, that is.

【你眼睛接收到的云的一点反射出的能量是集合了大量的光线的反射结果,换句话说,云的材质是光的集合,云层越深这集合就越大】

 
 

This is extremely pronounced in round formations on clouds, so much so that the crevices appear…

【因此才会出现云的黑边的问题,边界的眼睛直线方向上的云的深度比较小。】

 
 

to be lighter that the bulges and edges because they receive a small boost of in-scattered light.

Normally in film, we would take many many samples to gather the contributing light at a point and use a more expensive phase function. You can get this result with brute force. If you were in Magnus Wrenninge’s multiple scattering talk yesterday there was a very good example of how to get this. But in games we have to find a way to approximate this.

【电影里面采用大量的sample直接来模拟得到效果,但是游戏中我们就得想办法来得到近似效果。】

 
 


 
 

A former colleague of mine, Matt Wilson, from Blue Sky, said that there is a similar effect in piles of powdered sugar. So, I’ll refer to this as the powdered sugar look.

【一堆云和一堆糖在这一层面的效果和原理是一致的】

 
 


 
 

Once you understand this effect, you begin to see it everywhere. It cannot be un-seen.

Even in light whispyclouds. The dark gradient is just wider.

【你明白了原理你会发现这效果无处不在】

 
 


 
 

The reason we do not see this effect automatically is because our transmittance function is an approximation and doesn’t take it into account.

【我们原来的模型忽略了这一点原理,因此看不到效果】

 
 

The surface of the cloud is always going to have the same light energy that it receives. Let’s think of this effect as a statistical probability based on depth.

【我们来重新考虑lighting模型】

 
 


 
 

As we go deeper in the cloud, our potential for in scattering increases and more of it will reach our eye.

【云层越深,潜在的散射越强到达眼睛的能量越多】

 
 

If you combine the two functions you get something that describes this?

【我们合并这两个公式会得到什么样的结果呢?】

 
 

Effect as well as the traditional approach.

I am still looking for the Beer’s-Powder approximation method in the ACM digital library and I haven’t found anything mentioned with that name yet.

【我们没有找到相关创新的做法,在学界。就是说混合这两种原理作者是第一个这么做的】

 
 


 
 

Lets visually compare the components of our directional lighting model

The beer’s law component which handles the primary scattering?

The powder sugar effect which produces the dark edges facing the light?

And their combination in our final result.

【比较图中的四种方法的效果】

 
 


 
 

Here you can see what the beer’s law and combined beer’s law and powder effect look like when viewed from the light source. This is a pretty good approximation of our reference.

【混合Beer’s-Powder approximation得到了非常好的效果】

 
 


 
 

In game, it adds a lot of realism to the Thicker clouds and helps sell the scale of the scene.

【在游戏中增加了云的真实感】

 
 


 
 

But we have to remember that this is a view dependent effect. We only see it where our view vector approaches the light vector, so the powder function should account for this gradient as well.

【但是我们还是要记住这是一个基于视点的效果,这种效果适应的是光源直接在当前看得到的范围内且不被遮挡,上图所示的情况则是不适合的】

 
 


 
 

Here is a panning camera view that shows this effect increasing as we look away from the sun.

【效果展示,非常漂亮】

 
 


 
 

The last part of our lighting model is that we artificially darken the rain clouds by increasing the light absorption where they exist.

【最后要提到的是我们对于下雨的云曾加了暗度通过增加云对光的吸收量来实现】

 
 


 
 

So, in review our model has 3 components:

【总结一下模型,包含以下四个原理】

Beer’s Law

Henyen-Greenstein

our powder sugar effect

And Absorption increasing for rain clouds

 
 

 
 


 
 

I have outlined How our sampler is used to model clouds and how our lighting algorithm simulates the lighting effects associated with them. Now I am going to describe how and where we take samples to build an image. And how we integrate our clouds into atmosphere and our time of day cycle.

【接下来介绍怎么取sample来产生image,以及如何运用云在大气模拟中】

 
 


 
 

The first part of rendering with a ray march is deciding where to start. In our situation, Horizon takes place on Earth and as most of you are aware… the earth ….. Is round.

The gases that make up our atmosphere wrap around the earth and clouds exists in different layers of the atmosphere.

【大气层中由于气体的原因,云层分为好几种】

 
 


 
 

When you are on a “flat” surface such as the ocean, you can clearly see how the curvature of the earth causes clouds to descend into the horizon.

【当你在一个”平”的表面,如海洋,你可以清楚地看到地球的曲率如何使云彩降入地平线。】

 
 


 
 

For the purposes of our game we divide the clouds into two types in this spherical atmosphere.

 
 

•The low altitude volumetric stratoclass clouds between 1500 and 4000 meters…

•and the high altitude 2D alto and cirroclass clouds above 4000 meters. The upper level clouds are not very thick so this is a good area to reduce expense of the shaderby making them scrolling textures instead of multiple samples in the ray march.

 
 

【游戏里面我们将大气层分为两部分,按照高度区分,两部分分别存在不同类型的云层,超过4km的部分的云层忽略不模拟】

 
 


 
 

By ray marching through spherical atmosphere we can?

ensure that clouds properly descend into the horizon.

It also means we can force the scale of the scene by shrinking the radius of the atmosphere.

【如何模拟光线通过球形的大气层来确保云层远处看上去会降入地平线。这意味着我们要调整一下场景比例来做到】

 
 


 
 

In our situation we do not want to do any work or any expensive work where we don’t need to. So instead of sampling every point along the ray, we use our samplers two levels of detail as a way to do cheaper work until we actually hit a cloud.

【我们不希望做任何无用功来提高性能,因此我们不是sample光线的每一个点,而是采用了2层的LOD来降低工作量】

 
 


 
 

Recall that the sampler has a low detail noise that make as basic cloud shape

And a high detail noise that adds the realistic detail we need.

The high detail noise is always applied as an erosion from the edge of the base cloud shape.

【首先sample低精度的noise来获得基本的云的形状,然后sample高精度的noise来获得真实感的云,见上图所示。高精度的noise用来侵蚀已建好的低精度的云层。】

 
 


 
 

This means that we only need to do the high detail noise and all of its associated instructions where the low detail sample returns a non zero result.

This has the effect of producing an isosurface that surrounds the area that our cloud will be that could be.

【跟据体素的等值面的概念,我们的高精度处理只需要发生下0值也就是体素表面就行,节省了大量的计算】

 
 


 
 

So, when we take samples through the atmosphere, we do these cheaper samples at a larger step size until we hit a cloud isosurface. Then we switch to full samples with the high detail noise and all of its associated instructions. To make sure that we do not miss any high res samples, we always take a step backward before switching to high detail samples.

【因此在取sample的时候我们首先在低精度的场景下做光线跟踪,只需要在特定的部分采用高精度sample来光线跟踪处理,而且高精度的部分可以采用独立线程来做,确保帧率】

 
 


 
 

Once the alpha of the image reaches 1 we don’t need to keep sampling so we stop the march early.

【一旦alpha值到达1,则停止光线继续传播】

 
 


 
 

If we don’t reach an alpha of one we have another optimization.

After several consecutive samples that return zero density, we switch back to the cheap march behavior until we hit something again or reach the top of the cloud layer.

【如果alpha值到不了1,我们切换回低精度的光线跟踪,知道光线射出大气层停止追踪。】

 
 


 
 

Because of the fact that the ray length increases as we look toward the horizon, we start with

an initial potential 64 samples and end with a potential 128 at the horizon. I say potential because of the optimizations which can cause the march to exit early. And we really hope they do.

This is how we take the samples to build up the alpha channel of our image. To calculate light intensity we need to take more samples.

【因为从眼睛发出的光穿越在球形大气的距离不一样,我们设置了64-128个sample的处理范围】

 
 


 
 

Normally what you do in a ray march like this is to take samples toward the light source, plug the sum into your lighting equation and then attenuate this value using the alpha channel until you hopefully exit the march early because your alpha has reached 1.

【正常境况下光线追踪的做法就是眼睛发出的光线到达光源的路径能量总和,1为上限】

 
 


 
 

In our approach, we sample 6 times in a cone toward the sun. This smooth’s the banding we would normally get with 6 simples and weights our lighting function with neighboring density values, which creates a nice ambient effect. The last sample is placed far away from the rest in order to capture shadows cast by distant clouds.

【我们的方法里面,每一次我们在朝向光源的一个椎体范围内sample6次作为一次折射结果。这种方式可以很好的表现环境光】

 
 


 
 

Here you can see what our clouds look like with just alpha samples with our 5 cone samples for lighting and the long distance cone sample.

To improve performance of these light samples, we switched to sampling the cheap version of our shader once the alpha of the image reached 0.3. , this made the shader 2x faster

【这里你可以看到的云就是上面那种alpha椎体sample方式的结果。为了提高性能,当alpha值达到0.3后,我们完全采用粗粒度的sample方式。】

 
 


 
 

The lighting samples replace the lower case d, or depth in the beers law portion of our lighting model. This energy value is then attenuated(衰减) by the depth of the sample in the cloud to produce the image as per the standard volumetric ray-marching approach.

【能量公式,我们改掉了bear’s law的部分的能量实现方式】

 
 


 
 

The last step of our ray march was to sample the 2d cloud textures for the high altitude clouds

【光线追踪的最后一步就是纹理的采用】

 
 


 
 

These were a collection of the various types of cirrus and alto clouds that were tiling and scrolling at different speeds and directions above the volumetric clouds.

【我们采用了一系列的云层纹理,他们之间的区别在于tiling,scroling的速度和方向不同】

 
 


 
 

In reality light rays of different frequencies are mixing in a cloud producing very beautiful color effects. Since we live in a world of approximations, we had to base cloud colors on some logical assumptions.

We color our clouds based on the following model:

【现实中光线的频率不同带来的混合会出现漂亮的颜色特效,我们通过逻辑上的模拟来实现,我们的云层的颜色基于下面这些模块】

 
 

Ambient sky contribution increases over height

Direct lighting would be dominated by the sun color

Atmosphere would occlude clouds over depth.

 
 

We add up our ambient and direct components and attenuate to the atmosphere color based on the depth channel.

【上面三种结果相加混合】

 
 


 
 

Now, you can change the time of day in the game and the lighting and colors update automatically. This means no pre-baking and our unique memory usage for the entire sky is limited to the cost of 2 3d textures and 1 2d texture instead of dozens of billboards or sky domes.

【现在你可以根据游戏中的时间来调整大气的颜色亮度了,这里没有采用预烘焙的方式节约了大量的存储空间】

 
 


 
 

To sum up what makes our rendering approach unique:

【总结一下渲染方面用到的方法特点】

 
 

Sampler does “heap” work unless it is potentially in a cloud

64-128 potential march samples, 6 light samples per march in a cone, when we are potentially in a cloud.

Light samples switch from full to cheap at a certain depth

 
 

 
 


 
 

The approach that I have described so far costs around 20 milliseconds.

(pause for laughter)

Which means it is pretty but, it is not fast enough to be included in our game. My co-developer and mentor on this, Nathan Vos, Had the idea that…

【到上面为止每一帧这一部分的渲染时长还是在20毫秒,作为游戏这还不够快】

 
 


 
 

Every frame we could use a quarter res buffer to update 1 out of 16 pixels for each 4×4 pixel block with in our final image.

We reproject the previous frame to ensure we have something persistent.

【把我们最终的画面的4*4个pixel组成一个block,每次更新1/16,其他的重用上一帧的】

 
 


 
 

…and where we could not reproject, like the edge of the screen, We substitute the result from one of the low res buffers.

Nathan’s idea made the shader10x faster or more when we render this at half res and use filters to upscale it.

It is pretty much the whole reason we are able to put this in our game. Because of this our target performance is around 2 milliseconds, most of that coming from the number of instructions.

【这样足够快了,最终渲染时间在2ms左右】

 
 


 
 

In review we feel that

We have largely achieved our initial goals. This is still a work in progress as there is still time left in the production cycle so we hope to improve performance and direct-ability a bit more. We’re also still working on our atmospheric model and weather system and we will be sharing more about this work in the future on our website and at future conferences.

【回头看我们算是达到了目标,期间最大的问题就是性能处理,我们将继续优化以及将更多的细节分享给大家】

 
 

All of this was captured on a playstation4

And this solution was written in PSSL and C++

 
 


 
 

A number of sources were utilized in the development of this system. I have listed them here.

I would like to thank My co-developer, Nathan vosmost of all

【这里涉及到的资源分享给大家】

 
 

Also some other Guerrillas..

Elco–weather system and general help with transition to games

Michal –supervising the shader development with me and Nathan

Jan Bart, -for keeping us on target with our look goals

Marijn–for allowing me the time in the fxbudget to work on this and for his guidance

Maarten van der Gaagfor some optimization ideas

Felix van den Bergh for slaving away at making polygon clouds and voxel clouds in the early days

Vlad Lapotin, for his work testing out spherical harmonics

And to HermenHulst, manager of Guerrilla for hiring me and for allowing us the resources and time to properly solve this problem for real-time.

 
 


 
 

Are there any questions?

 
 


 
 

Peace out.