F2BPM 开发Api与RESTfull应用服务Api 层次关系及示范

系统架构。
自底向上,设备层、网络层、数据操作层、图总结层、API层、应用层。主题层,设备层、网络层、数据操作层、图统计层。最下层是网络通信层和设施管理层。
网络通信层包括gRPC(google Remote Procedure Call
Protocol)和长距离直接数据存取(Remote Direct Memory
Access,RDMA),分布式总计需要。设备管理层包手包括TensorFlow分别在CPU、GPU、FPGA等设备上的兑现。对上层提供联合接口,上层只需处理卷积等逻辑,不需要关爱硬件上卷积实现过程。
数据操作层包括卷积函数、激活函数等操作。
图总计层包括地面总括图和分布式统计图实现(图创设、编译、优化、执行)。

当下更为多的营业所架构解决方案更加趋向于基于http协议“微服务”访问跨系统调用,而不行使统传的WebService调用,即透过RESTfull形式开展互动,更加轻量整合调用更加有益于。本文档中所有F2BPM开发接口API都可以发布成RESTfull对外应用服务接口

应用层:磨练相关类库、预测相关类库
API层:Python客户端、C++客户端、Java客户端、Go客户端,TensorFlow核心API
图总结层:分布式总括图、本地总括图
多少操作层:Const、Var、Matmul、Conv2D、Relu、Queue
网络层:gPRC、RDMA
设备层:CPU、GPU

图片 1

计划意见。
图定义、图运行完全分离。符号主义。命令式编程(imperative style
programming),遵照编写逻辑顺序执行,易于理解调试。符号式编程(symbolic
style
programming),嵌入、优化,不易精通调试,运行速度快。Torch命令式,Caffe、MXNet混合,TensorFlow完全符号式。符号式统计,先定义各类变量,建立数量流图,规定变量总结关系,编译数据流图,这时还只是空壳,唯有把数量输入,模型才能形成数据流,才有输出值。
TensorFlow运算在数量流图中,图运行只暴发在对话(session)中。开启对话,数据填充节点,运算。关闭对话,无法测算。会话提供操作运行和Tensor求值环境。

RESTfull参数情势

inport tensorflow as tf
#创建图
a = tf.constant([1.0,2.0])
b = tf.constant([3.0,4.0])
c = a * b
#计算c
print sess.run(c)#进展矩阵乘法,输出[3.,8.]
sess.close()

authorJson:紧假设接口地方的验证相关参数,校验访问者的源于合法性

编程模型。
TensorFlow用数据流图做总结。创制数量流图(网络布局图)。TensorFlow运行规律,图中带有输入(input)、塑形(reshape)、Relu层(Relu
layer)、Logit层(Logit layer)、Softmax、交叉熵(cross
entropy)、梯度(gradient)、SGD训练(SGD Trainer),简单回归模型。
算算过程,从输入起先,经过塑形,一层一层前向传播运算。Relu层(隐藏层)有五个参数,Wh1、bh1,输出前用ReLu(Rectified
Linear
Units)激活函数做非线性处理。进入Logit层(输出层),学习五个参数Wsm、bsm。用Softmax总括输出结果各种项目概率分布。用交叉熵度量源样本概率分布和出口结果概率分布之间相似性。统计梯度,需要参数Wh1、bh1、Wsm、bsm、交叉熵结果。SGD磨炼,反向传播,从上往下统计每层参数,依次更新。总结更新顺序,bsm、Wsm、bh1、Wh1。
TensorFlow,张量流动。TensorFlow数据流图由节点(node)、边(edge)组成有向无环图(directed
acycline
graph,DAG)。TensorFlwo由Tensor和Flow两局部构成。Tensor(张量),数据流图的边。Flow(流动),数据流图节点操作。
SGD训练:
Wh1 bh1 Wsm bsm
更新Wh1 更新bh1 更新Wsm 更新bsm
learning)rat=[0.01]
Gradients
交叉熵
classes=[10] 类标记 Softmax
Logit层:
bsm BiasAdd
Wsm MatMul
Relu层:
ReLU
bh1 Bias Add
Wh1 MatMul
塑形shape=[784,1]
输入

parmJson:请求业务数据的参数,比如分页参数,查询参数等

边。数据看重、控制依赖。实线边表示数据看重,代表数量,张量(任意维度的数额)。机器学习算法,张量在数量流图往日将来流动,前向传来(forword
propagation)。残差(实际观看值与训练估量值的差),从后向前流动,反向传播(backword
propagation)。虚线边表示控制倚重(control
dependency),控制操作运行,确保happens-before关系,边上没有多少流过,源节点必须在目的节点起头履行前形成实施。
TensorFlow张量数据属性:
数据类型 Python类型 描述
DT_FLOAT tf.float32 32位浮点型
DT_DOUBLE tf.float64 64位浮点型
DT_INT64 tf.int64 64位有号子整型
DT_INT32 tf.int32 32位有标志整型
DT_INT16 tf.int16 16位有号子整型
DT_INT8 tf.int8 8位有记号整型
DT_UINT8 tf.uint8 8位无符号整型
DT_STRING tf.tring 要变长度字节数组,每一张量元素是一字节数组
DT_BOOL tf.bool 布尔型
DT_COMPLEX64 tf.complex64 七个32位浮点数组成复数,实部、虚部
DT_QINT32 tf.qint32
量化操作32位有号子整型,信号连续取值或大气也许离散取值,近似为简单六个或较少离散值
DT_QINT8 tf.qint8 量化操作8位有标志整型
DT_QUINT8 tf.quint8 量化操作8位无符号整型
图和张量实现源代码:tensorflow-1.1.0/tensorflow/python/framework/ops.py

 

节点。算子。代表一个操作(operation,OP)。表示数学运算,也足以代表数据输入(feed
in)起源和出口(push out)终点,或者读取、写入持久变量(persistent
variable)终点。
操作相关代码位于: tensorflow-1.1.0/tensorflow/python/ops/
TensoFlow实现算子(操作):
类别 示例
数学运算操作 Add、Sub、Mul、Div、Exp、Log、Greater、Less、Equal……
tensorflow-1.1.0/tensorflow/python/ops/math_ops.py,每个函数调用gen_math_ops.py,位于Python库stite-packages/tensorflow/python/ops/gen_math_ops.py
,又调用tensorflow-1.1.0/tensorflow/core/kernels/下核函数实现
数组运算操作 Concat、Slice、Split、Constant、Rank、Shape、Shuffle……
tensorflow-1.1.0/tensorflow/python/ops/array_ops.py,每个函数调用gen_array_ops.py,位于Python库stite-packages/tensorflow/python/ops/gen_array_ops.py
,又调用tensorflow-1.1.0/tensorflow/core/kernels/下核函数实现
矩阵运算操作 MatMul、MatrixInverse、MatrixDeterminant……
有情况操作 Variable、Assign、AssignAdd……
神经网络构建操作 Soft马克斯(Max)、Sigmoid、ReLU、Convolution2D、马克斯(Max)Pool……
检查点操作 Save、Restore
队列和同步操作 Enqueue、Dequeue、MutexAcquire、MutexRelease……
支配张量流动操作 Merge、Switch、Enter、Leave、NextIteration

拥有RESTfull都统一唯有那两个Json参数  

图。操作任务描述成有向无环图。创立各样节点。

 

import tensorflow as tf
#开创一个常量运算操作,爆发一个1×2矩阵
matrix1 = tf.constant([[3.,3.]])
#创建此外一个常量运算操作,暴发一个2×1矩阵
matrix2 = tf.constant([[2.],[2.]])
#创造一个矩阵乘法运算,把matrix1和matrix2作为输入
#再次来到值product代表矩阵乘法结果
product = tf.matmul(matrix2,matrix2)

