mxnet转keras的记录

于 2021-02-21 18:11:24 发布
阅读量140 收藏
点赞数
分类专栏： python 文章标签： mxnet keras
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011529752/article/details/113921376
版权 
import keras
from keras import layers
import numpy as np
import mxnet as mx
import cv2


def build_net():
    the_input = layers.Input(shape=(48,48,3))
    x = layers.Conv2D(64,(3,3),strides=(1,1),padding="valid",use_bias=True,name='conv1')(the_input)

    x = layers.PReLU(name='prelu1',shared_axes=[1,2])(x)
    x = layers.AveragePooling2D(pool_size=(3,3),strides=(2,2),padding="same",name="pool1")(x)
    #
    x = layers.DepthwiseConv2D((3,3),padding="valid",use_bias=True,name="conv2_dw")(x)
    # x = layers.LeakyReLU(0.25, name='prelu2_dw')(x)
    x = layers.PReLU(name='prelu2_dw', shared_axes=[1, 2])(x)
    x = layers.Conv2D(128,(1,1),strides=(1,1),use_bias=True,name='conv2_sep')(x)
    # x = layers.LeakyReLU(0.25, name='prelu2_sep')(x)
    x = layers.PReLU(name='prelu2_sep', shared_axes=[1, 2])(x)
    x = layers.AveragePooling2D(pool_size=(3,3),strides=(2,2),name="pool2")(x)

    x = layers.DepthwiseConv2D((3,3),padding="valid",use_bias=True,name="conv3_dw")(x)
    # x = layers.LeakyReLU(0.25, name='prelu3_dw')(x)
    x = layers.PReLU(name='prelu3_dw', shared_axes=[1, 2])(x)
    x = layers.Conv2D(256,(1,1),strides=(1,1),use_bias=True,name='conv3_sep')(x)
    # x = layers.LeakyReLU(0.25, name='prelu3_sep')(x)
    x = layers.PReLU(name='prelu3_sep', shared_axes=[1, 2])(x)
    x = layers.AveragePooling2D(pool_size=(2,2),strides=(2,2),name="pool3")(x)

    x = layers.DepthwiseConv2D((2,2),padding="valid",use_bias=True,name="conv4_dw")(x)
    # x = layers.LeakyReLU(0.25, name='prelu4_dw')(x)
    x = layers.PReLU(name='prelu4_dw', shared_axes=[1, 2])(x)
    x = layers.Conv2D(512,(1,1),strides=(1,1),use_bias=True,name='conv4_sep')(x)
    # x = layers.LeakyReLU(0.25, name='prelu4_sep')(x)
    x = layers.PReLU(name='prelu4_sep', shared_axes=[1, 2])(x)

    x = layers.DepthwiseConv2D((3,3),padding="valid",use_bias=True,name="conv5_dw")(x)
    # x = layers.LeakyReLU(0.25, name='prelu5_dw')(x)
    x = layers.PReLU(name='prelu5_dw', shared_axes=[1, 2])(x)
    x = layers.Conv2D(512,(1,1),strides=(1,1),use_bias=True,name='conv5_sep')(x)
    # x = layers.LeakyReLU(0.25, name='prelu5_sep')(x)
    x = layers.PReLU(name='prelu5_sep', shared_axes=[1, 2])(x)

    x = layers.Dense(212,use_bias=True,name="conv6_3")(x)
    x = layers.BatchNormalization(name="bn6_3",momentum=0.9,)(x)

    return keras.Model(the_input,x)


def set_dwconv_weights(model,layer_name,arg_params,aux_params):
    layer = model.get_layer(layer_name)

    weights_keras, bias_keras = layer.get_weights()

    weights_mx = arg_params[layer_name+"_weight"].asnumpy()
    bias_mx = arg_params[layer_name+"_bias"].asnumpy()

    # print(weights_keras.shape)
    # print(weights_mx.shape)

    input_channal = weights_mx.shape[0]
    output_channal = weights_mx.shape[1]

    for i in range(input_channal):
        for j in range(output_channal):
            weights_keras[:,:,i,j] = weights_mx[i,j,:,:]
    bias_keras = bias_mx

    layer.set_weights([weights_keras,bias_keras])

    #check
    # layer = model.get_layer(layer_name)
    # weights_keras, bias_keras = layer.get_weights()
    # for i in range(input_channal):
    #     for j in range(output_channal):
    #         print(np.sum(weights_keras[:,:,i,j] - weights_mx[i,j,:,:]))
    # print(bias_keras - bias_mx)

