import numpy as np
from sklearn.cluster import KMeans
from sklearn.metrics.pairwise import euclidean_distances
from scipy.optimize import fixed_point

from afsfc.algorithms.fsfc.base import ClusteringFeatureSelector


class Lasso(ClusteringFeatureSelector):
    """
    Feature selection and clustering algorithm exploting the idea of L1-norm

    Simultaneously does clustering and computes "importance" of each feature for it

    Based on the article `"A framework for feature selection in clustering." <https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2930825/>`_

    Algorithm does clustering and selects features in the following way:
        1. Assigns equal weights to every feature
        2. Finds clusters according to weights of features
        3. Computes objective of the method
        4. Optimizes L1-penalty for found objective
        5. Computes new feature weights using objective
        6. If new weights equal to the old ones, break. Otherwise repeat steps 2-6
        7. Select top k features according to weights

    Parameters
    ----------
    k: int
        Number of features to select
    norm_constraint: float
        Constraint of L1-norm
    eps: float (default 1e-4)
        Precision of the algorithm
    max_iterations: int (default 100)
        Maximal number of iterations of algorithm
    """
    def __init__(self, k, norm_constraint, eps=1e-4, max_iterations=100):
        super().__init__(k)
        self.norm_constraint = norm_constraint
        self.max_iterations = max_iterations
        self.eps = eps

    def _calc_scores_and_labels(self, x):
        # Assign equal weights to features
        feature_weights = np.full([1, x.shape[1]], 1/np.sqrt(x.shape[1]))
        labels = None
        for it in range(self.max_iterations):
            # Find clusters in the feature space, normalised by weights
            weighted_samples = feature_weights * x
            labels = KMeans().fit_predict(weighted_samples)

            # Compute objective vector of the method
            objective = Lasso._calc_objective_vector(x, labels)

            # Find parameter of threshold that optimizes L1-norm
            root = fixed_point(
                lambda delta: self._function_to_optimize(objective, delta),
                0
            )
            # Compute new feature weights
            new_weights = Lasso._calc_new_feature_weights(objective, root)
            if np.linalg.norm(new_weights - feature_weights) < self.eps:
                break
            feature_weights = new_weights
        return feature_weights[0], labels

    @staticmethod
    def _calc_objective_vector(x, labels):
        clusters = {}
        for i, label in enumerate(labels):
            if label not in clusters:
                clusters[label] = []
            clusters[label].append(i)
        result = np.zeros([1, x.shape[1]])
        for i in range(x.shape[1]):
            feature = 0
            samples = x[:, i].T.reshape([x.shape[0], 1])
            for label, cluster in clusters.items():
                size = len(cluster)
                cluster_samples = samples[cluster]
                distances = euclidean_distances(cluster_samples)
                feature += np.sum(distances) / size
            result[0, i] = np.sum(euclidean_distances(samples)) / x.shape[0] - feature
        return result

    def _function_to_optimize(self, objective, delta):
        weights = Lasso._calc_new_feature_weights(objective, delta)
        return np.linalg.norm(weights, 1) - self.norm_constraint

    @staticmethod
    def _soft_threshold(x, delta):
        positive = np.clip(x, a_min=0, a_max=None)
        return np.sign(positive) * np.clip(np.abs(positive) - delta, a_min=0, a_max=None)

    @staticmethod
    def _calc_new_feature_weights(objective, delta):
        soft = Lasso._soft_threshold(objective, delta)
        normed = soft / np.linalg.norm(soft)
        return normed

f3a4a324209eb21774559a18068e98bc4c79629f
<mask token>


