Python Placeholder.value示例

示例#1

文件： dilated_convolution_2d_function_test.py 项目： fossabot/hash2face

def test_with_placeholder():
    link = chainer.links.DilatedConvolution2D(None, 16, ksize=3, stride=1, pad=1, dilate=2)
    vx = chainer.Variable(np.random.rand(1, 3, 16, 16).astype(np.float32))
    vy = link(vx)

    N = Placeholder(label="N")
    H = Placeholder(label="H")
    W = Placeholder(label="W")
    px = PlaceholderVariable([N, 3, H, W])
    py = link(px)

    graph = ChainerConverter().convert([px], [py])

    x = graph.inputs[0]
    y = graph.outputs[0]

    N.value = 1
    H.value = 16
    W.value = 16
    generate_kernel_test_case(
        description=f"[chainer] L.DilatedConvolution2D with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={x: vx.data},
        expected={y: vy.data},
        EPS=1e-2
    )

示例#2

def test_with_placeholder():
    vx1 = chainer.Variable(np.random.rand(2, 10, 4, 5).astype(np.float32))
    vx2 = chainer.Variable(np.random.rand(2, 15, 4, 5).astype(np.float32))
    vy = chainer.functions.concat([vx1, vx2], axis=1)

    N = Placeholder(label="N")
    C1 = Placeholder(label="C1")
    C2 = Placeholder(label="C2")
    H = Placeholder(label="H")
    W = Placeholder(label="W")
    px1 = PlaceholderVariable([N, C1, H, W])
    px2 = PlaceholderVariable([N, C2, H, W])
    py = chainer.functions.concat([px1, px2], axis=1)

    graph = ChainerConverter().convert([px1, px2], [py])

    N.value = 2
    C1.value = 10
    C2.value = 15
    H.value = 4
    W.value = 5
    generate_kernel_test_case(
        description=f"[chainer] F.concat with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={
            graph.inputs[0]: vx1.data,
            graph.inputs[1]: vx2.data
        },
        expected={graph.outputs[0]: vy.data},
    )

示例#3

文件： matmul_test.py 项目： fossabot/hash2face

def test_with_placeholder():
    vx1 = chainer.Variable(np.random.rand(10, 12).astype(np.float32) * 2 - 1)
    vx2 = chainer.Variable(np.random.rand(12, 14).astype(np.float32) * 2 - 1)
    vy = chainer.functions.matmul(vx1, vx2, False, False)

    M = Placeholder(label="M")
    K = Placeholder(label="K")
    N = Placeholder(label="N")
    px1 = PlaceholderVariable([M, K])
    px2 = PlaceholderVariable([K, N])
    py = chainer.functions.matmul(px1, px2, False, False)

    graph = ChainerConverter().convert([px1, px2], [py])

    M.value = 10
    K.value = 12
    N.value = 14
    generate_kernel_test_case(
        description=f"[chainer] F.matmul with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={
            graph.inputs[0]: vx1.data,
            graph.inputs[1]: vx2.data
        },
        expected={graph.outputs[0]: vy.data})

示例#4

文件： local_response_normalization_test.py 项目： fossabot/hash2face

def test_with_placeholder():
    vx = chainer.Variable(np.random.rand(1, 3, 16, 16).astype(np.float32))
    vy = chainer.functions.local_response_normalization(vx)

    N = Placeholder(label="N")
    C = Placeholder(label="C")
    H = Placeholder(label="H")
    W = Placeholder(label="W")
    px = PlaceholderVariable([N, C, H, W])
    py = chainer.functions.local_response_normalization(px)

    graph = ChainerConverter().convert([px], [py])

    x = graph.inputs[0]
    y = graph.outputs[0]

    N.value = 1
    C.value = 3
    H.value = 16
    W.value = 16
    generate_kernel_test_case(
        description=
        f"[chainer] F.local_response_normalization with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={x: vx.data},
        expected={y: vy.data},
    )

示例#5

文件： split_axis_test.py 项目： fossabot/hash2face

def test_with_placeholder():
    vx = chainer.Variable(np.random.rand(2, 20, 4, 5).astype(np.float32))
    vy1, vy2, vy3 = chainer.functions.split_axis(vx, [5, 15], 1)

    N = Placeholder(label="N")
    H = Placeholder(label="H")
    W = Placeholder(label="W")
    px = PlaceholderVariable([N, 20, H, W])
    py1, py2, py3 = chainer.functions.split_axis(px, [5, 15], 1)

    graph = ChainerConverter().convert([px], [py1, py2, py3])

    N.value = 2
    H.value = 4
    W.value = 5
    generate_kernel_test_case(
        description=f"[chainer] F.split_axis with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={graph.inputs[0]: vx.data},
        expected={
            graph.outputs[0]: vy1.data,
            graph.outputs[1]: vy2.data,
            graph.outputs[2]: vy3.data
        },
    )

