Thank you for clarification regarding requires_grad. It is really helpful.
I checked x(or input):
input.requires_grad False

The whole thing:
# Inherit from Function
class LinearFunction(torch.autograd.Function):

    # Note that both forward and backward are @staticmethods
    @staticmethod
    # bias is an optional argument
    def forward(ctx, input, weight, bias=None):
        print('input.requires_grad', input.requires_grad)
        ctx.save_for_backward(input, weight, bias)
        print('input forward', input)
        print('weight forward', weight)
        print('bias forward', bias)
        output = input.mm(weight.t())
        if bias is not None:
            output += bias.unsqueeze(0).expand_as(output)
        return output

    # This function has only a single output, so it gets only one gradient
    @staticmethod
    def backward(ctx, grad_output):
        # This is a pattern that is very convenient - at the top of backward
        # unpack saved_tensors and initialize all gradients w.r.t. inputs to
        # None. Thanks to the fact that additional trailing Nones are
        # ignored, the return statement is simple even when the function has
        # optional inputs.
        print('grad_output', grad_output)
        print('grad_output.shape', grad_output.shape)
        print('type(ctx)', type(ctx))
        input, weight, bias = ctx.saved_tensors
        print('ctx.saved_tensors', ctx.saved_tensors)
        print('input.shape', input.shape)
        print('weight.shape', weight.shape)
        print('bias.shape', bias.shape)
        grad_input = grad_weight = grad_bias = None

        # These needs_input_grad checks are optional and there only to
        # improve efficiency. If you want to make your code simpler, you can
        # skip them. Returning gradients for inputs that don't require it is
        # not an error.
        print('ctx.needs_input_grad', ctx.needs_input_grad)
        if ctx.needs_input_grad[0]:
            grad_input = grad_output.mm(weight)
            print('grad_input', grad_input)
        if ctx.needs_input_grad[1]:
            grad_weight = grad_output.t().mm(input)
            print('grad_weight', grad_weight)
        if bias is not None and ctx.needs_input_grad[2]:
            grad_bias = grad_output.sum(0).squeeze(0)
            print('grad_bias', grad_bias)

        return grad_input, grad_weight, grad_bias

input.requires_grad False
input forward tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]])
weight forward Parameter containing:
tensor([[-5.7689e-02, -7.1829e-02, -2.6084e-02],
        [-2.0893e-03,  7.3108e-02, -9.8120e-02],
        [ 7.9525e-02, -9.9841e-02,  2.9965e-02],
        [ 5.8336e-02, -6.8684e-02,  8.0132e-02],
        [-7.8534e-02, -6.5824e-02,  6.9786e-02],
        [ 3.1624e-02, -4.9671e-02,  9.5418e-02],
        [ 5.4930e-02, -3.5600e-02, -7.9666e-02],
        [-1.9675e-02,  5.5125e-02,  2.1277e-02],
        [ 7.9899e-02, -6.3545e-03,  7.5164e-02],
        [ 6.5107e-02, -1.1355e-02,  6.1582e-02],
        [ 5.7898e-02,  8.2228e-02, -2.8934e-04],
        [ 3.8152e-02, -8.8827e-02, -9.7715e-02],
        [ 5.0026e-02, -5.9546e-02,  6.7430e-03],
        [-4.7775e-03, -7.8560e-02,  6.5737e-02],
        [ 6.6842e-02, -4.8822e-02, -2.9546e-02],
        [ 1.7129e-02, -1.9333e-02, -6.0500e-03],
        [ 2.3933e-02,  1.8603e-02, -7.6528e-02],
        [-8.5194e-02,  2.3240e-03, -8.4081e-02],
        [ 6.4385e-02, -9.2458e-02, -2.6505e-02],
        [ 9.1981e-02,  7.0836e-02,  3.5892e-02],
        [ 9.9067e-02,  3.2538e-02, -4.0784e-02],
        [-1.9370e-02, -2.8337e-02,  7.1533e-02],
        [ 8.7615e-02,  7.4066e-02,  8.4684e-03],
        [-9.8254e-03, -6.5946e-02,  7.2230e-02],
        [ 4.4700e-02,  7.9217e-02, -8.4470e-02],
        [-7.5376e-02, -6.5382e-02,  2.3836e-02],
        [ 5.7385e-02, -1.5403e-02,  3.6721e-02],
        [ 5.8476e-02, -5.9563e-02, -8.3188e-02],
        [ 7.3825e-02, -7.6582e-02, -3.1223e-04],
        [-4.3375e-03,  5.8998e-02, -6.2707e-03],
        [ 9.0194e-02, -6.9641e-02, -6.6580e-02],
        [ 3.5148e-02, -7.3449e-02, -3.4645e-02],
        [-5.3004e-02,  8.5227e-02,  6.0224e-02],
        [ 6.7936e-02, -5.7037e-02, -1.3519e-02],
        [-2.3542e-02, -6.3962e-02,  7.6364e-02],
        [-1.1940e-02,  5.3724e-03, -5.2544e-02],
        [-2.9361e-02,  2.4697e-02,  9.7657e-02],
        [ 3.1170e-02,  5.1035e-03, -2.3094e-02],
        [-1.0187e-02,  5.2062e-02,  2.5158e-02],
        [-3.7078e-02, -1.0134e-02,  3.8032e-03],
        [ 8.8694e-02, -3.0750e-03,  2.4333e-02],
        [ 9.2952e-02, -7.6131e-02,  6.7218e-02],
        [-3.4485e-02, -1.3299e-02, -6.3930e-02],
        [-4.7276e-02, -3.5576e-02,  7.2038e-02],
        [ 5.9960e-02,  2.2295e-02, -4.2306e-02],
        [-9.7502e-02,  5.1908e-02,  3.0460e-02],
        [ 7.1249e-02, -3.8853e-02,  7.7737e-02],
        [ 6.4047e-02,  1.7193e-02,  6.2109e-03],
        [ 1.6491e-02, -8.0544e-02,  2.6576e-02],
        [-6.6234e-02,  9.5245e-02,  8.1419e-02],
        [-8.5292e-02, -5.5366e-02, -1.9801e-02],
        [-2.5768e-02,  6.0976e-02, -9.0075e-03],
        [-6.0146e-02,  8.7594e-02,  3.5786e-02],
        [ 6.1822e-02,  9.8115e-02, -2.8956e-02],
        [ 5.5727e-02, -7.2281e-03, -3.3081e-02],
        [ 9.9295e-02, -2.2229e-02,  1.7998e-02],
        [ 5.3005e-02,  3.3666e-03, -4.3881e-02],
        [-5.8789e-02,  6.7245e-02,  9.3645e-02],
        [ 1.5318e-03,  4.7252e-05,  3.1342e-02],
        [-9.4592e-02,  1.6203e-03,  6.7871e-02],
        [-8.1662e-02,  4.9619e-02, -3.4235e-02],
        [-4.7592e-03,  8.8230e-02, -7.0480e-02],
        [-8.4769e-02, -4.5581e-02, -9.5608e-02],
        [ 5.2312e-02, -3.2134e-02, -9.9308e-02]], requires_grad=True)
