def softplus_mapper(node: torch.fx.Node, _: torch.nn.Module) -> torch.fx.Node:
    """
    Maps torch.nn.functional.softplus to acc_ops.where, acc_ops.relu, acc_ops.exp, acc_ops.mul, acc_ops.add and acc_ops.div

    softplus(input, beta, threshold) = where(beta * input > threshold, relu(input), div(log(1 + exp(beta * input))), beta))

    torch.where(
        softplus_module.beta * sample_inputs[0] > softplus_module.threshold,
        sample_inputs[0].relu(),
        torch.div((1 + (softplus_module.beta * sample_inputs[0]).exp()).log(), softplus_module.beta),
    )

    """

    input_node = node.kwargs["input"]
    beta_node = node.kwargs["beta"]
    threshold_node = node.kwargs["threshold"]

    with node.graph.inserting_after(node):
        cond_mul_node = node.graph.call_function(
            mul,
            kwargs={
                "input": input_node,
                "other": beta_node,
            },
        )
        cond_mul_node.meta = input_node.meta.copy()

    with node.graph.inserting_after(cond_mul_node):
        gt_node = node.graph.call_function(
            gt,
            kwargs={
                "input": cond_mul_node,
                "other": threshold_node,
            },
        )
        gt_node.meta = input_node.meta.copy()

    with node.graph.inserting_after(gt_node):
        relu_node = node.graph.call_function(relu, kwargs={"input": input_node})
        relu_node.meta = input_node.meta.copy()

    with node.graph.inserting_after(relu_node):
        mul_node = node.graph.call_function(
            mul,
            kwargs={
                "input": input_node,
                "other": beta_node,
            },
        )
        mul_node.meta = input_node.meta.copy()

    with node.graph.inserting_after(mul_node):
        exp_node = node.graph.call_function(exp, kwargs={"input": mul_node})
        exp_node.meta = input_node.meta.copy()

    with node.graph.inserting_after(exp_node):
        add_node = node.graph.call_function(
            add,
            kwargs={
                "input": exp_node,
                "other": 1,
            },
        )
        add_node.meta = input_node.meta.copy()

    with node.graph.inserting_after(add_node):
        log_node = node.graph.call_function(log, kwargs={"input": add_node})
        log_node.meta = input_node.meta.copy()

    with node.graph.inserting_after(log_node):
        div_node = node.graph.call_function(
            div,
            kwargs={
                "input": log_node,
                "other": beta_node,
            },
        )
        div_node.meta = input_node.meta.copy()

    with node.graph.inserting_after(div_node):
        where_node = node.graph.call_function(
            where,
            kwargs={
                "condition": gt_node,
                "x": relu_node,
                "y": div_node,
            },
        )
        where_node.meta = div_node.meta.copy()

        return where_node

    Maps torch.nn.functional.softplus to acc_ops.where, acc_ops.relu, acc_ops.exp, acc_ops.mul, acc_ops.add and acc_ops.div

    softplus(input, beta, threshold) = where(beta * input > threshold, relu(input), div(log(1 + exp(beta * input))), beta))

    torch.where(
        softplus_module.beta * sample_inputs[0] > softplus_module.threshold,
        sample_inputs[0].relu(),
        torch.div((1 + (softplus_module.beta * sample_inputs[0]).exp()).log(), softplus_module.beta),
    )

    
fx2ait/fx2ait/acc_tracer/acc_ops.py