def set_conv_weights(model,layer_name,arg_params,aux_params):
    layer = model.get_layer(layer_name)

    weights_keras, bias_keras = layer.get_weights()

    weights_mx = arg_params[layer_name+"_weight"].asnumpy()
    bias_mx = arg_params[layer_name+"_bias"].asnumpy()

    print(weights_keras.shape)
    print(weights_mx.shape)

    input_channal = weights_mx.shape[0]
    output_channal = weights_mx.shape[1]
    H1,H2 = weights_mx.shape[2:]
    for i in range(input_channal):
        for j in range(output_channal):
            for l in range(H1):
                for k in range(H2):
                    weights_keras[l,k,j,i] = weights_mx[i,j,l,k]
    bias_keras = bias_mx

    layer.set_weights([weights_keras,bias_keras])

    #check
    # layer = model.get_layer(layer_name)
    # weights_keras, bias_keras = layer.get_weights()
    # for i in range(input_channal):
    #     for j in range(output_channal):
    #         print(np.sum(weights_keras[:,:,j,i] - weights_mx[i,j,:,:]))
    # print(bias_keras - bias_mx)

def set_leaky_weights(model,layer_name,arg_params,aux_params):
    weight = arg_params[layer_name+"_gamma"].asnumpy()
    layer = model.get_layer(layer_name)
    weight = np.expand_dims(weight,0)
    weight = np.expand_dims(weight,0)
    weight = np.expand_dims(weight, 0)
    layer.set_weights(weight)

def set_bn_weights(model,layer_name,arg_params,aux_params):
    layer = model.get_layer(layer_name)
    # print(layer.weights)
    # print(len(layer.weights))
    # weights_keras = layer.get_weights()
    # for weight in weights_keras:
    #     print(weight.shape)
    moving_var = aux_params[layer_name+"_moving_var"].asnumpy()
    moving_mean = aux_params[layer_name+"_moving_mean"].asnumpy()
    gamma = arg_params[layer_name+"_gamma"].asnumpy()
    beta = arg_params[layer_name+"_beta"].asnumpy()
    # print("==========================")
    # print(moving_var.shape)
    # print(moving_mean.shape)
    # print(gamma.shape)
    # print(beta.shape)
    layer.set_weights([gamma,beta,moving_mean,moving_var])

    #check
    # gamma_keras, beta_keras, moving_mean_keras, moving_var_keras = layer.get_weights()
    #
    # print(np.sum(gamma-gamma_keras))
    # print(np.sum(beta-beta_keras))
    # print(np.sum(moving_mean-moving_mean_keras))
    # print(np.sum(moving_var-moving_var_keras))

def set_dense_weights(model,layer_name,arg_params,aux_params):
    layer = model.get_layer(layer_name)
    weight_keras, bias_keras = layer.get_weights()

    weight_mx = arg_params[layer_name+"_weight"].asnumpy()
    bias_mx = arg_params[layer_name+"_bias"].asnumpy()

    # print(weight_keras.shape,weight_mx.shape)
    # print(bias_keras.shape,bias_mx.shape)

    for i in range(weight_mx.shape[0]):
        weight_keras[:,i] = weight_mx[i,:]
    bias_keras = bias_mx
    layer.set_weights([weight_keras,bias_keras])

    # #check
    # weight_keras,bias_keras = layer.get_weights()
    # for i in range(weight_mx.shape[0]):
    #     print(np.sum(weight_keras[:,i] - weight_mx[i,:]))
    # print(np.sum(bias_mx-bias_keras))