API开发接口与RestFull API服务发布代码示例

SmartFormRESTfullApi 在线表单的RestFull API服务

package com.f2bpm.controller.restfullapi;

import java.util.List;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import net.sf.json.JSONObject;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import com.f2bpm.base.core.entity.AuthorEntity;
import com.f2bpm.base.core.entity.MyInteger;
import com.f2bpm.base.core.entity.PageParams;
import com.f2bpm.base.core.enums.ExtensionValidateType;
import com.f2bpm.base.core.utils.AppUtil;
import com.f2bpm.base.core.utils.ExtensionValidate;
import com.f2bpm.base.core.utils.FileDownUtil;
import com.f2bpm.base.core.utils.FileUtil;
import com.f2bpm.base.core.utils.JsonHelper;
import com.f2bpm.base.core.utils.string.StringUtil;
import com.f2bpm.base.core.utils.time.DateUtil;
import com.f2bpm.system.admin.impl.model.Users;
import com.f2bpm.system.security.utils.LogUtil;
import com.f2bpm.system.security.web.WebHelper;
import com.f2bpm.workflow.engine.api.entity.WorkflowInstanceContext;
import com.f2bpm.workflow.engine.api.model.TaskInstance;
import com.f2bpm.workflow.engine.api.model.TaskInstanceInfo;
import com.f2bpm.workflow.engine.api.model.WorkflowForm;
import com.f2bpm.workflow.engine.api.wapi.IWorkflowWAPIService;
import com.f2bpm.workflow.engine.helper.WfWebHelper;
import com.f2bpm.workflow.org.api.imodel.IUser;
import com.f2bpm.workflow.org.api.iservice.IUserService;
import com.f2bpm.workflow.smartForm.api.entity.BusObjectData;

/*
 * 在线表单RestFull API服务接口
 */
@Controller
@RequestMapping("/restfullapi/smartForm/")
public class SmartFormRESTfullApi {
    @Resource
    IUserService userService;
    public IWorkflowWAPIService WorkflowAPI = (IWorkflowWAPIService) AppUtil.getBean("WorkflowAPI");

    /**
     * 获取在线表单数据
     * 
     * @param parmJson
     * @param authorJson
     * @param response
     */
    @RequestMapping(value = "getOnlineFormData", method = RequestMethod.POST)
    public void getOnlineFormData(String parmJson, String authorJson, HttpServletResponse response) {
        String jsonResult = "";
        try {
            JSONObject jsonJSONObject = JSONObject.fromObject(parmJson);
            AuthorEntity authorEntity = JsonHelper.jsonToObject(authorJson, AuthorEntity.class);
            String loginAccount = authorEntity.getLoginAccount();
            // 流程实例ID
            String wiid = JsonHelper.getString(jsonJSONObject, "wiid");
            // 表单业务键
            String businessKey = JsonHelper.getString(jsonJSONObject, "businessKey");
            List<BusObjectData> data = WorkflowAPI.getSmartFormApiManager().getBusObjectListData(wiid, businessKey);
            jsonResult = JsonHelper.objectToJSON(data);
        } catch (Exception ex) {
            jsonResult = JsonHelper.outResult(false, ex.toString());
        }
        JsonHelper.write(response, jsonResult);
    }

    /**
     * 获取表单应用定义
     * 
     * @param parmJson
     * @param authorJson
     * @param response
     */
    @RequestMapping(value = "getWorkflowForm", method = RequestMethod.POST)
    public void getWorkflowForm(String parmJson, String authorJson, HttpServletResponse response) {
        String jsonResult = "";
        try {
            JSONObject jsonJSONObject = JSONObject.fromObject(parmJson);
            AuthorEntity authorEntity = JsonHelper.jsonToObject(authorJson, AuthorEntity.class);
            String loginAccount = authorEntity.getLoginAccount();
            String wid = JsonHelper.getString(jsonJSONObject, "wid");
            String appId = JsonHelper.getString(jsonJSONObject, "appId");
            WorkflowForm form = null;
            if (StringUtil.isEmpty(wid)) {
                // 启动时
                form = WorkflowAPI.getProcessDefManager().getWorkflowInfo(appId).getWorkflowFormRunned();
            } else {
                // 运行时
                form = WorkflowAPI.getProcessDefManager().getWorkflowInfo(wid, appId).getWorkflowFormRunned();

            }
            jsonResult = JsonHelper.objectToJSON(form);
        } catch (Exception ex) {
            jsonResult = JsonHelper.outResult(false, ex.toString());
        }
        JsonHelper.write(response, jsonResult);
    }

    /**
     * 获取表单手机端Html模板
     * 
     * @param parmJson wid:启动时可为空
     * @param authorJson
     * @param response
     */
    @RequestMapping(value = "getWorkflowFormMobileHtml", method = RequestMethod.POST)
    public void getWorkflowFormMobileHtml(String parmJson, String authorJson, HttpServletResponse response) {
        String jsonResult = "";
        try {
            JSONObject jsonJSONObject = JSONObject.fromObject(parmJson);
            AuthorEntity authorEntity = JsonHelper.jsonToObject(authorJson, AuthorEntity.class);
            String loginAccount = authorEntity.getLoginAccount();
            String wid = JsonHelper.getString(jsonJSONObject, "wid");//启用时可为空
            String appId = JsonHelper.getString(jsonJSONObject, "appId");
            String html= null;
            if (StringUtil.isEmpty(wid)) {
                // 启动时
                html = WorkflowAPI.getProcessDefManager().getWorkflowInfo(appId).getWorkflowFormRunned().getMobileTemplateContent();
            } else {
                // 运行时
                html = WorkflowAPI.getProcessDefManager().getWorkflowInfo(wid, appId).getWorkflowFormRunned().getMobileTemplateContent();

            }
            jsonResult = html;
        } catch (Exception ex) {
            jsonResult = JsonHelper.outResult(false, ex.toString());
        }
        JsonHelper.write(response, jsonResult);
    }
}