class Lasso(ClusteringFeatureSelector):
    <mask token>

    def __init__(self, k, norm_constraint, eps=0.0001, max_iterations=100):
        super().__init__(k)
        self.norm_constraint = norm_constraint
        self.max_iterations = max_iterations
        self.eps = eps

    def _calc_scores_and_labels(self, x):
        feature_weights = np.full([1, x.shape[1]], 1 / np.sqrt(x.shape[1]))
        labels = None
        for it in range(self.max_iterations):
            weighted_samples = feature_weights * x
            labels = KMeans().fit_predict(weighted_samples)
            objective = Lasso._calc_objective_vector(x, labels)
            root = fixed_point(lambda delta: self._function_to_optimize(
                objective, delta), 0)
            new_weights = Lasso._calc_new_feature_weights(objective, root)
            if np.linalg.norm(new_weights - feature_weights) < self.eps:
                break
            feature_weights = new_weights
        return feature_weights[0], labels
    <mask token>

    def _function_to_optimize(self, objective, delta):
        weights = Lasso._calc_new_feature_weights(objective, delta)
        return np.linalg.norm(weights, 1) - self.norm_constraint
    <mask token>

    @staticmethod
    def _calc_new_feature_weights(objective, delta):
        soft = Lasso._soft_threshold(objective, delta)
        normed = soft / np.linalg.norm(soft)
        return normed

<mask token>


class Lasso(ClusteringFeatureSelector):
    <mask token>

    def __init__(self, k, norm_constraint, eps=0.0001, max_iterations=100):
        super().__init__(k)
        self.norm_constraint = norm_constraint
        self.max_iterations = max_iterations
        self.eps = eps

    def _calc_scores_and_labels(self, x):
        feature_weights = np.full([1, x.shape[1]], 1 / np.sqrt(x.shape[1]))
        labels = None
        for it in range(self.max_iterations):
            weighted_samples = feature_weights * x
            labels = KMeans().fit_predict(weighted_samples)
            objective = Lasso._calc_objective_vector(x, labels)
            root = fixed_point(lambda delta: self._function_to_optimize(
                objective, delta), 0)
            new_weights = Lasso._calc_new_feature_weights(objective, root)
            if np.linalg.norm(new_weights - feature_weights) < self.eps:
                break
            feature_weights = new_weights
        return feature_weights[0], labels

    @staticmethod
    def _calc_objective_vector(x, labels):
        clusters = {}
        for i, label in enumerate(labels):
            if label not in clusters:
                clusters[label] = []
            clusters[label].append(i)
        result = np.zeros([1, x.shape[1]])
        for i in range(x.shape[1]):
            feature = 0
            samples = x[:, i].T.reshape([x.shape[0], 1])
            for label, cluster in clusters.items():
                size = len(cluster)
                cluster_samples = samples[cluster]
                distances = euclidean_distances(cluster_samples)
                feature += np.sum(distances) / size
            result[0, i] = np.sum(euclidean_distances(samples)) / x.shape[0
                ] - feature
        return result

    def _function_to_optimize(self, objective, delta):
        weights = Lasso._calc_new_feature_weights(objective, delta)
        return np.linalg.norm(weights, 1) - self.norm_constraint
    <mask token>

    @staticmethod
    def _calc_new_feature_weights(objective, delta):
        soft = Lasso._soft_threshold(objective, delta)
        normed = soft / np.linalg.norm(soft)
        return normed

<mask token>


