def createPooling(layer, nodename, inname, outname, input_shape):
dict = getPoolingAttri(layer)
output_shape = getPoolingOutShape(input_shape, layer, dict)
#判断是池化种类,最大池化、平均池化
if layer.pooling_param.pool == 0:
node = Node.c2oNode(layer,
nodename,
"MaxPool",
inname,
outname,
input_shape,
output_shape,
dict=dict)
elif layer.pooling_param.pool == 1:
node = Node.c2oNode(layer,
nodename,
"AveragePool",
inname,
outname,
input_shape,
output_shape,
dict=dict)
#Layers[i].pooling_param.pool==2为随机池化
print(nodename, "节点构建完成")
return node
def createPooling(layer, nodename, inname, outname, input_shape):
dict = getPoolingAttri(layer)
with_indices = True if len(outname) == 2 else False
output_shape = getPoolingOutShape(input_shape,
layer,
dict,
with_indices=with_indices)
#判断是池化种类,最大池化、平均池化
if layer.pooling_param.pool == 0:
if layer.pooling_param.global_pooling == True:
node = Node.c2oNode(layer,
nodename,
"GlobalMaxPool",
inname,
outname,
input_shape,
output_shape,
dict={})
else:
node = Node.c2oNode(layer,
nodename,
"MaxPool",
inname,
outname,
input_shape,
output_shape,
dict=dict)
elif layer.pooling_param.pool == 1:
if layer.pooling_param.global_pooling == True:
node = Node.c2oNode(layer,
nodename,
"GlobalAveragePool",
inname,
outname,
input_shape,
output_shape,
dict={})
else:
node = Node.c2oNode(layer,
nodename,
"AveragePool",
inname,
outname,
input_shape,
output_shape,
dict=dict)
#Layers[i].pooling_param.pool==2为随机池化
print(nodename, "节点构建完成")
return node
def create_pooling_node(layer, nodename, inname, outname, input_shape):
pool_type = pooling_type(layer)
node = None
attributes = get_pool_attributes(layer, pool_type, input_shape)
with_indices = True if len(outname) == 2 else False
output_shape = get_pooling_output_shape(input_shape,
layer,
attributes,
with_indices=with_indices)
# 判断是池化种类,最大池化、平均池化
if pool_type == 'GlobalMaxPool':
node = Node.c2oNode(layer,
nodename,
"GlobalMaxPool",
inname,
outname,
input_shape,
output_shape,
dict={})
elif pool_type == 'MaxPool':
node = Node.c2oNode(layer,
nodename,
"MaxPool",
inname,
outname,
input_shape,
output_shape,
dict=attributes)
elif pool_type == 'GlobalAveragePool':
node = Node.c2oNode(layer,
nodename,
"GlobalAveragePool",
inname,
outname,
input_shape,
output_shape,
dict={})
elif pool_type == 'AveragePool':
node = Node.c2oNode(layer,
nodename,
"AveragePool",
inname,
outname,
input_shape,
output_shape,
dict=attributes)
# Layers[i].pooling_param.pool==2为随机池化
assert (node is not None)
return node
def createConv(layer, node_name, input_name, output_name, input_shape):
attributes = getConvAttri(layer, input_shape)
output_shape = getConvOutShape(input_shape, layer, attributes)
# 构建node
node = Node.c2oNode(layer, node_name, "Conv", input_name, output_name,
input_shape, output_shape, attributes)
return node
def create_log_node(layer, node_name, input_name, output_name, input_shape):
output_shape = get_log_output_shape(layer)
node = Node.c2oNode(layer, node_name, 'Log', input_name, output_name,
input_shape, output_shape)
return node
def createLRN(layer,nodename, inname,outname,input_shape):
dict = getLRNAttri(layer)
output_shape = getLRNOutShape(input_shape)
#构建node
node = Node.c2oNode(layer, nodename, "LRN", inname, outname, input_shape, output_shape, dict)
return node
def createSigmoid(layer, nodename, inname, outname, input_shape):
output_shape = getOutShape(input_shape)
node = Node.c2oNode(layer, nodename, "Sigmoid", inname, outname,
input_shape, output_shape)
return node
def create_InstanceNorm_op(layer, node_name, input_name, output_name,
input_shape):
output_shape = get_InstanceNorm_output_shape(input_shape)
attributes = create_InstanceNorm_attributes(layer)
node = Node.c2oNode(layer, node_name, "InstanceNormalization", input_name,
output_name, input_shape, output_shape, attributes)
return node
def create_clip_node(layer, node_name, input_name, output_name, input_shape):
# onnx 1.6.0 don't use
# attributes = get_attribute(layer)
output_shape = get_clip_output_shape(input_shape)
node = Node.c2oNode(layer, node_name, 'Clip', input_name, output_name,
input_shape, output_shape)
return node
def create_interp_node(layer, node_name, input_name, output_name, input_shape):
attributes = get_interp_attri(layer, input_shape)
output_shape = get_interp_output_shape(layer, input_shape, attributes)
# print(output_shape)
node = Node.c2oNode(layer, node_name, "Upsample", input_name, output_name, input_shape, output_shape, attributes)
return node
def create_add_node(layer, node_name, input_name, output_name, input_shape):
output_shape = get_add_output_shape(input_shape)
node = Node.c2oNode(layer, node_name, 'Add', input_name, output_name,
input_shape, output_shape)
return node
def createConvTranspose(layer, nodename, inname, outname, input_shape):
dict = getConvTransposeAttri(layer)
output_shape = getConvTransposeOutShape(input_shape, layer, dict)
#构建node
node = Node.c2oNode(layer, nodename, "ConvTranspose", inname, outname,
input_shape, output_shape, dict)
return node
def createUnPooling(layer,nodename,inname,outname,input_shape):
dict = getUnPoolingAttri(layer)
output_shape = getUnPoolingOutShape(input_shape,layer,dict)
node = Node.c2oNode(layer, nodename, "MaxUnpool", inname, outname, input_shape, output_shape, dict=dict)
return node
def createCrop(layer, nodename, inname, outname, input_shape):
output_shape = getCropOutShape(input_shape)
#构建node
node = Node.c2oNode(layer, nodename, "Crop", inname, outname, input_shape,
output_shape)
print(nodename, "节点构建完成")
return node
def createConv(layer, nodename, inname, outname, input_shape):
dict = getConvAttri(layer)
output_shape = getConvOutShape(input_shape, layer, dict)
#构建node
node = Node.c2oNode(layer, nodename, "Conv", inname, outname, input_shape, output_shape, dict)
print(nodename, "节点构建完成")
return node
def create_mul_node(layer, node_name, input_name, output_name, input_shape):
output_shape = get_mul_output_shape(input_shape)
node = Node.c2oNode(layer, node_name, 'Mul', input_name, output_name,
input_shape, output_shape)
return node
def createSoftmax(layer, nodename, inname, outname, input_shape):
dict = getSoftmaxAttri(layer)
output_shape = getSoftmaxOutShape(input_shape)
#构建node
node = Node.c2oNode(layer, nodename, "Softmax", inname, outname,
input_shape, output_shape, dict)
print(nodename, "节点构建完成")
return node
def createShuffle(layer, nodename, inname, outname, input_shape):
# 获取output_shape
output_shape = getReshapeOutShape(layer, input_shape)
# 构建node
node = Node.c2oNode(layer, nodename, "Reshape", inname, outname,
input_shape, output_shape)
return node
def createConcat(layer, nodename, inname, outname, input_shape):
dict = getConcatAttri(layer)
output_shape = getConcatOutShape(input_shape)
node = Node.c2oNode(layer, nodename, "Concat", inname, outname,
input_shape, output_shape, dict)
print(nodename, "节点构建完成")
return node
def create_Lp_Normalization(layer, node_name, input_name, output_name,
input_shape):
attribute = create_attribute(layer)
output_shape = get_node_output(input_shape)
node = Node.c2oNode(layer, node_name, "LpNormalization", input_name,
output_name, input_shape, output_shape, attribute)
return node
def createGemm(layer, nodename, inname, outname, input_shape, num_output):
dict = getGemmAttri(layer)
output_shape = getGemmOutShape(input_shape, num_output)
#构建node
node = Node.c2oNode(layer, nodename, "Gemm", inname, outname, input_shape,
output_shape, dict)
print(nodename, "节点构建完成")
return node
def createReshape(layer,
node_name,
input_name,
output_name,
input_shape,
output_shape={}):
# 获取output_shape
if layer.type == 'Scale' and output_shape != {}:
node = Node.c2oNode(layer, node_name, "Reshape", input_name,
output_name, input_shape, output_shape)
return node
else:
output_shape = getReshapeOutShape(layer, input_shape)
# 构建node
node = Node.c2oNode(layer, node_name, "Reshape", input_name, output_name,
input_shape, output_shape)
return node
def createBN(layer, nodename, inname, outname, input_shape):
dict = getBNAttri(layer)
output_shape = getBNOutShape(input_shape)
node = Node.c2oNode(layer, nodename, "BatchNormalization", inname, outname,
input_shape, output_shape, dict)
return node
def create_upsample_node(layer, node_name, input_name, output_name,
input_shape):
attributes = get_upsample_attri(layer)
output_shape = get_upsample_outputshape(input_shape, layer)
# print(output_shape)
node = Node.c2oNode(layer, node_name, "Upsample", input_name, output_name,
input_shape, output_shape, attributes)
return node
def createReshape(layer, nodename, inname, outname, input_shape):
#获取output_shape
output_shape = getReshapeOutShape(layer, input_shape)
#构建node
node = Node.c2oNode(layer, nodename, "Reshape", inname, outname,
input_shape, output_shape)
print(nodename, "节点构建完成")
return node
def createTranspose(layer, node_name, input_name, output_name,
input_shape) -> Node:
attributes = getTransposeAttri(layer)
output_shape = getTransposeOutShape(layer, input_shape, attributes)
node = Node.c2oNode(layer, node_name, "Transpose", input_name, output_name,
input_shape, output_shape, attributes)
return node
def createRelu(layer, nodename, inname, outname, input_shape):
attributes = getReluAttri(layer)
output_shape = getReluOutShape(input_shape)
if attributes == {}:
node = Node.c2oNode(layer, nodename, "Relu", inname, outname,
input_shape, output_shape)
else:
node = Node.c2oNode(layer,
nodename,
"LeakyRelu",
inname,
outname,
input_shape,
output_shape,
dict=attributes)
return node
def createConcat(layer, nodename, inname, outname, input_shape):
attributes = get_concat_attributes(layer)
output_shape = get_concat_outshape(layer, input_shape)
node = Node.c2oNode(layer, nodename, "Concat", inname, outname,
input_shape, output_shape, attributes)
return node
def createUpsample(layer, nodename, inname, outname, input_shape):
dict = getUpsampleAttri(layer)
output_shape = getUpsampleOutShape(input_shape, layer)
#print(output_shape)
node = Node.c2oNode(layer, nodename, "Upsample", inname, outname,
input_shape, output_shape, dict)
print(nodename, "节点构建完成")
return node
def createBN(layer, nodename, inname, outname, input_shape):
dict = getBNAttri(layer)
#计算output_shape,输出维度等于输入维度
output_shape = getBNOutShape(input_shape)
#构建node
node = Node.c2oNode(layer, nodename, "BatchNormalization", inname, outname, input_shape, output_shape,dict)
print(nodename,"节点构建完成")
return node