示例#6

def test_with_placeholder():
    link = chainer.links.BatchNormalization(size=3)
    vx = chainer.Variable(np.random.rand(1, 3, 16, 16).astype(np.float32))
    with chainer.using_config('train', False):
        vy = link(vx)

    N = Placeholder(label="N")
    H = Placeholder(label="H")
    W = Placeholder(label="W")
    px = PlaceholderVariable([N, 3, H, W])
    with chainer.using_config('train', False):
        py = link(px)

    graph = ChainerConverter().convert([px], [py])

    x = graph.inputs[0]
    y = graph.outputs[0]

    N.value = 1
    H.value = 16
    W.value = 16
    generate_kernel_test_case(
        description=f"[chainer] L.FixedBatchNormalization with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={x: vx.data},
        expected={y: vy.data},
    )

示例#7

文件： minimum_test.py 项目： fossabot/hash2face

def test_with_placeholder():
    vx0 = chainer.Variable(np.random.rand(10, 11, 12).astype(np.float32))
    vx1 = chainer.Variable(np.random.rand(10, 11, 12).astype(np.float32))
    vy = chainer.functions.minimum(vx0, vx1)

    A = Placeholder(label="A")
    B = Placeholder(label="B")
    C = Placeholder(label="C")
    px0 = PlaceholderVariable([A, B, C])
    px1 = PlaceholderVariable([A, B, C])
    py = chainer.functions.minimum(px0, px1)

    graph = ChainerConverter().convert([px0, px1], [py])

    A.value = 10
    B.value = 11
    C.value = 12
    generate_kernel_test_case(
        description=f"[chainer] F.minimum with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={
            graph.inputs[0]: vx0.data,
            graph.inputs[1]: vx1.data
        },
        expected={graph.outputs[0]: vy.data},
    )

示例#8

文件： expand_dims_test.py 项目： fossabot/hash2face

def test_with_placeholder():
    vx = chainer.Variable(np.random.rand(2, 3, 4, 5).astype(np.float32))
    vy = chainer.functions.expand_dims(vx, axis=1)

    N = Placeholder(label="N")
    C = Placeholder(label="C")
    H = Placeholder(label="H")
    W = Placeholder(label="W")
    px = PlaceholderVariable([N, C, H, W])
    py = chainer.functions.expand_dims(px, axis=1)

    graph = ChainerConverter().convert([px], [py])

    x = graph.inputs[0]
    y = graph.outputs[0]

    N.value = 2
    C.value = 3
    H.value = 4
    W.value = 5
    generate_kernel_test_case(
        description=f"[chainer] F.expand_dims with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={x: vx.data},
        expected={y: vy.data},
    )

示例#9

文件： space2depth_test.py 项目： fossabot/hash2face

def test_with_placeholder():
    vx = chainer.Variable(np.random.rand(2, 5, 4, 8).astype(np.float32))
    vy = chainer.functions.space2depth(vx, r=2)

    N = Placeholder(label="N")
    C = Placeholder(label="C")
    px = PlaceholderVariable([N, C, 4, 8])
    py = chainer.functions.space2depth(px, r=2)

    graph = ChainerConverter().convert([px], [py])

    N.value = 2
    C.value = 5
    generate_kernel_test_case(
        description=f"[chainer] F.space2depth with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={graph.inputs[0]: vx.data},
        expected={graph.outputs[0]: vy.data},
    )

示例#10

def test_with_placeholder():
    vx = chainer.Variable(np.random.rand(10, 11, 12).astype(np.float32))
    vy = chainer.functions.logsumexp(vx, axis=1)

    A = Placeholder(label="A")
    C = Placeholder(label="C")
    px = PlaceholderVariable([A, 11, C])
    py = chainer.functions.logsumexp(px, axis=1)

    graph = ChainerConverter().convert([px], [py])

    A.value = 10
    C.value = 12
    generate_kernel_test_case(
        description=f"[chainer] F.logsumexp with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={graph.inputs[0]: vx.data},
        expected={graph.outputs[0]: vy.data},
        EPS=1e-2)

示例#11

def test_with_placeholder():
    vx = chainer.Variable(np.random.rand(1, 3, 16, 16).astype(np.float32))
    vy = vx ** 2

    H = Placeholder(label="H")
    W = Placeholder(label="W")
    px = PlaceholderVariable([1, 3, H, W])
    py = px ** 2

    graph = ChainerConverter().convert([px], [py])

    H.value = 16
    W.value = 16
    generate_kernel_test_case(
        description=f"[chainer] F.PowVarConst with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={graph.inputs[0]: vx.data},
        expected={graph.outputs[0]: vy.data}
    )