WorkflowBusinessRESTfullApi 流程运行相关的劳务接口

  1 package com.f2bpm.controller.restfullapi;
  2 
  3 import java.io.File;
  4 import java.io.FileInputStream;
  5 import java.io.IOException;
  6 import java.io.InputStream;
  7 import java.io.OutputStream;
  8 import java.util.List;
  9 
 10 import javax.annotation.Resource;
 11 import javax.servlet.http.HttpServletRequest;
 12 import javax.servlet.http.HttpServletResponse;
 13 
 14 import net.sf.json.JSONObject;
 15 
 16 import org.springframework.stereotype.Controller;
 17 import org.springframework.web.bind.annotation.RequestMapping;
 18 import org.springframework.web.bind.annotation.RequestMethod;
 19 import org.springframework.web.bind.annotation.ResponseBody;
 20 import org.springframework.web.multipart.MultipartFile;
 21 import org.springframework.web.multipart.MultipartHttpServletRequest;
 22 
 23 import com.f2bpm.base.core.entity.AuthorEntity;
 24 import com.f2bpm.base.core.entity.MyInteger;
 25 import com.f2bpm.base.core.entity.PageParams;
 26 import com.f2bpm.base.core.enums.ExtensionValidateType;
 27 import com.f2bpm.base.core.utils.AppUtil;
 28 import com.f2bpm.base.core.utils.ExtensionValidate;
 29 import com.f2bpm.base.core.utils.FileDownUtil;
 30 import com.f2bpm.base.core.utils.FileUtil;
 31 import com.f2bpm.base.core.utils.JsonHelper;
 32 import com.f2bpm.base.core.utils.string.StringUtil;
 33 import com.f2bpm.base.core.utils.time.DateUtil;
 34 import com.f2bpm.system.admin.impl.model.Users;
 35 import com.f2bpm.system.security.utils.LogUtil;
 36 import com.f2bpm.system.security.web.WebHelper;
 37 import com.f2bpm.workflow.engine.api.entity.WorkflowInstanceContext;
 38 import com.f2bpm.workflow.engine.api.model.ActivityInfo;
 39 import com.f2bpm.workflow.engine.api.model.TaskInstance;
 40 import com.f2bpm.workflow.engine.api.model.TaskInstanceInfo;
 41 import com.f2bpm.workflow.engine.api.wapi.IWorkflowWAPIService;
 42 import com.f2bpm.workflow.engine.helper.WfWebHelper;
 43 import com.f2bpm.workflow.org.api.imodel.IUser;
 44 import com.f2bpm.workflow.org.api.iservice.IUserService;
 45 /*
 46  * 流程运行相关 RestFull API服务接口
 47  */
 48 @Controller
 49 @RequestMapping("/restfullapi/workflowBusiness/")
 50 public class WorkflowBusinessRESTfullApi {
 51     @Resource
 52     IUserService userService;
 53 
 54     public IWorkflowWAPIService WorkflowAPI = (IWorkflowWAPIService) AppUtil.getBean("WorkflowAPI");
 55 
 56     /**
 57      * 查找任务实例
 58      * @param id
 59      * @param request
 60      * @param response
 61      * @return
 62      * @throws IOException
 63      */
 64     @ResponseBody
 65     @RequestMapping(value = "getTask", method = RequestMethod.GET)
 66     public TaskInstance getTask(String id, HttpServletRequest request, HttpServletResponse response) throws IOException {
 67         TaskInstance task = new TaskInstance();
 68         id = "031d2404-94d1-4566-8ade-21126b620904";
 69         task = WorkflowAPI.getWorkTaskManager().getTaskInstanceByTaskId(id);
 70         return task;
 71     }
 72 
 73     /**
 74      *  获取待办列表
 75      * @param authorJson
 76      * @param parmJson
 77      * @param request
 78      * @param response
 79      * @throws Exception
 80      */
 81     @RequestMapping(value = "getTodoList", method = RequestMethod.GET)
 82     public void getTodoList(String authorJson, String parmJson, HttpServletRequest request, HttpServletResponse response) throws Exception {
 83         JSONObject jsonJSONObject = JSONObject.fromObject(parmJson);
 84         PageParams pageParams = JsonHelper.jsonToObject(parmJson, PageParams.class);
 85         AuthorEntity authorEntity = JsonHelper.jsonToObject(authorJson, AuthorEntity.class);
 86         String loginAccount = authorEntity.getLoginAccount();
 87         MyInteger recordCount = new MyInteger(0);
 88         MyInteger pageCount = new MyInteger(0);
 89         String whereStr = JsonHelper.getString(jsonJSONObject, "whereStr");
 90         IUser user = userService.getUserByAccount(loginAccount);
 91         List<TaskInstanceInfo> list = WorkflowAPI.getWorkTaskManager().getTodoList(user.getUserId(), whereStr.toString(), pageParams.getOrderBy(), pageParams.getPageIndex(), pageParams.getPageSize(), pageCount, recordCount, true);
 92         String jsonString = JsonHelper.listToJSON(list);
 93         String jsonResult = JsonHelper.convertToEasyUIJsonResult(jsonString, pageParams.getPageSize(), pageParams.getPageIndex(), recordCount.getValue(), pageCount.getValue());
 94         JsonHelper.write(response, jsonResult);
 95     }
 96 
 97     /**
 98      *  已办列表
 99      * @param authorJson
100      * @param parmJson
101      * @param request
102      * @param response
103      * @throws Exception
104      */
105     @RequestMapping(value = "getDoneList", method = RequestMethod.POST)
106     public void getDoneList(String authorJson, String parmJson, HttpServletRequest request, HttpServletResponse response) throws Exception {
107         JSONObject jsonJSONObject = JSONObject.fromObject(parmJson);
108         PageParams pageParams = JsonHelper.jsonToObject(parmJson, PageParams.class);
109         AuthorEntity authorEntity = JsonHelper.jsonToObject(authorJson, AuthorEntity.class);
110         String loginAccount = authorEntity.getLoginAccount();
111         MyInteger recordCount = new MyInteger(0);
112         MyInteger pageCount = new MyInteger(0);
113         String whereStr = JsonHelper.getString(jsonJSONObject, "whereStr");
114         int isHistory = JsonHelper.getInt(jsonJSONObject, "isHistory");
115         IUser user = userService.getUserByAccount(loginAccount);
116         List<TaskInstanceInfo> list = null;
117         if (isHistory == 1) {
118             // 归档中的列表
119             list = WorkflowAPI.getHistoryDataManager().getHistoryDoneList(user.getUserId(), whereStr.toString(), pageParams.getOrderBy(), pageParams.getPageIndex(), pageParams.getPageSize(), pageCount, recordCount, true);
120         } else {
121             // 进行中的已办
122             list = WorkflowAPI.getWorkTaskManager().getDoneList(user.getUserId(), whereStr.toString(), pageParams.getOrderBy(), pageParams.getPageIndex(), pageParams.getPageSize(), pageCount, recordCount, true);
123         }
124 
125         String jsonString = JsonHelper.listToJSON(list);
126         String jsonResult = JsonHelper.convertToEasyUIJsonResult(jsonString, pageParams.getPageSize(), pageParams.getPageIndex(), recordCount.getValue(), pageCount.getValue());
127         JsonHelper.write(response, jsonResult);
128     }
129 
130     /**
131      * 响应发起流程
132      * @param authorJson
133      * @param parmJson
134      * @param request
135      * @param response
136      * @throws IOException
137      */
138     @RequestMapping(value = "startWorkflow", method = RequestMethod.POST)
139     public void startWorkflow(String authorJson, String parmJson, HttpServletRequest request, HttpServletResponse response) throws IOException {
140         JSONObject jsonJSONObject = JSONObject.fromObject(parmJson);
141         AuthorEntity authorEntity = JsonHelper.jsonToObject(authorJson, AuthorEntity.class);
142         String loginAccount = authorEntity.getLoginAccount();
143         // IUser user = userService.getUserByAccount(loginAccount);
144         String appId = JsonHelper.getString(jsonJSONObject, "appId");
145         String wiid = JsonHelper.getString(jsonJSONObject, "wiid");
146         String businessKey = JsonHelper.getString(jsonJSONObject, "businessKey");
147         String title = JsonHelper.getString(jsonJSONObject, "title");
148         String opinion = JsonHelper.getString(jsonJSONObject, "opinion");
149         String jsonFormData = JsonHelper.getString(jsonJSONObject, "jsonFormData");
150         StringBuilder message = new StringBuilder();
151         boolean success = WorkflowAPI.getWorkflowEnactmentManager().startWorkflow(appId, wiid, businessKey, title, opinion, loginAccount, null, message, jsonFormData, null, 0, 0);
152         String jsonResult = JsonHelper.outResult(success, message.toString());
153         JsonHelper.write(response, jsonResult);
154     }
155 
156     /**
157      *  驳回流程
158      * @param parmJson
159      * @param authorJson
160      * @param response
161      */
162     @RequestMapping(value = "rejectFlow", method = RequestMethod.POST)
163     public void rejectFlow(String parmJson, String authorJson, HttpServletResponse response) {
164         JSONObject jsonJSONObject = JSONObject.fromObject(parmJson);
165         AuthorEntity authorEntity = JsonHelper.jsonToObject(authorJson, AuthorEntity.class);
166         String loginAccount = authorEntity.getLoginAccount();
167         String taskId = JsonHelper.getString(jsonJSONObject, "taskId");
168         String opinion = JsonHelper.getString(jsonJSONObject, "opinion");
169         StringBuilder message = new StringBuilder();
170         boolean success = WorkflowAPI.getWorkflowEnactmentManager().rejectWorkflow(taskId, loginAccount, opinion, true, null, message);
171         String jsonResult = JsonHelper.outResult(success, message.toString());
172         JsonHelper.write(response, jsonResult);
173     }
174 
175     /**
176      * 作废流程实例
177      * 
178      * @param parmJson
179      * @param authorJson
180      * @param response
181      */
182     @RequestMapping(value = "invalidFlow", method = RequestMethod.POST)
183     public void invalidFlow(String parmJson, String authorJson, HttpServletResponse response) {
184         JSONObject jsonJSONObject = JSONObject.fromObject(parmJson);
185         AuthorEntity authorEntity = JsonHelper.jsonToObject(authorJson, AuthorEntity.class);
186         String loginAccount = authorEntity.getLoginAccount();
187         String taskId = JsonHelper.getString(jsonJSONObject, "taskId");
188         String opinion = JsonHelper.getString(jsonJSONObject, "opinion");
189         TaskInstance taskInstance = WorkflowAPI.getWorkTaskManager().getTaskInstanceByTaskId(taskId);
190         String wiid = taskInstance.getWorkflowInstanceId();
191         StringBuilder message = new StringBuilder();
192         IUser user = WorkflowAPI.getOrgEngineManager().getUserService().getUserByAccount(loginAccount);
193         boolean success = WorkflowAPI.getWorkflowEnactmentManager().invalidWorkflowInstance(wiid, opinion, user);
194         String jsonResult = JsonHelper.outResult(success, message.toString());
195         JsonHelper.write(response, jsonResult);
196     }
197 
198 
199     
200     /**
201      * 审批执行代办任务
202      * @param authorJson
203      * @param parmJson
204      * @param response
205      */
206     @RequestMapping(value = "approvalTask", method = RequestMethod.POST)
207     public void approvalTask(String authorJson, String parmJson, HttpServletResponse response) {
208         JSONObject jsonJSONObject = JSONObject.fromObject(parmJson);
209         AuthorEntity authorEntity = JsonHelper.jsonToObject(authorJson, AuthorEntity.class);
210         String loginAccount = authorEntity.getLoginAccount();
211         String taskId = JsonHelper.getString(jsonJSONObject, "taskId");
212         String opinion = JsonHelper.getString(jsonJSONObject, "opinion");
213         StringBuilder message = new StringBuilder();
214         boolean success = WorkflowAPI.getWorkflowEnactmentManager().sendWorkflowByTaskId(taskId, loginAccount, opinion, message);
215         String jsonResult = JsonHelper.outResult(success, message.toString());
216         JsonHelper.write(response, jsonResult);
217     }
218 
219     /**
220      * 获取任务指定节点的供选择人(计算出节点参与者)
221      * @param authorJson
222      * @param parmJson
223      * @param response
224      */
225     @RequestMapping(value = "getActivityUsers", method = RequestMethod.POST)
226     public void getActivityUsers(String authorJson, String parmJson, HttpServletResponse response) {
227         JSONObject jsonJSONObject = JSONObject.fromObject(parmJson);
228         AuthorEntity authorEntity = JsonHelper.jsonToObject(authorJson, AuthorEntity.class);
229         String loginAccount = authorEntity.getLoginAccount();
230         String taskId = JsonHelper.getString(jsonJSONObject, "taskId");
231         String activityId = JsonHelper.getString(jsonJSONObject, "activityId");
232         StringBuilder message = new StringBuilder();
233         WorkflowInstanceContext wfContext=WorkflowAPI.getWorkflowEnactmentManager().getWorkflowInstanceContextOnTodo(taskId, loginAccount);
234         TaskInstance  task = WorkflowAPI.getWorkTaskManager().getTaskInstanceByTaskId(taskId);
235         ActivityInfo activityInfo=WorkflowAPI.getProcessDefManager().getActivityInfo(task.getWorkflowId(), activityId);
236         List<IUser> list= WorkflowAPI.getWorkflowEnactmentManager().getListActorUserResultByActivityInfo(wfContext,activityInfo);
237         String jsonResult =JsonHelper.objectToJSON(list);
238         JsonHelper.write(response, jsonResult);
239     }
240     
241     /**
242      * 上传在线表单附件 上传在线表单附件, 返回字段值单个附件值,表单附件的字段值格式:
243      * [{filePathName:"/attachments/workflow/files/20170714215409547.txt"
244      * ,fileName:"TestClient.txt"}]
245      * 
246      * @param request
247      * @param response
248      */
249     @RequestMapping("uploadFile")
250     public void uploadFile(HttpServletRequest request, HttpServletResponse response) {
251         String jsonResult = "";
252         MultipartHttpServletRequest mRequest = (MultipartHttpServletRequest) request;
253         MultipartFile fileUpload = mRequest.getFile("FileUpload");
254         if (!fileUpload.isEmpty()) {
255 
256             try {
257                 String uploadType = WfWebHelper.query("UploadType", "");
258 
259                 String path = FileDownUtil.getWorkflowFilePath();
260                 String uploadFileName = fileUpload.getOriginalFilename();
261                 String fileExtension = uploadFileName.substring(uploadFileName.lastIndexOf("."));
262 
263                 if (!StringUtil.isNullOrWhiteSpace(uploadType)) {
264                     path = path + uploadType + "/";
265                     if (!FileUtil.isExistDirectory(path)) {
266                         FileUtil.createFolder(path);
267                     }
268                 }
269 
270                 if (!ExtensionValidate.validateExtension(fileExtension, ExtensionValidateType.FileExtension)) {
271                     jsonResult = JsonHelper.outResult(false, fileExtension + ",文件类型不允许上传!");
272                     JsonHelper.write(response, jsonResult);
273                     return;
274                 }
275                 uploadFileName = DateUtil.getCurrentDateTime("yyyyMMddHHmmssSSS") + fileExtension;
276                 String filePathName = path + uploadFileName;
277                 if (FileUtil.isExistFile(filePathName)) {
278                     FileUtil.deleteFile(filePathName);
279                 }
280                 File filePath = new File(filePathName);// 上传地址
281                 fileUpload.transferTo(filePath);
282 
283                 int index = filePathName.indexOf("attachments");
284                 String downfielNamePath = filePathName.substring(index);
285                 jsonResult = JsonHelper.outResult(true, "{filePathName:\"/" + downfielNamePath + "\",fileName:\"" + fileUpload.getOriginalFilename() + "\"}");
286 
287             } catch (RuntimeException | IOException ex) {
288                 jsonResult = JsonHelper.outResult(false, "上传失败");
289                 LogUtil.writeLog(ex.toString());
290             }
291         } else {
292             jsonResult = JsonHelper.outResult(false, "请选择要上传的文件");
293         }
294         JsonHelper.write(response, jsonResult);
295     }
296 
297     /**
298      * 附件下载
299      * @param authorJson
300      * @param parmJson
301      * @param request
302      * @param response
303      */
304     @RequestMapping("downloadFile")
305     public void downloadFile(String authorJson, String parmJson, HttpServletRequest request, HttpServletResponse response) {
306         try {
307             JSONObject jsonJSONObject = JSONObject.fromObject(parmJson);
308             AuthorEntity authorEntity = JsonHelper.jsonToObject(authorJson, AuthorEntity.class);
309             // String fileName = JsonHelper.getString(jsonJSONObject,
310             // "fileName");
311             String filePath = JsonHelper.getString(jsonJSONObject, "filePath");
312             String path = AppUtil.getWebRootPath() + filePath;
313             String fileName = new String(path.getBytes("iso8859-1"), "UTF-8");
314             File file = new File(fileName);
315             if (!file.exists()) {
316                 response.setStatus(404);
317                 String jsonResult = JsonHelper.outResult(false, "404 file not found!");
318                 JsonHelper.write(response, jsonResult);
319                 return;
320             }
321             // response.setCharacterEncoding("utf-8");
322             // response.setContentType("multipart/form-data");
323             // response.setHeader("Content-Disposition", "attachment;fileName="
324             // + fileName);
325             InputStream inputStream = new FileInputStream(file);
326             OutputStream os = response.getOutputStream();
327             byte[] b = new byte[1024];
328             int length;
329             while ((length = inputStream.read(b)) > 0) {
330                 os.write(b, 0, length);
331             }
332             inputStream.close();
333         } catch (Exception ex) {
334             LogUtil.writeLog(ex.toString());
335             response.setStatus(500);
336             ex.printStackTrace();
337             String jsonResult = JsonHelper.outResult(false, "500 err "+ex.getMessage());
338             JsonHelper.write(response, jsonResult);
339         }
340     }
341 }

