Method forward

tensorrt_llm/_torch/modules/linear.py:2303–2339

(
        self,
        input: Union[torch.Tensor, Fp4QuantizedTensor],
        *,
        all_reduce_params: Optional[AllReduceParams] = None,
        lora_params: Optional[dict] = None,
        layer_idx: Optional[int] = None,
    )

            return False

    def forward(
        self,
        input: Union[torch.Tensor, Fp4QuantizedTensor],
        *,
        all_reduce_params: Optional[AllReduceParams] = None,
        lora_params: Optional[dict] = None,
        layer_idx: Optional[int] = None,
    ) -> torch.Tensor:
        if self.tp_mode == TensorParallelMode.ROW:
            use_fused_gemm_allreduce = self.use_fused_gemm_allreduce and lora_params is None
            if use_fused_gemm_allreduce and all_reduce_params is not None:
                use_fused_gemm_allreduce = all_reduce_params.enable_allreduce and all_reduce_params.fusion_op == AllReduceFusionOp.NONE

            bias = None if (self.tp_rank > 0) else self.bias
            if self.reduce_output:
                if use_fused_gemm_allreduce:
                    output = self.apply_linear_allreduce(
                        input, self.bias, layer_idx)
                else:
                    fuse_bias = self._maybe_fuse_bias_into_allreduce(
                        bias, all_reduce_params)
                    bias = None if fuse_bias else bias
                    output = self.apply_linear(input, bias, lora_params,
                                               layer_idx)
                    output = self.all_reduce(
                        output, all_reduce_params=all_reduce_params)
            else:
                output = self.apply_linear(input, bias, lora_params, layer_idx)
        elif self.tp_mode == TensorParallelMode.COLUMN:
            output = self.apply_linear(input, self.bias, lora_params, layer_idx)
            if self.gather_output:
                from ..distributed import allgather
                output = allgather(output, self.mapping)
        else:
            output = self.apply_linear(input, self.bias, lora_params, layer_idx)

        return output

    def load_weights(self,
                     weights: List[Dict],