示例#12

文件： unpooling_2d_test.py 项目： fossabot/hash2face

def test_with_placeholder():
    vx = chainer.Variable(np.random.rand(2, 16, 7, 7).astype(np.float32))
    vy = chainer.functions.unpooling_2d(vx, ksize=3, stride=2, pad=0)

    N = Placeholder(label="N")
    C = Placeholder(label="C")
    px = PlaceholderVariable([N, C, 7, 7])
    py = chainer.functions.unpooling_2d(px, ksize=3, stride=2, pad=0)

    graph = ChainerConverter().convert([px], [py])

    N.value = 2
    C.value = 16
    generate_kernel_test_case(
        description=f"[chainer] F.unpooling_2d with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={graph.inputs[0]: vx.data},
        expected={graph.outputs[0]: vy.data},
    )

示例#13

文件： mat_mul_var_var_test.py 项目： fossabot/hash2face

def test_with_placeholder():
    vx1 = chainer.Variable(np.random.rand(2, 8).astype(np.float32))
    vx2 = chainer.Variable(np.random.rand(8, 6).astype(np.float32))
    vy = vx1 @ vx2

    M = Placeholder(label="M")
    N = Placeholder(label="N")
    px1 = PlaceholderVariable([M, 8])
    px2 = PlaceholderVariable([8, N])
    py = px1 @ px2

    graph = ChainerConverter().convert([px1, px2], [py])

    M.value = 2
    N.value = 6
    generate_kernel_test_case(
        description=f"[chainer] F.MatMulVarVar with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={graph.inputs[0]: vx1.data, graph.inputs[1]: vx2.data},
        expected={graph.outputs[0]: vy.data}
    )

示例#14

文件： softplus_test.py 项目： fossabot/hash2face

def test_with_placeholder():
    vx = chainer.Variable(np.random.rand(10, 11, 12).astype(np.float32))
    vy = chainer.functions.softplus(vx, beta=1.0)

    A = Placeholder(label="A")
    B = Placeholder(label="B")
    C = Placeholder(label="C")
    px = PlaceholderVariable([A, B, C])
    py = chainer.functions.softplus(px, beta=1.0)

    graph = ChainerConverter().convert([px], [py])

    A.value = 10
    B.value = 11
    C.value = 12
    generate_kernel_test_case(
        description=f"[chainer] F.softplus with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={graph.inputs[0]: vx.data},
        expected={graph.outputs[0]: vy.data},
    )

示例#15

def test_with_placeholder():
    vx = chainer.Variable(np.random.rand(2, 1, 4, 1).astype(np.float32))
    vy = chainer.functions.squeeze(vx, axis=None)

    N = Placeholder(label="N")
    C = Placeholder(label="C")
    H = Placeholder(label="H")
    W = Placeholder(label="W")
    px = PlaceholderVariable([N, C, H, W])
    py = chainer.functions.squeeze(px, axis=None)

    graph = ChainerConverter().convert([px], [py])

    N.value = 2
    C.value = 1
    H.value = 4
    W.value = 1
    generate_kernel_test_case(
        description=f"[chainer] F.squeeze with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={graph.inputs[0]: vx.data},
        expected={graph.outputs[0]: vy.data},
    )

示例#16

def test_with_placeholder():
    link = chainer.links.Linear(16, 32)
    vx = chainer.Variable(np.random.rand(2, 16).astype(np.float32))
    vy = link(vx)

    N = Placeholder(label="N")
    px = PlaceholderVariable([N, 16])
    py = link(px)

    graph = ChainerConverter().convert([px], [py])

    N.value = 2
    generate_kernel_test_case(
        description=f"[chainer] L.Linear with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={graph.inputs[0]: vx.data},
        expected={graph.outputs[0]: vy.data},
    )

示例#17

文件： mat_mul_constant_test.py 项目： fossabot/hash2face

def test_with_placeholder():
    rhs = np.random.rand(8, 4)

    vx = chainer.Variable(np.random.rand(2, 8).astype(np.float32))
    vy = vx @ rhs

    M = Placeholder(label="M")
    px = PlaceholderVariable([M, 8])
    py = px @ rhs

    graph = ChainerConverter().convert([px], [py])

    x = graph.inputs[0]
    y = graph.outputs[0]

    M.value = 2
    generate_kernel_test_case(
        description=f"[chainer] F.MatMulVarConstant with placeholder",
        graph=graph,
        backend=["webgpu", "webassembly"],
        inputs={x: vx.data},
        expected={y: vy.data},
    )