客户端调用示例

  1 package com.f2bpm.restfullapi;
  2 
  3 import java.util.HashMap;
  4 import java.util.Map;
  5 
  6 import org.apache.http.client.HttpClient;
  7 import org.apache.http.client.methods.HttpPost;
  8 import org.apache.http.impl.client.DefaultHttpClient;
  9 
 10 import com.f2bpm.base.core.utils.Guid;
 11 import com.f2bpm.base.core.utils.HttpClientUtil;
 12 import com.f2bpm.base.core.utils.string.StringUtil;
 13 
 14 public class WorkflowBusinessTestClient {
 15 
 16     String webApiUrl = "http://localhost:8081/f2bpm/restfullapi";
 17     
 18     /**
 19      * get请求 get只适合参数相对简单的请求,如果参数过长或参数字符复杂,则使用Post 来传参请求
 20      * 这里仅是一个get示例,不建议使用get统一使用Post来做 不建议使用get统一使用Post来做 不建议使用get统一使用Post来做
 21      * 不建议使用get统一使用Post来做
 22      */
 23     public void getTask() {
 24         String url = webApiUrl + "/workflowBusiness/getTask?";
 25         String queryString="id=123";
 26         String param = HttpClientUtil.urlEncode(queryString.toString()); // 特殊字符进行转义
 27         url = url + param;
 28         String jsonRes = HttpClientUtil.get(url);
 29         System.out.println(jsonRes);
 30     }
 31 
 32 
 33 //    public void getTodoList() {
 34 //        String urlString = webApiUrl + "/workflowBusiness/getTodoList/?";
 35 //        StringBuilder queryString = new StringBuilder();
 36 //        queryString.append(StringUtil.format("authorJson={loginAccount:\"{0}\"}", "admin"));
 37 //        queryString.append(StringUtil.format("&parmJson={pageIndex:{0},pageSize:{1},sort:\"{2}\",order:\"{3}\"}", 1, 2, "CreatedTime", "desc"));
 38 //        String param = HttpClientUtil.urlEncode(queryString.toString()); // 特殊字符进行转义
 39 //        urlString = urlString + param;
 40 //        String jsonRes = HttpClientUtil.get(urlString);
 41 //        System.out.println(jsonRes);
 42 //    }
 43     
 44     /**
 45      * 获取待办列表
 46      */
 47     public void getTodoList() {
 48         String  url= webApiUrl + "/workflowBusiness/getTodoList/";
 49         Map<String, String> params = new HashMap<String, String>();
 50         StringBuilder queryString = new StringBuilder();
 51         params.put("authorJson", StringUtil.format("{loginAccount:\"{0}\"}", "admin"));
 52         params.put("parmJson", StringUtil.format("{pageIndex:{0},pageSize:{1},sort:\"{2}\",order:\"{3}\",whereStr:\"{4}\",}", 1, 2, "CreatedTime", "desc", ""));
 53         String jsonRes = HttpClientUtil.post(url, params);
 54         System.out.println(jsonRes);
 55     }
 56     /**
 57      * 获取已办列表
 58      */
 59     public void getDoneList() {
 60         String urlString = webApiUrl + "/workflowBusiness/getDoneList/";
 61         Map<String, String> params = new HashMap<String, String>();
 62         StringBuilder queryString = new StringBuilder();
 63         params.put("authorJson", StringUtil.format("{loginAccount:\"{0}\"}", "admin"));
 64         // isHistory:0 进行中的已办,isHistory:1流程已结束并归档的已办
 65         params.put("parmJson", StringUtil.format("{isHistory:0,pageIndex:{0},pageSize:{1},sort:\"{2}\",order:\"{3}\",whereStr:\"{4}\",}", 1, 2, "CreatedTime", "desc", ""));
 66         String jsonRes = HttpClientUtil.post(urlString, params);
 67         System.out.println(jsonRes);
 68     }
 69 
 70     /**
 71      * 发起流程
 72      */
 73     public void startWorkflow() {
 74         String urlString = webApiUrl + "/workflowBusiness/startWorkflow/";
 75         Map<String, String> params = new HashMap<String, String>();
 76         String onlineFormData = StringUtil.format("[{\"mainTable\":\"csb\",\"data\":[{\"name\":\"csb.nl\",\"value\":\"22\"},{\"name\":\"csb.MyId\",\"value\":\"\"},{\"name\":\"csb.zz\",\"value\":\"RestFull测试\"},{\"name\":\"csb.xm\",\"value\":\"RestFull姓名\"}],\"subTables\":[]}]");
 77         params.put("authorJson", StringUtil.format("{loginAccount:\"{0}\"}", "admin"));
 78         params.put("parmJson", StringUtil.format("{appId:\"{0}\",wiid:\"{1}\",businessKey:\"{2}\",title:\"{3}\",opinion:\"{4}\",jsonFormData:{5}}", "ZX", Guid.getGuid(), Guid.getGuid(), "应用端RestFull请求测试", "同意", onlineFormData));
 79         // String param = HttpClientUtil.urlEncode(queryString.toString());
 80         // //特殊字符进行转义
 81         String jsonRes = HttpClientUtil.post(urlString, params);
 82         System.out.println(jsonRes);
 83     }
 84 
 85     /**
 86      * 驳回到提单
 87      */
 88     public void rejectFlow() {
 89         String urlString = webApiUrl + "/workflowBusiness/rejectFlow/";
 90         Map<String, String> params = new HashMap<String, String>();
 91         params.put("authorJson", StringUtil.format("{loginAccount:\"{0}\"}", "admin"));
 92         params.put("parmJson", StringUtil.format("{taskId:\"{0}\",opinion:\"{1}\"}", "d212c718-b6ea-481e-b7cc-1f44a9d47fd0", "驳回"));
 93         String jsonRes = HttpClientUtil.post(urlString, params);
 94         System.out.println(jsonRes);
 95     }
 96 
 97     /**
 98      * 作废工单
 99      */
100     public void invalidFlow() {
101         String urlString = webApiUrl + "/workflowBusiness/invalidFlow/";
102         Map<String, String> params = new HashMap<String, String>();
103         params.put("authorJson", StringUtil.format("{loginAccount:\"{0}\"}", "admin"));
104         params.put("parmJson", StringUtil.format("{taskId:\"{0}\",opinion:\"{1}\"}", "eac4e893-822c-46ec-9ba6-a1c028a1cef3", "作废"));
105         String jsonRes = HttpClientUtil.post(urlString, params);
106         System.out.println(jsonRes);
107     }
108 
109     /**
110      * 审批执行代办任务
111      */
112     public void approvalTask() {
113         String urlString = webApiUrl + "/workflowBusiness/approvalTask/";
114         Map<String, String> params = new HashMap<String, String>();
115         params.put("authorJson", StringUtil.format("{loginAccount:\"{0}\"}", "admin"));
116         params.put("parmJson", StringUtil.format("{taskId:\"{0}\",opinion:\"{1}\"}", "5f267057-ddd4-470a-bca4-a797caac3e09", "原则同意"));
117         String jsonRes = HttpClientUtil.post(urlString, params);
118         System.out.println(jsonRes);
119     }
120 
121 
122     /**
123      *上传在线表单附件,返回字段值单个附件值
124     /表单附件的字段值格式:
125     /#[{"value":"/attachments/workflow/files/20170714215204767.txt","text":"TestClient.txt"}]#
126     */
127     public void uploadFormFile() {
128         String urlString = webApiUrl + "/workflowBusiness/uploadFile/?loginAccount=admin";
129         String filepath = "C:\\Users\\Administrator\\Desktop\\TestClient.txt";
130         String jsonRes = HttpClientUtil.postFile(urlString, filepath);
131         System.out.println(jsonRes);
132     }
133     /**
134      * 下载表单附件
135      */
136     public void downLoadFile() {
137         String urlString = webApiUrl + "/workflowBusiness/downloadFile/";
138         //保存到本地的地址
139         String filepath = "C:\\Users\\Administrator\\Desktop\\TestClient.txt";
140         
141         Map<String, String> params = new HashMap<String, String>();
142         params.put("authorJson", StringUtil.format("{login Account:\"{0}\"}", "admin"));
143         params.put("parmJson", StringUtil.format("{filePath:\"{0}\"}", "/attachments/workflow/files/20170714215204767.txt"));
144         String jsonRes = HttpClientUtil.downLoadFile(urlString,filepath, params);
145         System.out.println(jsonRes);
146         
147     }
148     
149     public static void main(String[] args) {
150         WorkflowBusinessTestClient client = new WorkflowBusinessTestClient();
151         client.downLoadFile();
152         System.out.print("结束");
153     }
154 
155 }

 

