Posts made by slaxes

onnx转化为caffe2 pb文件

import caffe2.python.onnx.backend as cf2_backend
from onnx_caffe2.backend import Caffe2Backend as cf2_backend2

cf2_rep = cf2_backend.prepare(model)
output = cf2_rep.run(np_onnx_image.astype(np.float32))

same = True if id2class[np.argmax(output)] == label else False
print(same)

init_net, predict_net = cf2_backend2.onnx_graph_to_caffe2_net(model.graph)
with open("./ONNX/Mobilenet_init_net.pb", "wb") as f:
    f.write(init_net.SerializeToString())
with open("./ONNX/Mobilenet_predict_net.pb", "wb") as f:
    f.write(predict_net.SerializeToString())

tf.pb转化为tflite，实现移动端的部署

graph_def_file = "./ONNX/MobilenetV2.pb"
input_arrays = ["actual_input_1"]
output_arrays = ["add_10"]
converter = tf.contrib.lite.TFLiteConverter.from_frozen_graph(
  graph_def_file, input_arrays, output_arrays)
tflite_model = converter.convert()
open("./ONNX/MobilenetV2.tflite", "wb").write(tflite_model)

tf.pb测试

with tf.Session() as persisted_sess:
    with tf.gfile.GFile('./ONNX/MobilenetV2.pb', 'rb') as f:
        graph_def = tf.GraphDef()
        graph_def.ParseFromString(f.read())

    persisted_sess.graph.as_default()
    tf.import_graph_def(graph_def, name='')

    inp = persisted_sess.graph.get_tensor_by_name('actual_input_1:0')
    out = persisted_sess.graph.get_tensor_by_name('add_10:0')

    feed_dict = {inp: np.array(image)}

    res = persisted_sess.run(out, feed_dict)
    same = True if id2class[np.argmax(res)] == label else False
    print(same)

将tf_rep转化为tensorflow的pb文件

tf_rep.export_graph('./ONNX/MobilenetV2.pb')

直接对tf_rep进行测试

output = tf_rep.run(np_onnx_image)
same = True if id2class[np.argmax(output)] == label else False

将onnx格式的模型转化为tf_rep，并测试预测是否正确

import onnx_tf.backend as tf_backend

model = onnx.load('./ONNX/MobilenetV2.onnx')
tf_rep = tf_backend.prepare(model)
np_onnx_image = np.array(image)

with tf.Session() as persisted_sess:
    persisted_sess.graph.as_default()
    tf.import_graph_def(tf_rep.graph.as_graph_def(), name='')
    inp = persisted_sess.graph.get_tensor_by_name(
        tf_rep.tensor_dict[tf_rep.inputs[0]].name
    )
    out = persisted_sess.graph.get_tensor_by_name(
        tf_rep.tensor_dict[tf_rep.outputs[0]].name
    )
    print("inputs: {}, outputs: {}".format(tf_rep.tensor_dict[tf_rep.inputs[0]].name,
                                           tf_rep.tensor_dict[tf_rep.outputs[0]].name))
    res = persisted_sess.run(out, {inp: np_onnx_image})

    same = True if id2class[np.argmax(res)] == label else False
    print(same)

将pytorch的模型转化为onnx的中间格式，以便于转化到其它模型，参数dummy_input是pytorch的一个输入范例

state_dict = torch.load('./ONNX/best_model.dat', map_location='cpu')['state_dict']
net.load_state_dict(state_dict)
net.eval()

dummy_input = image                     # An example of args to input to the network.
input_names = ["actual_input_1"] + ["learned_%d" % i for i in range(314)]
output_names = ["output1"]
torch.onnx.export(net, dummy_input, "./ONNX/MobilenetV2.onnx",
                  input_names=input_names,
                  output_names=output_names,
                  # verbose=True        # It can show the structure of your network.
                  )

ONNX是Open Neural Network Exchange的缩写，它的作用是在不同框架之间实现模型互相转换，本帖将会聚焦于pytorch转出到其它的模型

$\epsilon-$贪心：有$1-\epsilon$的概率选择最优行为，$\epsilon$的概率随机选择行为，0<$\epsilon$<1
Q-learning实质：学习当state确定后，采取特定的action所得到的操作奖励，（reward表示状态转换的结果奖励）
Q函数由s、a两个参数组成$Q(s,a)$，假设存在n种state，m种action，考虑一个$n\times{m}$的矩阵，对应着$n\times{m}$个二元对的Q值
与此同时，存在另一个$n\times{m}$的矩阵，对应着n种state，m种action组合的reward，这些reward在最早给定
Q-table（矩阵）的更新策略如下：操作奖励更新为当前奖励与未来奖励的奖励的加权和，状态同步转移
$Q(s,a)\leftarrow(1-\alpha) * Q(s,a)+\alpha*\left[R(s,a)+\gamma*\max_a Q \left(s^\prime, a\right)\right] \$
$s\leftarrow s^\prime$
可以看出，$\alpha\rightarrow1$时Q值更加注重于未来奖励，反之注重于当前奖励（不更新）
局限性：若状态空间过大，$n\rightarrow\infty$
代码示例如下：

# -*- coding:utf-8 -*-
#|-----|-----|-----|
#|     |     |     |
#|  0  |  1  |  2  |
#|_____|_____|_____|
#|     |     |     |
#|  3  |  4  |  5  |
#|_____|_____|_____|
# Entering room 0 can get 10 reward, else get -1 reward

import argparse
import random
parser = argparse.ArgumentParser()
parser.add_argument('-g', type=float, default=0.8, dest='gamma')
parser.add_argument('-s', type=int, default=1000, dest='step_num')
parser.add_argument('-e', type=float, default=1.0, dest='epsilon')
args = parser.parse_args()

reward = [[0, -1, 0, -1, 0, 0],
          [10, 0, -1, 0, -1, 0],
          [0, -1, 0, 0, 0, -1],
          [10, 0, 0, 0, -1, 0],
          [0, -1, 0, -1, 0, -1],
          [0, 0, -1, 0, -1, 0]]
q_table = [[0 for x in range(6)] for y in range(6)]
step = 0
while step < args.step_num:
    s = random.randint(1, 5)
    while s != 0:
        if random.random() < args.epsilon:
            action_list = [x for x in range(6) if reward[s][x] != 0]
            s2 = random.choice(action_list)
        else:
            s2 = q_table[s].index(max(q_table[s]))
        q_table[s][s2] = reward[s][s2] + args.gamma * max([q_table[s2][y] for y in range(6) if y != s2])
        s = s2
    step += 1
print(q_table)
# 0, 0, 0, 0, 0, 0
# 10, 0, 4.6 0 4.6 0
# 0, 7, 0, 0, 0, 2.68
# 10, 0, 0, 0, 4.6 0
# 0, 7, 0, 7, 0, 2.68
# 0, 0, 4.6, 0, 4.6, 0