def test_nchw_backwardweights_filter3x5_nopack(tensile_state,
run_convolution_level):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionBackwardWeights',
config={
'TensorAFormat': 'NCHW',
'Filter': '3x5',
'PackedSpatialDims': 0,
})
log.debug(conv.printUsage(z))
if not tensile_state.args["no_conv_assertions"]:
# TODO - need to expand filter dims
(cdim, filterDims) = (6, [5, 4]) if conv.unrollOnChannel else (4,
[6, 5])
assert (z['NumIndicesC'] == 4)
assert (z['IndexAssignmentsA'] == filterDims + [0, 1, 2, cdim])
assert (z['IndexAssignmentsB'] == filterDims + [3, cdim, 2])
assert (z['SetConstStrideA'] == [[0, 1], [filterDims[0], 1]])
assert (z['SetConstStrideB'] == [[2, 0], [filterDims[0], 1]])
#assert(conv.solutionParms["AssertStrideAEqual"] == "1:1,3:1,0:1")
#assert(conv.solutionParms["AssertStrideBEqual"] == "1:1")
assert (conv.solutionParms["AssertSizeEqual"] == {0: 5, 1: 3})
run_convolution_level.func(conv, z, run_convolution_level.solution)
def test_nchw_stride_filter(tensile_state, run_convolution_level):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Stride': 'NxN',
'Filter': '2x2',
'PadStart': 'NxN',
'PadEnd': 'NxN',
})
log.debug(conv.printUsage(z))
if not tensile_state.args["no_conv_assertions"]:
filterDims = [5, 4] if conv.unrollOnChannel else [6, 5]
cdim = 6 if conv.unrollOnChannel else 3
assert (z['NumIndicesC'] == 4)
assert (z['IndexAssignmentsA'] == filterDims + [0, 1, cdim, 3])
assert (z['IndexAssignmentsB'] == filterDims + [cdim, 2, 3])
assert (not z['UseInitialStridesAB'])
assert (conv.solutionParms["AssertStrideAEqual"] == {0: 1})
assert (conv.solutionParms["AssertStrideBEqual"] == {0: 1, 4: 0})
assert (conv.solutionParms["AssertSizeEqual"] == {
filterDims[0]: 2,
filterDims[1]: 2
})
run_convolution_level.func(conv, z, run_convolution_level.solution)
def test_nhwc_filter2x2_stride(tensile_state, run_convolution_level):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NHWC',
'TensorBFormat': 'KYXC',
'Filter': '2x2',
'Stride': '2x2',
})
log.debug(conv.printUsage(z))
if not tensile_state.args["no_conv_assertions"]:
filterDims = [4, 3] if conv.unrollOnChannel else [5, 4]
cdim = 5 if conv.unrollOnChannel else 3
assert (z['NumIndicesC'] == 3)
assert (z['IndexAssignmentsA'] == [cdim] + filterDims + [1, 2])
assert (z['IndexAssignmentsB'] == [cdim] + filterDims + [0, 2])
assert (not z['UseInitialStridesAB'])
assert (conv.solutionParms["AssertStrideAEqual"] == {0: 1})
assert (conv.solutionParms["AssertStrideBEqual"] == {0: 1, 4: 0})
assert (conv.solutionParms["AssertSizeEqual"] == {
filterDims[0]: 2,
filterDims[1]: 2
})
run_convolution_level.func(conv, z, run_convolution_level.solution)
def test_nchw_filter2x2(tensile_state, run_convolution_level, problemSizes):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'TensorBFormat': 'KCYX',
'Filter': '2x2',
'PadStart': 'NxN',
'PadEnd': 'NxN',
})
log.debug(conv.printUsage(z))
if not tensile_state.args["no_conv_assertions"]:
filterDims = [3] if conv.unrollOnChannel else [4]
cdim = 4 if conv.unrollOnChannel else 3
assert (z['NumIndicesC'] == 3)
assert (z['IndexAssignmentsA'] == filterDims + [0, cdim, 2])
assert (z['IndexAssignmentsB'] == filterDims + [cdim, 1, 2])
assert (z['UseInitialStridesAB'])
assert (conv.solutionParms["AssertStrideAEqual"] == {1: 1})
assert (conv.solutionParms["AssertStrideBEqual"] == {3: 0})
assert (conv.solutionParms["AssertSizeEqual"] == {filterDims[0]: 2})
run_convolution_level.func(conv, z, run_convolution_level.solution,
problemSizes[0], problemSizes[1])
def test_pad_4x3():
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Filter': '4x3',
'PadStart': 'NxN',
'PadEnd': 'NxN',
})
log.debug(conv.printUsage(z))
e = {
'n': 1,
'c': 4,
'h': 12,
'w': 8,
'k': 1,
'p': 1,
'p_': 2,
'q': 3,
'q_': 4
}
ec = ConvProblem(e, conv)
assert (ec.zeroPadA[0] == [0, 5, 3, 4])
assert (ec.zeroPadA[1] == [1, 4, 8, 16])
assert (len(ec.zeroPadA) == 2)
def test_nchw_filter2x1_dilation(tensile_state, run_convolution_level):
z={} # problemType definition
conv = Convolution(z, 'ConvolutionForward',
config={'TensorAFormat': 'NCHW',
'TensorBFormat': 'KCYX',
'Filter': '2x1',
'Dilation': '1x2',
'PadStart': 'Nx0',
'PadEnd': 'Nx0',
})
log.debug(conv.printUsage(z))
if not tensile_state.args["no_conv_assertions"]:
filterDims = [3] if conv.unrollOnChannel else [4]
cdim = 4 if conv.unrollOnChannel else 3
assert(z['NumIndicesC']==3)
assert(z['IndexAssignmentsA']==filterDims + [0, cdim, 2])
assert(z['IndexAssignmentsB']==filterDims + [cdim, 1, 2])
assert(z['UseInitialStridesAB'])
assert(conv.solutionParms["AssertStrideAEqual"] == {1:1})
assert(conv.solutionParms["AssertStrideBEqual"] == {3:0})
assert(conv.solutionParms["AssertSizeEqual"] == {filterDims[0]:2})
solutionName = run_convolution_level.solution.__name__
if solutionName.startswith("asm") or solutionName == 'src1':
pytest.skip("skip configs w/o PBD")
run_convolution_level.func(conv, z, run_convolution_level.solution)
def test_nhwc_filter2x2(tensile_state, run_convolution_level):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NHWC',
'Filter': '3x2',
})
log.debug(conv.printUsage(z))
if not tensile_state.args["no_conv_assertions"]:
filterDims = [4, 3] if conv.unrollOnChannel else [5, 4]
cdim = 5 if conv.unrollOnChannel else 3
assert (z['NumIndicesC'] == 3)
assert (z['IndexAssignmentsA'] == [cdim] + filterDims + [1, 2])
assert (z['IndexAssignmentsB'] == filterDims + [cdim, 0, 2])
assert (not z['UseInitialStridesAB'])
assert (conv.solutionParms["AssertStrideAEqual"] == {0: 1})
assert (conv.solutionParms["AssertStrideBEqual"] == {0: 1, 4: 0})
assert (conv.solutionParms["AssertSizeEqual"] == {
filterDims[0]: 2,
filterDims[1]: 3
})
#skip since bug in asm output swap required by NHWC, impacts both source and asm
solutionName = run_convolution_level.solution.__name__
if solutionName.startswith("asm"):
pytest.skip("bug with asm NHWC")
def test_nchw_dilation_filter4x4_pad(tensile_state, run_convolution_level):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Filter': '4x4',
'PadStart': '2x2',
'PadEnd': '2x2',
})
log.debug(conv.printUsage(z))
if not tensile_state.args["no_conv_assertions"]:
(cdim, filterDims) = (5, [4, 3]) if conv.unrollOnChannel else (5,
[4, 3])
assert (z['NumIndicesC'] == 3)
assert (z['IndexAssignmentsA'] == filterDims + [0, cdim, 2])
assert (z['IndexAssignmentsB'] == filterDims + [cdim, 1, 2])
assert (z['UseInitialStridesAB'])
assert (conv.solutionParms["AssertStrideAEqual"] == {0: 2, 2: 1})
assert (conv.solutionParms["AssertStrideBEqual"] == {
0: 1,
filterDims[0]: 0
})
assert (conv.solutionParms["AssertSizeEqual"] == {
filterDims[0]: 1,
filterDims[1]: 1
})
run_convolution_level.func(conv, z, run_convolution_level.solution)
def test_simple(run_convolution_vs_contraction):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
})
log.debug(conv.printUsage(z))
run_convolution_vs_contraction(conv)
def test_spatial_unspecified():
z={} # problemType definition
conv = Convolution(z, 'ConvolutionForward',
config={'TensorAFormat': 'NCHW',
})
log.debug(conv.printUsage(z))
with pytest.raises(RuntimeError, match="ConvolutionConfig field 'spatial' == None"):
conv.makeProblem(n=64, c=1024, k=256, pcc=conv.cc)
def test_dilation2x3(run_convolution_vs_contraction):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Filter': '2x2',
'Dilation': '2x3',
})
log.debug(conv.printUsage(z))
run_convolution_vs_contraction(conv)
def test_mismatch():
z={} # problemType definition
conv = Convolution(z, 'ConvolutionForward',
config={'TensorAFormat': 'NCHW',
'Spatial' : '34x99',
})
log.debug(conv.printUsage(z))
pcc = ConvolutionConfig(spatial=[14,15])
with pytest.raises(RuntimeError, match="Mismatch between ConvolutionConfig value"):
conv.makeProblem(n=64, c=1024, k=256, pcc=pcc)
def test_pad0x1(run_convolution_vs_contraction):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Filter': '2x2',
'PadStart': '0x1',
'PadEnd': '0x1',
})
log.debug(conv.printUsage(z))
run_convolution_vs_contraction(conv)
def test_bad_invalid_list():
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Stride': '2x3',
})
log.debug(conv.printUsage(z))
e = [1, 2, 3, 4]
with pytest.raises(Exception, match="ConvProblem must be a dictionary"):
ConvProblem(e, conv)
def test_filter2x1(request, tensile_client_dir, tmp_path):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Filter': '2x1',
'Stride': '1x1',
'Dilation': '1x1',
'Spatial': '17x31',
})
log.debug(conv.printUsage(z))
def test_spatial_in():
z={} # problemType definition
conv = Convolution(z, 'ConvolutionForward',
config={'TensorAFormat': 'NCHW',
})
log.debug(conv.printUsage(z))
pcc = ConvolutionConfig(spatial=[14,15])
p = conv.makeProblem(n=64, c=1024, k=256, pcc=pcc)
assert(p[0] == [210, 256, 64, 1024])
assert(p[1] == [1, -1, -1])
assert(p[2] == [-1, -1, 0])
def test_simple(run_convolution_vs_contraction):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Filter': '1x1',
'Stride': '1x1',
'Dilation': '1x1',
'Spatial': '17x31',
})
log.debug(conv.printUsage(z))
run_convolution_vs_contraction(conv)
def test_nchw_defaults(tensile_state, run_convolution_level):
z = {} # problemType definition
conv = Convolution(z, 'ConvolutionForward', config={})
log.debug(conv.printUsage(z))
if not tensile_state.args["no_conv_assertions"]:
assert (z['NumIndicesC'] == 3)
assert (z['IndexAssignmentsA'] == [0, 3, 2])
assert (z['IndexAssignmentsB'] == [3, 1, 2])
assert (not z['UseInitialStridesAB'])
assert (conv.solutionParms["AssertStrideAEqual"] == {0: 1})
assert (conv.solutionParms["AssertStrideBEqual"] == {0: 1, 2: 0})
assert (conv.solutionParms["AssertSizeEqual"] == {})
run_convolution_level.func(conv, z, run_convolution_level.solution)
def test_stride():
z={} # problemType definition
conv = Convolution(z, 'ConvolutionForward',
config={'TensorAFormat': 'NCHW',
'Spatial' : '13x14',
'Stride' : '2x3',
})
log.debug(conv.printUsage(z))
p = conv.makeProblem(n=64, c=1024, k=256, pcc=conv.cc)
assert(p[0] == [4, 6, 256, 64, 1024])
assert(p[1] == [3, 28, -1, -1])
assert(p[2] == [-1, -1, 0])
def test_stride2x3_defaults():
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Stride': '2x3',
})
log.debug(conv.printUsage(z))
e = {'n': 64, 'c': 256, 'h': 20, 'w': 14, 'k': 1024}
ec = ConvProblem(e, conv)
assert (ec.sizes == (4, 10, e['k'], e['n'], e['c']))
assert (ec.stridesA == (3, 28, -1, -1))
def test_filter_stride_dilation_1(run_convolution_vs_contraction):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Filter': '6x7',
'Stride': '2x3',
'Dilation': '4x5',
'Spatial': '27x51',
})
log.debug(conv.printUsage(z))
run_convolution_vs_contraction(conv)
def test_stride2x3(request, tensile_client_dir, tmp_path):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Filter': '1x1',
'Stride': '2x3',
'Dilation': '1x1',
'Spatial': '17x31',
})
log.debug(conv.printUsage(z))
YamlBuilder.run_convolution_vs_contraction(request, conv, z,
tensile_client_dir, tmp_path)
def test_bad_missing_field():
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Stride': '2x3',
})
log.debug(conv.printUsage(z))
e = {'c': 256, 'h': 20, 'w': 14, 'k': 1024, 'x': 1, 'y': 1, 'u': 1, 'v': 1}
with pytest.raises(
Exception,
match="required ConvProblem field 'n' not present in ConvProblem"):
ConvProblem(e, conv)
def test_pad_4x1():
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
'Filter': '4x1',
'PadStart': 'Nx0',
'PadEnd': 'Nx0',
})
log.debug(conv.printUsage(z))
e = {'n': 1, 'c': 4, 'h': 12, 'w': 8, 'k': 1, 'p': 2, 'p_': 3}
ec = ConvProblem(e, conv)
assert (ec.zeroPadA == [[1, 4, 2, 3]])
def test_nchw_backwardweights_filter3x5(run_convolution_level):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionBackwardWeights',
config={
'TensorAFormat': 'NCHW',
'Filter': '3x5',
})
log.debug(conv.printUsage(z))
assert (z['NumIndicesC'] == 4)
assert (z['IndexAssignmentsA'] == [5, 0, 1, 2, 4])
assert (z['IndexAssignmentsB'] == [5, 3, 4])
#assert(z['SetConstStrideA']==[[3,1]])
assert (z['SetConstStrideB'] == [])
run_convolution_level(conv, z)
def test_nchw_backwardweights_defaults(run_convolution_level):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionBackwardWeights',
config={
'TensorAFormat': 'NCHW',
'Spatial': '14x14',
})
log.debug(conv.printUsage(z))
assert (z['NumIndicesC'] == 2)
assert (z['IndexAssignmentsA'] == [3, 0, 2])
assert (z['IndexAssignmentsB'] == [3, 1, 2])
assert (z['SetConstStrideA'] == [[3, 1]])
assert (z['SetConstStrideB'] == [])
run_convolution_level(conv, z)
def test_nchw_backwarddata_defaults(tensile_state, run_convolution_level):
z={} # problemType definition
conv = Convolution(z, 'ConvolutionBackwardData',
config={'TensorAFormat': 'NCHW',
'Spatial' : '14x14',
})
log.debug(conv.printUsage(z))
if not tensile_state.args["no_conv_assertions"]:
assert(z['NumIndicesC']==2)
assert(z['IndexAssignmentsA']==[3, 0, 2])
assert(z['IndexAssignmentsB']==[3, 1, 2])
#assert(conv.solutionParms["AssertStrideAEqual"] == "1:1,0:1")
#assert(conv.solutionParms["AssertStrideBEqual"] == "1:1")
assert(conv.solutionParms["AssertSizeEqual"] == {})
run_convolution_level.func(conv, z, run_convolution_level.solution)
def test_nchw_backwarddata_filter3x5(tensile_state, run_convolution_level):
z={} # problemType definition
conv = Convolution(z, 'ConvolutionBackwardData',
config={'TensorAFormat': 'NCHW',
'Filter': '3x5',
})
log.debug(conv.printUsage(z))
if not tensile_state.args["no_conv_assertions"]:
assert(z['NumIndicesC']==4)
assert(z['IndexAssignmentsA']==[5, 0, 1, 2, 4])
assert(z['IndexAssignmentsB']==[5, 3, 4])
#assert(conv.solutionParms["AssertStrideAEqual"] == "1:1,3:1,0:1")
#assert(conv.solutionParms["AssertStrideBEqual"] == "1:1")
assert(conv.solutionParms["AssertSizeEqual"] == {4:3,5:5})
run_convolution_level.func(conv, z, run_convolution_level.solution)
def test_ncdhw_packed_strides3d_defaults(run_convolution_level):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCDHW',
'Stride': 'NxNxN',
})
log.debug(conv.printUsage(z))
assert (z['NumIndicesC'] == 5)
assert (z['IndexAssignmentsA'] == [0, 1, 2, 5, 4])
assert (z['IndexAssignmentsB'] == [5, 3, 4])
assert (z['SetConstStrideA'] == [])
assert (z['SetConstStrideB'] == [[4, 0]])
run_convolution_level(conv, z)
def test_nchw_defaults(run_convolution_level):
z = {} # problemType definition
conv = Convolution(z,
'ConvolutionForward',
config={
'TensorAFormat': 'NCHW',
})
log.debug(conv.printUsage(z))
assert (z['NumIndicesC'] == 3)
assert (z['IndexAssignmentsA'] == [0, 3, 2])
assert (z['IndexAssignmentsB'] == [3, 1, 2])
assert (z['SetConstStrideA'] == [[0, 1]])
assert (z['SetConstStrideB'] == [[2, 0]])
assert (z['UseInitialStridesAB'] == 0)
run_convolution_level(conv, z)