bias forward Parameter containing:
tensor([ 0.0021, -0.0651,  0.0892, -0.0630,  0.0621,  0.0624,  0.0788, -0.0088,
         0.0874, -0.0747, -0.0461, -0.0674,  0.0427,  0.0846, -0.0922, -0.0300,
         0.0652,  0.0913,  0.0199, -0.0351,  0.0483,  0.0904,  0.0747, -0.0173,
        -0.0394,  0.0115,  0.0767,  0.0386,  0.0785,  0.0339, -0.0191,  0.0577,
        -0.0916,  0.0067,  0.0178,  0.0637, -0.0571, -0.0420,  0.0207, -0.0514,
        -0.0505, -0.0063, -0.0777,  0.0068,  0.0712,  0.0565,  0.0319, -0.0343,
        -0.0751,  0.0895,  0.0987,  0.0345, -0.0811, -0.0717, -0.0697, -0.0729,
        -0.0520,  0.0426, -0.0916, -0.0618, -0.0259,  0.0824, -0.0973,  0.0086],
       requires_grad=True)
input.requires_grad True
input forward tensor([[-0.1535, -0.0922,  0.0989,  ...,  0.0953, -0.3233, -0.0706],
        [-0.1535, -0.0922,  0.0989,  ...,  0.0953, -0.3233, -0.0706],
        [-0.1535, -0.0922,  0.0989,  ...,  0.0953, -0.3233, -0.0706],
        ...,
        [-0.1535, -0.0922,  0.0989,  ...,  0.0953, -0.3233, -0.0706],
        [-0.1535, -0.0922,  0.0989,  ...,  0.0953, -0.3233, -0.0706],
        [-0.1535, -0.0922,  0.0989,  ...,  0.0953, -0.3233, -0.0706]],
       grad_fn=<LinearFunctionBackward>)
weight forward Parameter containing:
tensor([[-0.0373, -0.0337, -0.0244,  ...,  0.0944, -0.0116,  0.0215],
        [ 0.0040, -0.0831,  0.0885,  ...,  0.0085, -0.0741,  0.0127],
        [ 0.0498, -0.0686,  0.0238,  ..., -0.0737, -0.0593, -0.0929],
        ...,
        [ 0.0007,  0.0510, -0.0142,  ...,  0.0279, -0.0415, -0.0512],
        [-0.0253, -0.0744, -0.0856,  ..., -0.0384, -0.0035,  0.0923],
        [-0.0838,  0.0584,  0.0247,  ..., -0.0630,  0.0615,  0.0827]],
       requires_grad=True)
bias forward Parameter containing:
tensor([-6.3925e-02,  9.5133e-02,  6.3453e-03, -9.6132e-02, -7.5031e-02,
         7.1918e-02,  6.5596e-02,  2.9120e-02, -3.0924e-02, -3.1459e-02,
         8.3751e-02, -5.3198e-02,  2.2847e-02,  5.0141e-02,  1.7165e-02,
         9.5857e-02,  4.8013e-02, -1.5712e-02, -9.6951e-02,  6.9367e-03,
         6.5624e-03,  2.5855e-02, -7.5122e-02, -3.0202e-02, -6.7543e-02,
        -4.3585e-02,  9.0823e-06, -5.5203e-02, -9.5422e-02,  2.1666e-02,
        -7.3739e-03, -5.1144e-02, -1.3289e-03, -8.6629e-02, -9.3888e-02,
        -5.1129e-02, -3.5457e-02, -1.9761e-02, -4.0732e-02, -7.1337e-02,
         8.7817e-03, -8.5516e-02, -9.5054e-02, -9.8342e-02,  5.7102e-02,
        -9.9832e-02, -5.9283e-02,  2.8818e-02,  1.3624e-02,  3.7801e-02,
        -3.4223e-02, -3.0157e-02,  1.8073e-02,  7.5750e-02,  7.9041e-03,
        -8.0859e-02, -9.5542e-02, -1.1279e-02,  1.0384e-02, -5.2687e-02,
         4.8081e-02, -2.6380e-02,  6.3792e-02, -3.4629e-02],
       requires_grad=True)