<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def mean_squared_error(data, ground_truth, mask=None, normalized=False, force_lower_is_better=True):
 r"""Return mean squared L2 distance between ``data`` and ``ground_truth``. See also `this Wikipedia article <https://en.wikipedia.org/wiki/Mean_squared_error>`_. Parameters data : `Tensor` or `array-like` Input data to compare to the ground truth. If not a `Tensor`, an unweighted tensor space will be assumed. ground_truth : `array-like` Reference to which ``data`` should be compared. mask : `array-like`, optional If given, ``data * mask`` is compared to ``ground_truth * mask``. normalized : bool, optional If ``True``, the output values are mapped to the interval :math:`[0, 1]` (see `Notes` for details). force_lower_is_better : bool, optional If ``True``, it is ensured that lower values correspond to better matches. For the mean squared error, this is already the case, and the flag is only present for compatibility to other figures of merit. Returns ------- mse : float FOM value, where a lower value means a better match. Notes ----- The FOM evaluates .. math:: \mathrm{MSE}(f, g) = \frac{\| f - g \|_2^2}{\| 1 \|_2^2}, where :math:`\| 1 \|^2_2` is the volume of the domain of definition of the functions. For :math:`\mathbb{R}^n` type spaces, this is equal to the number of elements :math:`n`. The normalized form is .. math:: \mathrm{MSE_N} = \frac{\| f - g \|_2^2}{(\| f \|_2 + \| g \|_2)^2}. The normalized variant takes values in :math:`[0, 1]`. """

    if not hasattr(data, 'space'):
        data = odl.vector(data)

    space = data.space
    ground_truth = space.element(ground_truth)

    l2norm = odl.solvers.L2Norm(space)

    if mask is not None:
        data = data * mask
        ground_truth = ground_truth * mask

    diff = data - ground_truth
    fom = l2norm(diff) ** 2

    if normalized:
        fom /= (l2norm(data) + l2norm(ground_truth)) ** 2
    else:
        fom /= l2norm(space.one()) ** 2

    # Ignore `force_lower_is_better` since that's already the case

    return fom