对话。启动图第一步创设一个Session对象。会话(session)提供图实施操作方法。建立会话,生成一张空图,会话添加节点和边,形成图,执行。tf.Session类创造并运行操作。

with tf.Session as sess:
result = sess.run([product])
print result
调用Session对象run()方法执行图,传入Tensor,填充(feed)。重回结果类型遵照输入类型而定,取回(fetch)。
对话是图交互桥梁,一个会话可以有四个图,会话可以修改图结构,可以往图流入数据统计。会话多少个API:Extend(图添加节点、边)、Run(输入统计节点和和填充必要数据,运算,输出运算结果)。
会话源代码: tensorflow-1.1.0/tensorflow/python/client/session.py

设备(device)。一块用作运算、拥有自己地址空间的硬件。CPU、GPU。TensorFlow可以提定操作在哪些设备进行。with
tf.device(“/gpu:1”): 。

变量(variable)。特殊数据。图中有一定地点,不流动。tf.Variable()构造函数。初阶值形状、类型。

#创立一个变量,起首化为标量0
state = tf.Variable(0,name=”counter”)
创设常量张量:

state = tf.constant(3.0)
填充机制。构建图用tf.placeholder()临时替代任意操作张量,调用Session对象run()方法执行图,用填充数据作参数。调用结束,填充数据没有。