if __name__ == "__main__":
    model = build_net()
    model.summary()
    sym, arg_params, aux_params = mx.model.load_checkpoint('models/lnet106-normal', 0)
    # print(arg_params)
    # print([key for key, _ in arg_params.items()])
    # print([key for key,_ in aux_params.items()])

    # layer_name = "conv4_dw"
    # set_dwconv_weights(model,layer_name,arg_params)
    #
    # layer_name = "conv3_sep"
    # set_conv_weights(model,layer_name,arg_params,aux_params)

    # layer_name = "bn6_3"
    # set_bn_weights(model,layer_name,arg_params,aux_params)

    # layer_name = "conv6_3"
    # set_dense_weights(model,layer_name,arg_params,aux_params)

    dw_layer_names = ["conv2_dw","conv3_dw","conv4_dw","conv5_dw"]
    conv_layer_names = ["conv1","conv2_sep","conv3_sep","conv4_sep","conv5_sep"]
    leaky_layer_names = ["prelu1","prelu2_dw","prelu2_sep","prelu3_dw","prelu3_sep","prelu4_dw","prelu4_sep","prelu5_dw","prelu5_sep"]
    dense_layer_names = ["conv6_3"]
    bn_layer_names = ["bn6_3"]

    for layer_name in dw_layer_names:
        print(layer_name)
        set_dwconv_weights(model,layer_name,arg_params,aux_params)
    print("set dw conv layers done！")

    for layer_name in conv_layer_names:
        print(layer_name)
        set_conv_weights(model,layer_name,arg_params,aux_params)
    print("set conv layers done！")

    for layer_name in leaky_layer_names:
        print(layer_name)
        set_leaky_weights(model,layer_name,arg_params,aux_params)
    print("set leaky layers done！")

    for layer_name in dense_layer_names:
        print(layer_name)
        set_dense_weights(model,layer_name,arg_params,aux_params)
    print("set dense layers done！")

    for layer_name in bn_layer_names:
        print(layer_name)
        set_bn_weights(model,layer_name,arg_params,aux_params)
    print("set bn layers done！")

    model.save_weights("frommx.h5")
    model.load_weights("frommx.h5")

    ###check out_put
    # print("+++++++++mx_out++++++++++++++++++++++++++")
    # internals = sym.get_internals()
    # print(internals)
    #
    # sym1 = internals[51]
    # # sym = internals['conv6_3']
    #
    # print(sym1)
    # mod = mx.mod.Module(symbol=mx.symbol.Group([sym, sym1]), context=mx.cpu(), label_names=None)
    # mod.bind(for_training=False, data_shapes=[('data', (1, 3, 48, 48))],
    #          label_shapes=mod._label_shapes)
    # mod.set_params(arg_params, aux_params, allow_missing=True)

    img = cv2.imread("images/test_data/LFPW_image_test_0008_0.jpg")
    # img = cv2.imread("images/face.jpeg")
    print(img.shape)
    img_draw1 = np.copy(img)
    img_draw2 = np.copy(img)

    img = cv2.resize(img, (48, 48))
    img2 = np.copy(img)
    img2 =cv2.cvtColor(img2,cv2.COLOR_BGR2RGB)
    img2 = img2 / 255.0
    # img = img / 255.0

    # B = img[:, :, 0]
    # G = img[:, :, 0]
    # R = img[:, :, 0]
    #
    # img1 = np.array([R, G, B])
    # img1 = np.expand_dims(img1, 0)

    # prob1 = mod.predict(mx.nd.array(img1))
    #
    # prob1 = prob1.asnumpy()
    # print(prob1.shape)
    #
    # points = np.reshape(prob1[0], (-1, 2))
    # print(points)
    #
    # for point in points:
    #     cv2.circle(img_draw1, (int(img_draw1.shape[1] * point[0]), int(img_draw1.shape[0] * point[1])), 2, (0, 255, 0), 2)
    #
    # cv2.imwrite("images/out_mx.jpg", img_draw1)

    ##keras pro
    prob = np.load("pro.npy")
    print(prob.shape)

    print("+++++++++keras_out++++++++++++++++++++++++++")
    img2 = np.expand_dims(img2,0)
    prob2 = model.predict(img2)
    # print(prob2)
    print(prob2.shape)

    # for i in range(prob.shape[1]): #64
    #     for j in range(prob.shape[2]): #46
    #         for k in range(prob.shape[3]): #46
    #             print(np.sum(prob[0,i,j,k] - prob2[0,j,k,i]))
    print(np.mean(prob-prob2[0,0,:,:]))
    points = np.reshape(prob2[0,0], (-1, 2))
    print(points)

    for point in points:
        cv2.circle(img_draw2, (int(img_draw2.shape[1] * point[0]), int(img_draw2.shape[0] * point[1])), 2, (0, 255, 0), 2)
        # cv2.circle(img2, (int(img2.shape[1] * point[0]), int(img2.shape[0] * point[1])), 1, (0, 255, 0),1)

    cv2.imwrite("images/out_keras.jpg", img_draw2)

    # print(np.sum(prob1-prob2))