class Lasso(ClusteringFeatureSelector):
    """
    Feature selection and clustering algorithm exploting the idea of L1-norm

    Simultaneously does clustering and computes "importance" of each feature for it

    Based on the article `"A framework for feature selection in clustering." <https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2930825/>`_

    Algorithm does clustering and selects features in the following way:
        1. Assigns equal weights to every feature
        2. Finds clusters according to weights of features
        3. Computes objective of the method
        4. Optimizes L1-penalty for found objective
        5. Computes new feature weights using objective
        6. If new weights equal to the old ones, break. Otherwise repeat steps 2-6
        7. Select top k features according to weights

    Parameters
    ----------
    k: int
        Number of features to select
    norm_constraint: float
        Constraint of L1-norm
    eps: float (default 1e-4)
        Precision of the algorithm
    max_iterations: int (default 100)
        Maximal number of iterations of algorithm
    """

    def __init__(self, k, norm_constraint, eps=0.0001, max_iterations=100):
        super().__init__(k)
        self.norm_constraint = norm_constraint
        self.max_iterations = max_iterations
        self.eps = eps

    def _calc_scores_and_labels(self, x):
        feature_weights = np.full([1, x.shape[1]], 1 / np.sqrt(x.shape[1]))
        labels = None
        for it in range(self.max_iterations):
            weighted_samples = feature_weights * x
            labels = KMeans().fit_predict(weighted_samples)
            objective = Lasso._calc_objective_vector(x, labels)
            root = fixed_point(lambda delta: self._function_to_optimize(
                objective, delta), 0)
            new_weights = Lasso._calc_new_feature_weights(objective, root)
            if np.linalg.norm(new_weights - feature_weights) < self.eps:
                break
            feature_weights = new_weights
        return feature_weights[0], labels

    @staticmethod
    def _calc_objective_vector(x, labels):
        clusters = {}
        for i, label in enumerate(labels):
            if label not in clusters:
                clusters[label] = []
            clusters[label].append(i)
        result = np.zeros([1, x.shape[1]])
        for i in range(x.shape[1]):
            feature = 0
            samples = x[:, i].T.reshape([x.shape[0], 1])
            for label, cluster in clusters.items():
                size = len(cluster)
                cluster_samples = samples[cluster]
                distances = euclidean_distances(cluster_samples)
                feature += np.sum(distances) / size
            result[0, i] = np.sum(euclidean_distances(samples)) / x.shape[0
                ] - feature
        return result

    def _function_to_optimize(self, objective, delta):
        weights = Lasso._calc_new_feature_weights(objective, delta)
        return np.linalg.norm(weights, 1) - self.norm_constraint

    @staticmethod
    def _soft_threshold(x, delta):
        positive = np.clip(x, a_min=0, a_max=None)
        return np.sign(positive) * np.clip(np.abs(positive) - delta, a_min=
            0, a_max=None)

    @staticmethod
    def _calc_new_feature_weights(objective, delta):
        soft = Lasso._soft_threshold(objective, delta)
        normed = soft / np.linalg.norm(soft)
        return normed

import numpy as np
from sklearn.cluster import KMeans
from sklearn.metrics.pairwise import euclidean_distances
from scipy.optimize import fixed_point
from afsfc.algorithms.fsfc.base import ClusteringFeatureSelector


class Lasso(ClusteringFeatureSelector):
    """
    Feature selection and clustering algorithm exploting the idea of L1-norm

    Simultaneously does clustering and computes "importance" of each feature for it

    Based on the article `"A framework for feature selection in clustering." <https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2930825/>`_

    Algorithm does clustering and selects features in the following way:
        1. Assigns equal weights to every feature
        2. Finds clusters according to weights of features
        3. Computes objective of the method
        4. Optimizes L1-penalty for found objective
        5. Computes new feature weights using objective
        6. If new weights equal to the old ones, break. Otherwise repeat steps 2-6
        7. Select top k features according to weights

    Parameters
    ----------
    k: int
        Number of features to select
    norm_constraint: float
        Constraint of L1-norm
    eps: float (default 1e-4)
        Precision of the algorithm
    max_iterations: int (default 100)
        Maximal number of iterations of algorithm
    """

    def __init__(self, k, norm_constraint, eps=0.0001, max_iterations=100):
        super().__init__(k)
        self.norm_constraint = norm_constraint
        self.max_iterations = max_iterations
        self.eps = eps

    def _calc_scores_and_labels(self, x):
        feature_weights = np.full([1, x.shape[1]], 1 / np.sqrt(x.shape[1]))
        labels = None
        for it in range(self.max_iterations):
            weighted_samples = feature_weights * x
            labels = KMeans().fit_predict(weighted_samples)
            objective = Lasso._calc_objective_vector(x, labels)
            root = fixed_point(lambda delta: self._function_to_optimize(
                objective, delta), 0)
            new_weights = Lasso._calc_new_feature_weights(objective, root)
            if np.linalg.norm(new_weights - feature_weights) < self.eps:
                break
            feature_weights = new_weights
        return feature_weights[0], labels

    @staticmethod
    def _calc_objective_vector(x, labels):
        clusters = {}
        for i, label in enumerate(labels):
            if label not in clusters:
                clusters[label] = []
            clusters[label].append(i)
        result = np.zeros([1, x.shape[1]])
        for i in range(x.shape[1]):
            feature = 0
            samples = x[:, i].T.reshape([x.shape[0], 1])
            for label, cluster in clusters.items():
                size = len(cluster)
                cluster_samples = samples[cluster]
                distances = euclidean_distances(cluster_samples)
                feature += np.sum(distances) / size
            result[0, i] = np.sum(euclidean_distances(samples)) / x.shape[0
                ] - feature
        return result

    def _function_to_optimize(self, objective, delta):
        weights = Lasso._calc_new_feature_weights(objective, delta)
        return np.linalg.norm(weights, 1) - self.norm_constraint

    @staticmethod
    def _soft_threshold(x, delta):
        positive = np.clip(x, a_min=0, a_max=None)
        return np.sign(positive) * np.clip(np.abs(positive) - delta, a_min=
            0, a_max=None)

    @staticmethod
    def _calc_new_feature_weights(objective, delta):
        soft = Lasso._soft_threshold(objective, delta)
        normed = soft / np.linalg.norm(soft)
        return normed