input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
output = tf.mul(input1,input2)
with tf.Session() as sess:
#输出[array([24.],dtype=float32)]
print sess.run([output],feed_dict={input1:[7.],input2:[2.]})
变量源代码: tensorflow-1.1.0/tensorflow/python/ops/variables.py

基本。操作(operation),抽象操作统称。内核(kernel),运行在一定设备(CPU、GPU)上操作的实现。同一操作可能对应四个基本。自定义操作,新操作和基础注册添加到系统。

常用API。
图。TensorFlow总结表现为多少流图。tf.Graph类包含一名目繁多统计操作对象(tf.Operation)和操作间流动数量张量对象(tf.Tensor)。
操作 描述
tf.Graph.__init__() 创制一个空图
tf.Graph.as_default()将某图设置为默认图,重返一个上下文管理器。不展现添加默认图,系统自动安装全局默认图。模块范围内定义节点都插手默认图
tf.Graph.device(device_name_or_function)
定义运行图所接纳设备,重临上下文管理器
tf.Graph.name_scope(name) 为节点创立层次化名称,重回上下方管理器

tf.Operaiotn类代表图中节点,用于总括张量数据。由节点构造器(如tf.matmul()、Graph.create_op())产生。
操作 描述
tf.Operation.name 操作名称
tf.Operation.type 操作类型
tf.Operation.inputs 操作输入
tf.Operation.outputs 操作输出
tf.Operation.control_inputs 操作依赖
tf.Operation.run(feed_dict=None,session=None) 在对话中运行操作
tf.Operation.get_attr(name) 获取操作属性值

tf.Tensor类,操作输出符号句柄,不含有操作输出值,提供在tf.Session中总括值方法。操作间构建数据流连接,TensorFlow能免执行大气步多划算图形。
操作 描述
tf.Tensor.dtype 张量数据类型
tf.Tensor.name 张量名称
tf.Tensor.value_index 张量操作输出索引
tf.Tensor.graph 张量所在图
tf.Tensor.op 发生张量操作
tf.Tensor.consumers() 重返使用张量操作列表
tf.Tensor.eval(feed_dict=None,session=None)
会话中求张量值,使用sess.as_default()、eval(session=sess)
tf.Tensor.get_shape() 再次回到表示张量形状(维度)类TensorShape
tf.Tensor.set_shape(shape) 更新张量形状
tf.Tensor.device 设置总计张量设备

可视化。
在先后中给节点添加摘要(summary),摘要收集节点数据,标记步数、时间戳标识,写入事件文件(event
file)。tf.summary.FileWriter类在目录创造事件文件,向文件添加摘要、事件,在TensorBoard显示。
操作 描述
tf.summary.FileWriter.__init__(logdir,graph=None,max_queue=10,
flush_secs=120,graph_def=None)
创设FileWriter和事件文件,logdir中开革新事件文件
tf.summary.FileWriter.add_summary(summary,global_step=None)
摘要添加到事件文件
tf.summary.FileWriter.add_event(event) 事件文件添加事件
tf.summary.FileWriter.add_graph(graph,global_step=None,graph_def=None)
事件文件添加图
tf.summary.FileWriter.get_logdir() 事件文件路径
tf.summary.FileWriter.flush() 所有事件上写入磁盘
tf.summary.FileWriter.close() 事件写入磁盘,关闭文件操作符
tf.summary.scalar(name,tensor,collections=None) 输出单个标量值摘要
tf.summary.histogram(name,values,collections=None) 输出直方图摘要
tf.summary.audio(name,tensor,sample_rate,max_outputs=3,collections=None)
输出音频摘要
tf.summary.image(name,tensor,max_outputs=3,collections=None)
输出图片摘要
tf.summary.merge(inputs,collections=None,name=None)
合并摘要,所有输入摘要值