'''
  [[ 0.1353147  -0.0579986  -0.01030864 ... -0.28304923 -0.02570831
     0.5062662 ]
   [-0.14282435 -0.0184907   0.02211118 ...  0.12231904 -0.36815152
     0.1277793 ]
   [-0.22176422 -0.01984607 -0.01824915 ... -0.03450887  0.00403773
    -0.19866396]
   ...
   [-0.03818798 -0.0659131  -0.08594778 ... -0.11230922 -0.11797775
    -0.14423251]
   [-0.03948684 -0.02449722  0.00924962 ... -0.14035185 -0.06742968
    -0.0276219 ]
   [-0.01135029 -0.00452198 -0.02984257 ... -0.04574583 -0.10807924
    -0.14593129]]]]
'''
```json
{
  "nodes": [
    {
      "op": "null",
      "name": "data",
      "inputs": []
    },
    {
      "op": "null",
      "name": "conv1_weight",
      "attrs": {
        "kernel": "(3, 3)",
        "num_filter": "64"
      },
      "inputs": []
    },
    {
      "op": "null",
      "name": "conv1_bias",
      "attrs": {
        "kernel": "(3, 3)",
        "num_filter": "64"
      },
      "inputs": []
    },
    {
      "op": "Convolution",
      "name": "conv1",
      "attrs": {
        "kernel": "(3, 3)",
        "num_filter": "64"
      },
      "inputs": [[0, 0, 0], [1, 0, 0], [2, 0, 0]]
    },
    {
      "op": "null",
      "name": "prelu1_gamma",
      "attrs": {
        "__init__": "[\"Constant\", {\"value\": 0.25}]",
        "act_type": "prelu"
      },
      "inputs": []
    },
    {
      "op": "LeakyReLU",
      "name": "prelu1",
      "attrs": {"act_type": "prelu"},
      "inputs": [[3, 0, 0], [4, 0, 0]]
    },
    {
      "op": "Pooling",
      "name": "pool1",
      "attrs": {
        "kernel": "(3, 3)",
        "pool_type": "avg",
        "pooling_convention": "full",
        "stride": "(2, 2)"
      },
      "inputs": [[5, 0, 0]]
    },
    {
      "op": "null",
      "name": "conv2_dw_weight",
      "attrs": {
        "kernel": "(3, 3)",
        "num_filter": "64",
        "num_group": "64"
      },
      "inputs": []
    },
    {
      "op": "null",
      "name": "conv2_dw_bias",
      "attrs": {
        "kernel": "(3, 3)",
        "num_filter": "64",
        "num_group": "64"
      },
      "inputs": []
    },
    {
      "op": "Convolution",
      "name": "conv2_dw",
      "attrs": {
        "kernel": "(3, 3)",
        "num_filter": "64",
        "num_group": "64"
      },
      "inputs": [[6, 0, 0], [7, 0, 0], [8, 0, 0]]
    },
    {
      "op": "null",
      "name": "prelu2_dw_gamma",
      "attrs": {
        "__init__": "[\"Constant\", {\"value\": 0.25}]",
        "act_type": "prelu"
      },
      "inputs": []
    },
    {
      "op": "LeakyReLU",
      "name": "prelu2_dw",
      "attrs": {"act_type": "prelu"},
      "inputs": [[9, 0, 0], [10, 0, 0]]
    },
    {
      "op": "null",
      "name": "conv2_sep_weight",
      "attrs": {
        "kernel": "(1, 1)",
        "num_filter": "128"
      },
      "inputs": []
    },
    {
      "op": "null",
      "name": "conv2_sep_bias",
      "attrs": {
        "kernel": "(1, 1)",
        "num_filter": "128"
      },
      "inputs": []
    },
    {
      "op": "Convolution",
      "name": "conv2_sep",
      "attrs": {
        "kernel": "(1, 1)",
        "num_filter": "128"
      },
      "inputs": [[11, 0, 0], [12, 0, 0], [13, 0, 0]]
    },
    {
      "op": "null",
      "name": "prelu2_sep_gamma",
      "attrs": {
        "__init__": "[\"Constant\", {\"value\": 0.25}]",
        "act_type": "prelu"
      },
      "inputs": []
    },
    {
      "op": "LeakyReLU",
      "name": "prelu2_sep",
      "attrs": {"act_type": "prelu"},
      "inputs": [[14, 0, 0], [15, 0, 0]]
    },
    {
      "op": "Pooling",
      "name": "pool2",
      "attrs": {
        "kernel": "(3, 3)",
        "pool_type": "avg",
        "pooling_convention": "full",
        "stride": "(2, 2)"
      },
      "inputs": [[16, 0, 0]]
    },
    {
      "op": "null",
      "name": "conv3_dw_weight",
      "attrs": {
        "kernel": "(3, 3)",
        "num_filter": "128",
        "num_group": "128"
      },
      "inputs": []
    },
    {
      "op": "null",
      "name": "conv3_dw_bias",
      "attrs": {
        "kernel": "(3, 3)",
        "num_filter": "128",
        "num_group": "128"
      },
      "inputs": []
    },
    {
      "op": "Convolution",
      "name": "conv3_dw",
      "attrs": {
        "kernel": "(3, 3)",
        "num_filter": "128",
        "num_group": "128"
      },
      "inputs": [[17, 0, 0], [18, 0, 0], [19, 0, 0]]
    },
    {
      "op": "null",
      "name": "prelu3_dw_gamma",
      "attrs": {
        "__init__": "[\"Constant\", {\"value\": 0.25}]",
        "act_type": "prelu"
      },
      "inputs": []
    },
    {
      "op": "LeakyReLU",
      "name": "prelu3_dw",
      "attrs": {"act_type": "prelu"},
      "inputs": [[20, 0, 0], [21, 0, 0]]
    },
    {
      "op": "null",
      "name": "conv3_sep_weight",
      "attrs": {
        "kernel": "(1, 1)",
        "num_filter": "256"
      },
      "inputs": []
    },
    {
      "op": "null",
      "name": "conv3_sep_bias",
      "attrs": {
        "kernel": "(1, 1)",
        "num_filter": "256"
      },
      "inputs": []
    },
    {
      "op": "Convolution",
      "name": "conv3_sep",
      "attrs": {
        "kernel": "(1, 1)",
        "num_filter": "256"
      },
      "inputs": [[22, 0, 0], [23, 0, 0], [24, 0, 0]]
    },
    {
      "op": "null",
      "name": "prelu3_sep_gamma",
      "attrs": {
        "__init__": "[\"Constant\", {\"value\": 0.25}]",
        "act_type": "prelu"
      },
      "inputs": []
    },
    {
      "op": "LeakyReLU",
      "name": "prelu3_sep",
      "attrs": {"act_type": "prelu"},
      "inputs": [[25, 0, 0], [26, 0, 0]]
    },
    {
      "op": "Pooling",
      "name": "pool3",
      "attrs": {
        "kernel": "(2, 2)",
        "pool_type": "avg",
        "pooling_convention": "full",
        "stride": "(2, 2)"
      },
      "inputs": [[27, 0, 0]]
    },
    {
      "op": "null",
      "name": "conv4_dw_weight",
      "attrs": {
        "kernel": "(2, 2)",
        "num_filter": "256",
        "num_group": "256"
      },
      "inputs": []
    },
    {
      "op": "null",
      "name": "conv4_dw_bias",
      "attrs": {
        "kernel": "(2, 2)",
        "num_filter": "256",
        "num_group": "256"
      },
      "inputs": []
    },
    {
      "op": "Convolution",
      "name": "conv4_dw",
      "attrs": {
        "kernel": "(2, 2)",
        "num_filter": "256",
        "num_group": "256"
      },
      "inputs": [[28, 0, 0], [29, 0, 0], [30, 0, 0]]
    },
    {
      "op": "null",
      "name": "prelu4_dw_gamma",
      "attrs": {
        "__init__": "[\"Constant\", {\"value\": 0.25}]",
        "act_type": "prelu"
      },
      "inputs": []
    },
    {
      "op": "LeakyReLU",
      "name": "prelu4_dw",
      "attrs": {"act_type": "prelu"},
      "inputs": [[31, 0, 0], [32, 0, 0]]
    },
    {
      "op": "null",
      "name": "conv4_sep_weight",
      "attrs": {
        "kernel": "(1, 1)",
        "num_filter": "512"
      },
      "inputs": []
    },
    {
      "op": "null",
      "name": "conv4_sep_bias",
      "attrs": {
        "kernel": "(1, 1)",
        "num_filter": "512"
      },
      "inputs": []
    },
    {
      "op": "Convolution",
      "name": "conv4_sep",
      "attrs": {
        "kernel": "(1, 1)",
        "num_filter": "512"
      },
      "inputs": [[33, 0, 0], [34, 0, 0], [35, 0, 0]]
    },
    {
      "op": "null",
      "name": "prelu4_sep_gamma",
      "attrs": {
        "__init__": "[\"Constant\", {\"value\": 0.25}]",
        "act_type": "prelu"
      },
      "inputs": []
    },
    {
      "op": "LeakyReLU",
      "name": "prelu4_sep",
      "attrs": {"act_type": "prelu"},
      "inputs": [[36, 0, 0], [37, 0, 0]]
    },
    {
      "op": "null",
      "name": "conv5_dw_weight",
      "attrs": {
        "kernel": "(3, 3)",
        "num_filter": "512",
        "num_group": "512"
      },
      "inputs": []
    },
    {
      "op": "null",
      "name": "conv5_dw_bias",
      "attrs": {
        "kernel": "(3, 3)",
        "num_filter": "512",
        "num_group": "512"
      },
      "inputs": []
    },
    {
      "op": "Convolution",
      "name": "conv5_dw",
      "attrs": {
        "kernel": "(3, 3)",
        "num_filter": "512",
        "num_group": "512"
      },
      "inputs": [[38, 0, 0], [39, 0, 0], [40, 0, 0]]
    },
    {
      "op": "null",
      "name": "prelu5_dw_gamma",
      "attrs": {
        "__init__": "[\"Constant\", {\"value\": 0.25}]",
        "act_type": "prelu"
      },
      "inputs": []
    },
    {
      "op": "LeakyReLU",
      "name": "prelu5_dw",
      "attrs": {"act_type": "prelu"},
      "inputs": [[41, 0, 0], [42, 0, 0]]
    },
    {
      "op": "null",
      "name": "conv5_sep_weight",
      "attrs": {
        "kernel": "(1, 1)",
        "num_filter": "512"
      },
      "inputs": []
    },
    {
      "op": "null",
      "name": "conv5_sep_bias",
      "attrs": {
        "kernel": "(1, 1)",
        "num_filter": "512"
      },
      "inputs": []
    },
    {
      "op": "Convolution",
      "name": "conv5_sep",
      "attrs": {
        "kernel": "(1, 1)",
        "num_filter": "512"
      },
      "inputs": [[43, 0, 0], [44, 0, 0], [45, 0, 0]]
    },
    {
      "op": "null",
      "name": "prelu5_sep_gamma",
      "attrs": {
        "__init__": "[\"Constant\", {\"value\": 0.25}]",
        "act_type": "prelu"
      },
      "inputs": []
    },
    {
      "op": "LeakyReLU",
      "name": "prelu5_sep",
      "attrs": {"act_type": "prelu"},
      "inputs": [[46, 0, 0], [47, 0, 0]]
    },
    {
      "op": "null",
      "name": "conv6_3_weight",
      "attrs": {"num_hidden": "212"},
      "inputs": []
    },
    {
      "op": "null",
      "name": "conv6_3_bias",
      "attrs": {"num_hidden": "212"},
      "inputs": []
    },
    {
      "op": "FullyConnected",
      "name": "conv6_3",
      "attrs": {"num_hidden": "212"},
      "inputs": [[48, 0, 0], [49, 0, 0], [50, 0, 0]]
    },
    {
      "op": "null",
      "name": "bn6_3_gamma",
      "attrs": {
        "fix_gamma": "False",
        "momentum": "0.9"
      },
      "inputs": []
    },
    {
      "op": "null",
      "name": "bn6_3_beta",
      "attrs": {
        "fix_gamma": "False",
        "momentum": "0.9"
      },
      "inputs": []
    },
    {
      "op": "null",
      "name": "bn6_3_moving_mean",
      "attrs": {
        "__init__": "[\"zero\", {}]",
        "fix_gamma": "False",
        "momentum": "0.9"
      },
      "inputs": []
    },
    {
      "op": "null",
      "name": "bn6_3_moving_var",
      "attrs": {
        "__init__": "[\"one\", {}]",
        "fix_gamma": "False",
        "momentum": "0.9"
      },
      "inputs": []
    },
    {
      "op": "BatchNorm",
      "name": "bn6_3",
      "attrs": {
        "fix_gamma": "False",
        "momentum": "0.9"
      },
      "inputs": [[51, 0, 0], [52, 0, 0], [53, 0, 0], [54, 0, 1], [55, 0, 1]]
    }
  ],
  "arg_nodes": [
    0,
    1,
    2,
    4,
    7,
    8,
    10,
    12,
    13,
    15,
    18,
    19,
    21,
    23,
    24,
    26,
    29,
    30,
    32,
    34,
    35,
    37,
    39,
    40,
    42,
    44,
    45,
    47,
    49,
    50,
    52,
    53,
    54,
    55
  ],
  "node_row_ptr": [
    0,
    1,
    2,
    3,
    4,
    5,
    6,
    7,
    8,
    9,
    10,
    11,
    12,
    13,
    14,
    15,
    16,
    17,
    18,
    19,
    20,
    21,
    22,
    23,
    24,
    25,
    26,
    27,
    28,
    29,
    30,
    31,
    32,
    33,
    34,
    35,
    36,
    37,
    38,
    39,
    40,
    41,
    42,
    43,
    44,
    45,
    46,
    47,
    48,
    49,
    50,
    51,
    52,
    53,
    54,
    55,
    56
  ],
  "heads": [[56, 0]],
  "attrs": {"mxnet_version": ["int", 10200]}
}
Maxwellhang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
神经网络的三种可视化方法——使用keras和MXNet(gluon)实现
qq_37070854的博客
03-30 5602
神经网络的三种可视化方法——用keras和MXNet(gluon)实现 目录神经网络的三种可视化方法——用keras和MXNet(gluon)实现概述keras实现keras特征图可视化keras可视化滤波器(卷积核)的最大响应图keras可视化热力图MXNet(Gluon)实现Gluon可视化特征图Gluon可视化滤波器(卷积核)的最大响应图Gluon可视化热力图 keras之父弗朗西斯科肖莱在...
TensorFlow、MXNet、Keras如何取舍？ 常用深度学习框架对比
weixin_45583158的博客
12-21 632
作者简介魏秀参，旷视科技 Face++ 南京研究院负责人。南京大学 LAMDA 研究所博士，主要研究领域为计算机视觉和机器学习。在相关领域顶级国际期刊如 IEEE TIP...
TensorFlow和Caffe、MXNet、Keras等深度学习框架的对比
Jason的专栏
07-24 1万+
Google 近日发布了 TensorFlow 1.0 候选版，这第一个稳定版将是深度学习框架发展中的里程碑的一步。自 TensorFlow 于 2015 年底正式开源，距今已有一年多，这期间 TensorFlow 不断给人以惊喜。在这一年多时间，TensorFlow 已从初入深度学习框架大战的新星，成为了几近垄断的行业事实标准。 主流深度学习框架对比 深度学习研究的热潮持续高涨，各种开源深度
李沐等：MXNet设计和实现简介
klzhang的专栏
12-03 2381
我爱计算机 http://www.52cs.org/ @52cs 关注计算机领域进展 Skip to content Home About 友情 达人 李沐等：MXNet设计和实现简介 MXNet设计和实现简介 声明：本文经作者同意转载。 原始链接：https://github.com/dmlc/mxnet/issu
深度学习框架的比较（MXNet, Caffe, TensorFlow, Torch, Theano)
热门推荐
MyArrow的专栏
07-29 5万+
1. 比较表 2.详细描述
mxnet2caffe:将模型从mxnet转换为caffe，而不会损失精度
05-09
Mxnet2Caffe 将模型从mxnet转换为caffe，而不会损失精度
arcface_retinaface_mxnet2onnx:arcface 和retinaface 模型将mxnet 转换为onnx
05-29
更新2个模型码：jks7 码：otx7Update1 fix_gamma 在 mxnet 符号中，BN 有 fix_gamma，如果 fix_gamma 为 true，则将 gamma 设置为 1，其梯度为 0，您可以在找到它。 在retinaface_mnet025_v1中，'conv_3_dw_...
TensorFlow、Keras、PyTorch和Apache MXNet的分布式培训框架
最新发布
03-14
TensorFlow、Keras、PyTorch和Apache MXNet都支持分布式训练，以下是它们各自的分布式培训框架： 1. **TensorFlow**： - TensorFlow提供了多种分布式训练策略和工具，包括tf.distribute.Strategy、tf.distribute....
mxnet_backend.pyc
03-15
mxnet安装要比tensorflow简单的多，而且支持的系统也较为全面，现修改keras支持后端为mxnet。该为mxnet_backend.py的编译文件。
mxnet_mxnet_
10-02
MXNETMxnet是一个轻量化分布式可移植深度学习计算平台，他支持多机多节点、多GPU的计算，其openMP+MPI/SSH+Cuda/Cudnn的框架是的计算速度很快，且能与分布式文件系统结合实现大数据的深度学习
TensorFlow和Caffe、MXNet、Keras等其他深度学习框架的对比
xiangz_csdn的博客
02-25 4万+
[转] http://www.leiphone.com/news/201702/T5e31Y2ZpeG1ZtaN.html 雷锋网按：本文作者黄文坚，PPmoney 大数据算法总监，《 TensorFlow 实战》作者。本文节选自《 TensorFlow 实战》第二章。 在下周二（2月28日）雷锋网(公众号：雷锋网)硬创公开课栏目将会推出黄文坚老师的公开课《深度学习之经典卷积神
测试keras和mxnet的速度
jacke121的专栏
12-22 3086
测试keras和mxnet的速度
主流深度学习框架对比（TensorFlow、Keras、MXNet、PyTorch）
Circlecircle3的博客
08-27 4万+
近几年来，深度学习的研究和应用的热潮持续高涨，各种开源深度学习框架层出不穷，包括TensorFlow，Keras，MXNet，PyTorch，CNTK，Theano，Caffe，DeepLearning4，Lasagne，Neon，等等。Google，Microsoft等商业巨头都加入了这场深度学习框架大战，当下最主流的框架当属TensorFlow，Keras，MXNet，PyTorch，接下来我...
测试了一下keras和mxnet的速度
yudongfeng110的专栏
12-03 3250
这两个都很好用啊，适合我这样的入门小白 win10 64 cuda8.0 cudnn5.1 gtx1060 cnn mnist import numpy import os import urllib import gzip import struct def read_data(label_name, image_name): s=os.getenv('DATA')
keras实现简略版的VGGNet并加入可调整的学习率fine tuning
OliverkingLi的博客
07-25 2570
VGGNet的原理部分就不细说了，具体可以看原作者paper：Very Deep Learning Convolutional Neural Networks for Large-Scale Image Recognition。 这里使用小数据集去训练，因此就是用简略版的VGGNet去实现VGG思想，使用3x3的卷积核去迭代组合形成更深的网络结构。 这个实现：CONV => RELU =...
Tutorial教程：使用MMdnn将mxnet模型转换为tensorflow 2.0/keras 模型-全网唯一
MrCharles在CSDN
09-16 1万+
import keras from keras.models import Model from keras import layers import keras.backend as K import numpy as np from keras.layers.core import Lambda import tensorflow as tf —》 改为 import tensorflow.keras from tensorflow.keras.models import Model from te.
mxnet数据格式转换为tensorflow，pytorch数据
Lavi的专栏
12-14 2373
数据格式转换： mxnet的idx，rec格式数据生成参考：insightface mxnet的idx，rec格式数据转换成tfrecord，参考：MobileFaceNet_TF mxnet的idx，rec格式数据转换成pytorch容易读取的数据参考：InsightFace_Pytorch MobileFaceNet各种实现方式： mxnet：insightface tensorflow：M...
MXNet的数据格式转化为tensorflow训练用的数据格式
公众号:facefinetune
05-02 1258
1 介绍 本文将mxNet的数据格式转化为tensorflow训练用的数据格式。 2 导入包 import mxnet as mx import argparse import PIL.Image import io import numpy as np import cv2 import tensorflow as tf import os 3 主函数 ...
update mxnet
11-16
以下是更新mxnet的步骤： 1.使用pip升级mxnet：在命令行中输入以下命令： ```shell pip install mxnet --upgrade ``` 2.使用conda升级mxnet：在命令行中输入以下命令： ```shell conda update mxnet ``` 如果以上...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值