import numpy as np
from sklearn.cluster import KMeans
from sklearn.metrics.pairwise import euclidean_distances
from scipy.optimize import fixed_point

from afsfc.algorithms.fsfc.base import ClusteringFeatureSelector


class Lasso(ClusteringFeatureSelector):
    """
    Feature selection and clustering algorithm exploting the idea of L1-norm

    Simultaneously does clustering and computes "importance" of each feature for it

    Based on the article `"A framework for feature selection in clustering." <https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2930825/>`_

    Algorithm does clustering and selects features in the following way:
        1. Assigns equal weights to every feature
        2. Finds clusters according to weights of features
        3. Computes objective of the method
        4. Optimizes L1-penalty for found objective
        5. Computes new feature weights using objective
        6. If new weights equal to the old ones, break. Otherwise repeat steps 2-6
        7. Select top k features according to weights

    Parameters
    ----------
    k: int
        Number of features to select
    norm_constraint: float
        Constraint of L1-norm
    eps: float (default 1e-4)
        Precision of the algorithm
    max_iterations: int (default 100)
        Maximal number of iterations of algorithm
    """
    def __init__(self, k, norm_constraint, eps=1e-4, max_iterations=100):
        super().__init__(k)
        self.norm_constraint = norm_constraint
        self.max_iterations = max_iterations
        self.eps = eps

    def _calc_scores_and_labels(self, x):
        # Assign equal weights to features
        feature_weights = np.full([1, x.shape[1]], 1/np.sqrt(x.shape[1]))
        labels = None
        for it in range(self.max_iterations):
            # Find clusters in the feature space, normalised by weights
            weighted_samples = feature_weights * x
            labels = KMeans().fit_predict(weighted_samples)

            # Compute objective vector of the method
            objective = Lasso._calc_objective_vector(x, labels)

            # Find parameter of threshold that optimizes L1-norm
            root = fixed_point(
                lambda delta: self._function_to_optimize(objective, delta),
                0
            )
            # Compute new feature weights
            new_weights = Lasso._calc_new_feature_weights(objective, root)
            if np.linalg.norm(new_weights - feature_weights) < self.eps:
                break
            feature_weights = new_weights
        return feature_weights[0], labels

    @staticmethod
    def _calc_objective_vector(x, labels):
        clusters = {}
        for i, label in enumerate(labels):
            if label not in clusters:
                clusters[label] = []
            clusters[label].append(i)
        result = np.zeros([1, x.shape[1]])
        for i in range(x.shape[1]):
            feature = 0
            samples = x[:, i].T.reshape([x.shape[0], 1])
            for label, cluster in clusters.items():
                size = len(cluster)
                cluster_samples = samples[cluster]
                distances = euclidean_distances(cluster_samples)
                feature += np.sum(distances) / size
            result[0, i] = np.sum(euclidean_distances(samples)) / x.shape[0] - feature
        return result

    def _function_to_optimize(self, objective, delta):
        weights = Lasso._calc_new_feature_weights(objective, delta)
        return np.linalg.norm(weights, 1) - self.norm_constraint

    @staticmethod
    def _soft_threshold(x, delta):
        positive = np.clip(x, a_min=0, a_max=None)
        return np.sign(positive) * np.clip(np.abs(positive) - delta, a_min=0, a_max=None)

    @staticmethod
    def _calc_new_feature_weights(objective, delta):
        soft = Lasso._soft_threshold(objective, delta)
        normed = soft / np.linalg.norm(soft)
        return normed