变量功能域。
TensorFlow五个效能域(scope),name_scope(给op_name加前缀),variable_scope(给variable_name、op_name加前缀)。
variable_scope变量成效域机制:
v =
tf.get_variable(name,shape,dtype,initializer)#经过名字创办或回到变量
tf.variable_scope(<scope_name>)#给变量指定命名空间
tf.get_variable_scope().reuse==False(默认为False,不可能得用),variable_scope功用域只好创制新变量。tf.get_variable_scope().reuse==True,功用域共享变量,with
tf.variable_scope(name,reuse=True),或scope.reuse_variables()。
tf.variable_scope()获取变量功用域。开户变量功能域使用以前先行定义成效域,跳过当前变量功用域,保持预先存在效率域不变。
变量效用域可以默认指导一个起首化器。子效用域或变量可以持续或重写父功能域初叶化器值。
op_name在variable_scope效能域操作,会增长前缀。
variable_scope重要用在循环神经网络(RNN)操作,大量共享变量。
name_scope。划分变量范围,可视化中象征在总括图一个层级。name_scope影响op_name,不影响用get_variable()创造变量。影响用Variable()创立变量。给操作加名字前缀。

批标准化。batch normalization,BN。优化梯度弥散问题(vanishing gradient
problem)。
总括机器学习,ICS(Internal Covariate Shift)理论,源域(source
domain)和目的域(target
domain)数据分布一致。训练多少和测试数据知足相同分布。是通过磨炼多少拿到模型在测试集拿到好效益的基本保障。Covariate
Shift,训练集样本数据和对象集分布不一致,练习模型无法很好泛化(generalization)。源域和目的域条件概率一样,边缘概率不同。神经网络各层输出,经层内操作,各层输出分布与输入信号分布不同,差距随网络加深变大,但每层指向样本标记(label)不变。解决,依照操练样本和目的样本比例矫正训练样本。引入批标准化规范化层输入(数据按百分比缩放,落入小特定区间,数据去平均值,除以标准差),固定每层输入信号均值、方差。
形式。批标准化通过规范化激活函数分布在线性区间,加大梯度,模型梯度下降。加大追究步长,加快收敛速度。更易于跳出局部最小值。破坏原数据分布,缓解过拟合。解决神经网络收敛速度慢或梯度爆炸(gradient
explode,梯度分外大,链式求导乘积变得很大,权重过大,发生指数级爆炸)。

#计算Wx_plus_b均值方差,axes=[0]规格维度
fc_mean,fc_var = tf.nn.moments(Wx_plus_b, axes=[0])
scale = tf.Variable(tf.ones([out_size]))
shift = tf.Variable(tf.zeros([out_size]))
epsilon = 0.001
Wx_plus_b =
tf.nn.batch.normalization(Wx_plus_b,fc_mean,fc_var,shift,scale,epsilon)
#Wx_plus_b = (Wx_plus_b – fc_mean) / tf.sqrt(fc_var + 0.001)
#Wx_plus_b = Wx_plus_b * scale + shift
《Batch Normalization:Accelerating Deep Network Training by Reducing
Internal Covariate Shift》,Serger Ioffe、Christian Szegedy。

神经元函数优化措施。

激活函数。activation
function,运行时激活神经网络某有些神经元,激活信息向后传出下层神经网络。出席非线性因素,弥补线性模型表明力,把“激活神经元特征”通过函数保留映射到下层。神经网络数学基础处处可微,选择激活函数保证输入输出可微。激活函数不改动输入数据维度,输入输出维度相同。TensorFlow激活函数定义在tensorflow-1.1.0/tensorflow/python/ops/nn.py。tf.nn.relu()、tf.nn.sigmoid()、tf.nn.tanh()、tf.nn.elu()、tf.nn.bias_add()、tf.nn.crelu()、tf.nn.relu6()、tf.nn.softplus()、tf.nn.softsign()、tf.nn.dropout()。输入张量,输出与输入张量数据类型相同张量。
sigmoid函数。输出映射在(0,1)内,单调连续,适合作输出层,求导容易。软饱和性,输入落入饱和区,f'(x)变得接近0,容易暴发梯度消失。软饱和,激活函数h(x)取值趋于无穷大时,一阶导数趋于0。硬饱和,当|x|>c,c为常数,f'(x)=0。relu左侧硬饱和激活函数。梯度消失,更新模型参数,采用链式求导法则反向求导,越往前梯度越小。最终结出到达一定深度后梯度对模型更新没有任何贡献。
tanh函数。软饱和性,输出0为骨干,收敛速度比sigmoid快。也无从解决梯度消失。
relu函数。最受欢迎。softplus是ReLU平滑版本。relu,f(x)=max(x,0)。softplus,
f(x)=log(1+exp(x))。relu在x<0时硬饱和。x>0,导数为1,relu在x>0时保障梯度不衰减,缓解梯度消失,更快收敛,提供神经网络稀疏表明能力。部分输入落到硬饱和区,权重不可能改进,神经元死亡。TensorFlow
relu6,min(max(features,0))
,tf.nn.relu6(features,name=None)。crelu,tf.nn.crelu(features,name=None)

dropout函数。神经元以概率keep_prob决定是否被扼杀。要是被扼杀,神经元就输出0,否则输出被平放原来的1/keep_prob倍。神经元是否被遏制,默认互相独立。noise_shape调节,noise_shape[i]==shape(x)[i],x中元素相互独立。shape(x)=[k,l,m,n],x维度顺序批、行、列、通道。noise_shape=[k,1,1,n],批、通道相互独立,行、列数据涉嫌,都为0,或原值。散文中最早做法,练习中概率p放弃。预测中,参数按比例收缩,乘p。框架实现,反向ropout代替dropout,磨炼中一头dropout,再按比例放大,即乘以1/p,预测中不做此外处理。
激活函数采用。输入数据特征相差显然,用tanh,循环过程不断扩展特征效果显示。特征相差不显眼,用sigmoid。sigmoid、tanh,需要输入规范化,否则激活后值全体进入平坦区,隐层输出全体趋同,丧失原有风味表明。relu会好广大,有时可以不做输入规范化。85%-90%神经网络都用ReLU。10-15%用tanh。

卷积函数。图像扫描二维过滤器。卷积函数定义,tensorflow-1.1.0/tensorflow/python/ops/nn_impl.py、nn_ops.py

tf.nn.convolution(input,filter,padding,strides=None,dilation_rate=None,
name=None,data_format=None) 统计N维卷积和。
tf.conv2d(input,filter,strides,padding,use_cudnn_on_gpu=None,data_format=None,name=None),四维输入数据ipnut和四维卷积核filter操作,输入数据二维卷积操作,得到卷积结果。input,Tensor,数据类型floate32、floate64。filter,Tensor,数据类型floate32、floate64。strides:长度4一维整数类型数组,每一维度对应input每一维移动步数。padding,字符串,SAME
全尺寸操作 输入、输出数据维度相同,VALID 部分窗口
输入、输出数据维度不同。use_cudnn_on_gpu
,可选布尔值,默认True。name,可选,操作名字。输出,Tensor,数据类型floate32、floate64。
tf.nn.depthwise_conv2d(input,filter,strides,padding,rate=None,name=None,
data_format=None),输入张量数据维度[batch,in_height,in_width,in_width,in_channels]
,卷积核维度[filter_height,filter_width,in_channel_multiplier],通道in_channels卷积深度1,depthwise_conv2d函数将不同卷积核独立使用在in_channels每个通道上,再把具备结果汇总。输出通道总数in_channels*channel_multiplier

