def find_outliers(mds, centers, center_info, ref_pop, options):
    """Finds the outliers for a given population.

    :param mds: the ``mds`` information about each samples.
    :param centers: the centers of the three reference population clusters.
    :param center_info: the label of the three reference population clusters.
    :param ref_pop: the reference population for which we need the outliers
                    from.
    :param options: the options

    :type mds: numpy.recarray
    :type centers: numpy.array
    :type center_info: dict
    :type ref_pop: str
    :type options: argparse.Namespace

    :returns: a :py:class:`set` of outliers from the ``ref_pop`` population.

    Perform a ``KMeans`` classification using the three centers from the three
    reference population cluster.

    Samples are outliers of the required reference population (``ref_pop``) if:

    * the sample is part of another reference population cluster;
    * the sample is an outlier of the desired reference population
      (``ref_pop``).

    A sample is an outlier of a given cluster :math:`C_j` if the distance
    between this sample and the center of the cluster :math:`C_j` (:math:`O_j`)
    is bigger than a constant times the cluster's standard deviation
    :math:`\\sigma_j`.

    .. math::
        \\sigma_j = \\sqrt{\\frac{\\sum{d(s_i,O_j)^2}}{||C_j|| - 1}}

    where :math:`||C_j||` is the number of samples in the cluster :math:`C_j`,
    and :math:`d(s_i,O_j)` is the distance between the sample :math:`s_i` and
    the center :math:`O_j` of the cluster :math:`C_j`.

    .. math::
        d(s_i, O_j) = \\sqrt{(x_{O_j} - x_{s_i})^2 + (y_{O_j} - y_{s_i})^2}

    Using a constant equals to one ensure we remove 100% of the outliers from
    the cluster. Using a constant of 1.6 or 1.9 ensures we remove 99% and 95%
    of outliers, respectively (an error rate of 1% and 5%, respectively).

    """
    # Importing matplotlib for plotting purposes
    import matplotlib as mpl
    if options.format != "X11" and mpl.get_backend() != "agg":
        mpl.use("Agg")
    import matplotlib.pyplot as plt
    if options.format != "X11":
        plt.ioff()
    import matplotlib.mlab as mlab

    from sklearn.cluster import KMeans
    from sklearn.metrics.pairwise import euclidean_distances

    # Formatting the data
    data = np.array(zip(mds["c1"], mds["c2"]))

    # Configuring and running the KMeans
    k_means = KMeans(init=centers, n_clusters=3, n_init=1)
    k_means.fit_predict(data)

    # Creating the figure and axes
    fig_before, axe_before = plt.subplots(1, 1)
    fig_after, axe_after = plt.subplots(1, 1)
    fig_outliers, axe_outliers = plt.subplots(1, 1)

    # Setting the axe
    axe_before.xaxis.set_ticks_position("bottom")
    axe_before.yaxis.set_ticks_position("left")
    axe_before.spines["top"].set_visible(False)
    axe_before.spines["right"].set_visible(False)
    axe_before.spines["bottom"].set_position(("outward", 9))
    axe_before.spines["left"].set_position(("outward", 9))
    axe_after.xaxis.set_ticks_position("bottom")
    axe_after.yaxis.set_ticks_position("left")
    axe_after.spines["top"].set_visible(False)
    axe_after.spines["right"].set_visible(False)
    axe_after.spines["bottom"].set_position(("outward", 9))
    axe_after.spines["left"].set_position(("outward", 9))
    axe_outliers.xaxis.set_ticks_position("bottom")
    axe_outliers.yaxis.set_ticks_position("left")
    axe_outliers.spines["top"].set_visible(False)
    axe_outliers.spines["right"].set_visible(False)
    axe_outliers.spines["bottom"].set_position(("outward", 9))
    axe_outliers.spines["left"].set_position(("outward", 9))

    # Setting the title and labels
    axe_before.set_title("Before finding outliers", weight="bold")
    axe_before.set_xlabel(options.xaxis)
    axe_before.set_ylabel(options.yaxis)
    axe_after.set_title("After finding outliers\n($> {} "
                        "\\sigma$)".format(options.multiplier), weight="bold")
    axe_after.set_xlabel(options.xaxis)
    axe_after.set_ylabel(options.yaxis)
    axe_outliers.set_title("Outliers", weight="bold")
    axe_outliers.set_xlabel(options.xaxis)
    axe_outliers.set_ylabel(options.yaxis)

    # The population name
    ref_pop_name = ["CEU", "YRI", "JPT-CHB"]

    # The colors
    colors = ["#CC0000", "#669900", "#0099CC"]
    outlier_colors = ["#FFCACA", "#E2F0B6", "#C5EAF8"]

    # Plotting each of the clusters with the initial center
    plots_before = []
    plots_after = []
    plots_outliers = []
    plot_outliers = None
    plot_not_outliers = None
    outliers_set = set()
    for label in xrange(3):
        # Subsetting the data
        subset_mds = mds[k_means.labels_ == label]
        subset_data = data[k_means.labels_ == label]

        # Plotting the cluster
        p, = axe_before.plot(subset_mds["c1"], subset_mds["c2"], "o",
                             mec=colors[label], mfc=colors[label], ms=2,
                             clip_on=False)
        plots_before.append(p)

        # Plotting the cluster center (the real one)
        axe_before.plot(centers[label][0], centers[label][1], "o",
                        mec="#000000", mfc="#FFBB33", ms=6, clip_on=False)

        # Computing the distances
        distances = euclidean_distances(subset_data, centers[label])

        # Finding the outliers (that are not in the reference populations
        sigma = np.sqrt(np.true_divide(np.sum(distances ** 2),
                                       len(distances) - 1))
        outliers = np.logical_and(
            (distances > options.multiplier * sigma).flatten(),
            subset_mds["pop"] != ref_pop_name[label],
        )
        logger.info("  - {} outliers for the {} cluster".format(
            np.sum(outliers),
            ref_pop_name[label],
        ))

        # Saving the outliers
        if ref_pop_name[label] != options.outliers_of:
            # This is not the population we want, hence everybody is an outlier
            # (we don't include the reference population).
            outlier_mds = subset_mds[subset_mds["pop"] != ref_pop_name[label]]
            outliers_set |= set([(i["fid"], i["iid"]) for i in outlier_mds])

            # Plotting all samples that are not part of the reference
            # populations
            axe_outliers.plot(
                subset_mds["c1"][subset_mds["pop"] != ref_pop_name[label]],
                subset_mds["c2"][subset_mds["pop"] != ref_pop_name[label]],
                "o",
                mec="#555555",
                mfc="#555555",
                ms=2,
                clip_on=False,
            )
        else:
            # This is the population we want, hence only the real outliers are
            # outliers (we don't include the reference population)
            outlier_mds = subset_mds[
                np.logical_and(subset_mds["pop"] != ref_pop_name[label],
                               outliers)
            ]

            # Plotting the outliers
            plot_outliers, = axe_outliers.plot(outlier_mds["c1"],
                                               outlier_mds["c2"], "o",
                                               mec="#555555", mfc="#555555",
                                               ms=2, clip_on=False)

            # Plotting the not outliers
            plot_not_outliers, = axe_outliers.plot(
                subset_mds["c1"][np.logical_and(
                        ~outliers,
                        subset_mds["pop"] != ref_pop_name[label]
                )],
                subset_mds["c2"][np.logical_and(
                    ~outliers,
                    subset_mds["pop"] != ref_pop_name[label]
                )],
                "o",
                mec="#FFBB33",
                mfc="#FFBB33",
                ms=2,
                clip_on=False,
            )
            outliers_set |= set([(i["fid"], i["iid"]) for i in outlier_mds])

        # Plotting the cluster (without outliers)
        p, = axe_after.plot(
            subset_mds[~outliers]["c1"],
            subset_mds[~outliers]["c2"],
            "o",
            mec=colors[label],
            mfc=colors[label],
            ms=2,
            clip_on=False,
        )
        plots_after.append(p)

        # Plotting the cluster (only outliers)
        axe_after.plot(subset_mds[outliers]["c1"], subset_mds[outliers]["c2"],
                       "o", mec=outlier_colors[label],
                       mfc=outlier_colors[label], ms=2, clip_on=False)

        # Plotting only the reference populations
        p, = axe_outliers.plot(
            subset_mds["c1"][subset_mds["pop"] == ref_pop_name[label]],
            subset_mds["c2"][subset_mds["pop"] == ref_pop_name[label]],
            "o",
            mec=colors[label],
            mfc=colors[label],
            ms=2,
            clip_on=False,
        )
        plots_outliers.append(p)

        # Plotting the cluster center (the real one)
        axe_after.plot(centers[label][0], centers[label][1], "o",
                       mec="#000000", mfc="#FFBB33", ms=6)

    # The legends
    axe_before.legend(plots_before, ref_pop_name, loc="best", numpoints=1,
                      fancybox=True, fontsize=8).get_frame().set_alpha(0.5)
    axe_after.legend(plots_after, ref_pop_name, loc="best", numpoints=1,
                     fancybox=True, fontsize=8).get_frame().set_alpha(0.5)
    axe_outliers.legend(plots_outliers + [plot_not_outliers, plot_outliers],
                        ref_pop_name + ["SOURCE", "OUTLIERS"], loc="best",
                        numpoints=1, fancybox=True,
                        fontsize=8).get_frame().set_alpha(0.5)

    # Saving the figure
    fig_before.savefig("{}.before.{}".format(options.out, options.format),
                       dpi=300)
    fig_after.savefig("{}.after.{}".format(options.out, options.format),
                      dpi=300)
    fig_outliers.savefig("{}.outliers.{}".format(options.out, options.format),
                         dpi=300)

    return outliers_set