tf.nn.separable_conv2d(input,depthwise_filter,pointwise_filter,strides,padding,rate=None,name=None,data_format=None)
用多少个分别卷积核做卷积。用二维卷积核在每个通道上,以深度channel_multiplier卷积。depthwise_filter,
张量,数据四维[filter_height,filter_width,in_channels,channel_multiplier],in_channels卷积深度1。pointwise_filter,张量,数据四维[1,1,channel_multiplier*in_channels,out_channels],pointwise_filter,在depthwise_filter卷积后混合卷积。
tf.nn.atrous_conv2d(value,filters,rate,padding,name=None)总结Atrous卷积,孔卷积,扩展卷积。
tf.nn.conv2d_transpose(value,filter,output_shape,strides,padding=’SAME’,
data_format=’NHWC’,name=None),解卷积网络(deconvolutional
network)中称’反卷积’,实际上是conv2d的转置。output_shape,一维张量,反卷积运算输出形状。
tf.nn.conv1d(value,filters,stride,padding,use_cudnn_on_gpu=None,data_format=None,name=None),总括给定三维输入和过滤器的一维卷积。输入三维[batch,in_width,in_channels],卷积核三维,少filter_height,[filter_width,in_channels,out_channels]
,stride正整数,卷积核向右移动每一步长度。
tf.nn.conv3d(input,filter,strides,padding,name=None)总结给定五维输入和过滤器的三维卷积。input
shape多一维in_depth,形状Shape[batch,in_depth,in_height,in_width,in_channels]
。filter
shape多一维filter_depth,卷积核大小filter_depth,filter_height,filter_width。strides多一维,[strides_batch,
strides_depth,strides_height,strides_sidth,strides_channel],必须确保strides[0]=strides[4]=1。
tf.nn.conv3d_transpose(value,filter,output_shape,strides,padding=’SAME’,
name=None)。

池化函数。神经网络,池化函数一般跟在卷积函数下一层,定义在tensorflow-1.1.0/tensorflow/python/ops/nn.py、gen_nn_ops.py。
池化操作,用一个矩阵窗口在张量上扫描,每个矩阵窗口中的值通过取最大值或平均值来收缩元素个数。每个池化操作矩阵窗口大小ksize指定,依据步长strides移动。
tf.nn.avg_pool(value,ksize,strides,padding,data_format=’NHWC’,name=None)总结池化区域元素平均值。value,四维张量,数据维度[batch,height,width,
channels]。ksize,长度不低于4整型数组,每位值对应输入数据张量每维窗口对应值。strides,长度不小于4整型数组,批定滑动窗口在输入数据张量每一维上的肥瘦。padding,字符串,SAME或VALID。data_format,’NHWC’,输入张量维度顺序,N个数,H中度,W宽度,C通道数(RGB三通道或灰度单通道)。name,可选,操作名字。
tf.nn.max_pool(value,ksize,strides,padding,data_format=’NHWC’,
name=None)总结池化区域元素最大值。
tf.nn.max_pool_with_argmax(input,ksize,strides,padding,Targmax=None,
name=None),总计池化区域元素最大值和所在地点。总计地点agrmax,input铺平。如input=[b,y,x,c],索引地点((b*height+y)*width+x)*channels+c。只好在GPU运行。再次来到张量元组(output,argmax),output池化区域最大值,argmax数据类型Targmax,四维。
tf.nn.avg_pool3d()、tf.nn.max_pool3d() 三维平均池化和最大池化。
tf.nn.fractional_avg_pool()、tf.nn.tractional_max_pool()
tf.nn.pool(input,window_shape,pooling_type,padding,dilation_rate=None,
strides=None,name=None,data_format=None)执行N维池化操作。

分拣函数。定义在tensorflow-1.1.0/tensorflow/python/ops/nn.py、nn_ops.py。
tf.nn.sigmoid_cross_entropy_with_logits(logits,targets,name=None)。输入,logtis:[batch_size,num_classes],targets:[batch_size,size],logits用最终一层输入。输出,loss
[batch_size,num_classes]。如作损失函数,神经网络最终一层不需要sigmoid运算。
tf.nn.softmax(logits,dim=-1,name=None)计算Softmax激活,softmax=exp(logits)
/reduce_sum(exp(logits),dim)。
tf.nn.log_softmax(logits,dim=-1,name=None)计算log
softmax激活,logsoftmax=logits-log(reduce_sum(exp(logits),dim))。
tf.nn.softmax_cross_entropy_with_logits(_sentinel=None,labels=None,logits=None,dim=-a,name=None)。输入,logits、lables
[batch_size,num_classes] ,输出,loss [batch_size],保存batch
每个样本交叉熵。
tf.nn.sparse_softmax_cross_entropy_with_logits(logits,labels,name=None)。logits神经网络最终一层结果。输入,logits
[batch_size,num_classes],labels
[batch_size],必须在[0,num_classes]。输出,loss
[batch_size],保存batch 每个样本交叉熵。

优化措施。加速操练优化措施,多数基于梯度下降。梯度下降求函数极值。学习最终求损失函数极值。TensorFlow提供成千上万优化器(optimizer)。
BGD法。bat gradient
descent,批梯度下降。利用现有参数对磨练集每个输入生成一个推测输出yi。跟实际输出yi相比,总括所有误差,求平均以后拿到平均误差,以此更新参数。迭代经过,提取操练集中具有情节{x1,…,xn},相关输出yi
。总结梯度和误差,更新参数。使用具有训练多少测算,保证没有,不需要逐渐压缩学习率。每一步都亟待采纳所有磨练多少,速度更是慢。
SDG法。stochastic gradient
descent,随机梯度下降。数据集拆分成一个个批次(batch),随机抽取一个批次总结,更新参数,MBGD(minibatch
gradient
descent)。每一回迭代测算mini-batch梯度,更新参数。练习多少集很大,仍是可以较疾速度没有。抽取不可避免梯度误差,需要手动调整学习率(learning
rate)。采用切合学习率相比不方便。想对常并发特点更新速度快,不常出现特征更新速度慢。SGD更新所有参数用同样学习率。SGD容易收敛到有的最优,可能被困在鞍点。
Momentum法。模拟物农学动量概念。更新时在必然水平保留往日更新方向,当前批次再微调本次更新参数,引入新变量v(速度),作为前三次梯度累加。Momentum更新学习率,在下跌初期,前后梯度方向一致时,加速学习,在下滑中中期,在部分最小值附最近回震荡时,抑制震荡,加快收敛。
Nesterov Momentum法。Ilya
Sutskever,Nesterov。标准Momentum法,先总括一个梯度,在增速革新梯度方向大跳跃。Nesterov法,先在原本加速梯度方向大跳跃,再在该职务总括梯度值,用那个梯度值修正最后更新方向。
Adagrad法。自适应为顺序参数分配不同学习率,控制每个维度梯度方向。实现学习率自动更改。这次更新梯度大,学习率衰减快,否则慢。
艾达(Ada)delta法。艾达grad法,学习单调递减,磨炼前期学习率非凡小,需要手动设置一个大局伊始学习率。Adadelta法用一阶方法,近似模拟二阶牛顿(牛顿(Newton))法,解决问题。
RMSprop法。引入一个衰减周详,每回合都衰减一定比例。对循环神经网络(RNN)效果很好。
艾达m法。自适应矩臆想(adaptive moment
estimation)。艾达m法依照损失函数针对各样参数梯度一阶矩臆想和二阶矩估量动态调整每个参数学习率。矩估摸,利用样本矩估摸全部相应参数。一个随便变量X遵从某种分布,X一阶矩是E(X),样本平均值,X二阶矩E(X2),样本平方平均值。
措施相比较。Karpathy在MNIST数据集发现规律:不调整参数,艾达grad法比SGD法、Momentum法更安宁、性能更优。精调参数,精调SGD法、Momentum法收敛速度和准确性优于艾达(Ada)grad法。http://sebastianruder.com/optimizing-gradient-descent/。《An
overview of gradient descent optimization algorithms》。

参考资料:
《TensorFlow技术解析与实战》

欢迎付费咨询(150元每刻钟),我的微信:qingxingfengzi