tsam 2.1.0__py3-none-any.whl → 2.3.2__py3-none-any.whl

tsam/periodAggregation.py

@@ -1,141 +1,141 @@
-# -*- coding: utf-8 -*-
-
-import numpy as np
-from tsam.representations import representations
-
-
-def aggregatePeriods(
-    candidates,
-    n_clusters=8,
-    n_iter=100,
-    clusterMethod="k_means",
-    solver="cbc",
-    representationMethod=None,
-    representationDict=None,
-    distributionPeriodWise=True,
-    timeStepsPerPeriod=None,
-):
-    """
-    Clusters the data based on one of the cluster methods:
-    'averaging', 'k_means', 'exact k_medoid' or 'hierarchical'
-
-    :param candidates: Dissimilarity matrix where each row represents a candidate. required
-    :type candidates: np.ndarray
-
-    :param n_clusters: Number of aggregated cluster. optional (default: 8)
-    :type n_clusters: integer
-
-    :param n_iter: Only required for the number of starts of the k-mean algorithm. optional (default: 10)
-    :type n_iter: integer
-
-    :param clusterMethod: Chosen clustering algorithm. Possible values are
-        'averaging','k_means','exact k_medoid' or 'hierarchical'. optional (default: 'k_means')
-    :type clusterMethod: string
-    """
-
-    # cluster the data
-    if clusterMethod == "averaging":
-        n_sets = len(candidates)
-        if n_sets % n_clusters == 0:
-            cluster_size = int(n_sets / n_clusters)
-            clusterOrder = [
-                [n_cluster] * cluster_size for n_cluster in range(n_clusters)
-            ]
-        else:
-            cluster_size = int(n_sets / n_clusters)
-            clusterOrder = [
-                [n_cluster] * cluster_size for n_cluster in range(n_clusters)
-            ]
-            clusterOrder.append(
-                [n_clusters - 1] * int(n_sets - cluster_size * n_clusters)
-            )
-        clusterOrder = np.hstack(np.array(clusterOrder))
-        clusterCenters, clusterCenterIndices = representations(
-            candidates,
-            clusterOrder,
-            default="meanRepresentation",
-            representationMethod=representationMethod,
-            representationDict=representationDict,
-            distributionPeriodWise=distributionPeriodWise,
-            timeStepsPerPeriod=timeStepsPerPeriod,
-        )
-
-    if clusterMethod == "k_means":
-        from sklearn.cluster import KMeans
-
-        k_means = KMeans(n_clusters=n_clusters, max_iter=1000, n_init=n_iter, tol=1e-4)
-
-        clusterOrder = k_means.fit_predict(candidates)
-        # get with own mean representation to avoid numerical trouble caused by sklearn
-        clusterCenters, clusterCenterIndices = representations(
-            candidates,
-            clusterOrder,
-            default="meanRepresentation",
-            representationMethod=representationMethod,
-            representationDict=representationDict,
-            distributionPeriodWise=distributionPeriodWise,
-            timeStepsPerPeriod=timeStepsPerPeriod,
-        )
-
-    if clusterMethod == "k_medoids":
-        from tsam.utils.k_medoids_exact import KMedoids
-
-        k_medoid = KMedoids(n_clusters=n_clusters, solver=solver)
-
-        clusterOrder = k_medoid.fit_predict(candidates)
-        clusterCenters, clusterCenterIndices = representations(
-            candidates,
-            clusterOrder,
-            default="medoidRepresentation",
-            representationMethod=representationMethod,
-            representationDict=representationDict,
-            distributionPeriodWise=distributionPeriodWise,
-            timeStepsPerPeriod=timeStepsPerPeriod,
-        )
-
-    if clusterMethod == "k_maxoids":
-        from tsam.utils.k_maxoids import KMaxoids
-
-        k_maxoid = KMaxoids(n_clusters=n_clusters, solver=solver)
-
-        clusterOrder = k_maxoid.fit_predict(candidates)
-        clusterCenters, clusterCenterIndices = representations(
-            candidates,
-            clusterOrder,
-            default="maxoidRepresentation",
-            representationMethod=representationMethod,
-            representationDict=representationDict,
-            distributionPeriodWise=distributionPeriodWise,
-            timeStepsPerPeriod=timeStepsPerPeriod,
-        )
-
-    if clusterMethod == "hierarchical" or clusterMethod == "adjacent_periods":
-        if n_clusters == 1:
-            clusterOrder = np.asarray([0] * len(candidates))
-        else:
-            from sklearn.cluster import AgglomerativeClustering
-
-            if clusterMethod == "hierarchical":
-                clustering = AgglomerativeClustering(
-                    n_clusters=n_clusters, linkage="ward"
-                )
-            elif clusterMethod == "adjacent_periods":
-                adjacencyMatrix = np.eye(len(candidates), k=1) + np.eye(
-                    len(candidates), k=-1
-                )
-                clustering = AgglomerativeClustering(
-                    n_clusters=n_clusters, linkage="ward", connectivity=adjacencyMatrix
-                )
-            clusterOrder = clustering.fit_predict(candidates)
-        # represent hierarchical aggregation with medoid
-        clusterCenters, clusterCenterIndices = representations(
-            candidates,
-            clusterOrder,
-            default="medoidRepresentation",
-            representationMethod=representationMethod,
-            representationDict=representationDict,
-            distributionPeriodWise=distributionPeriodWise,
-            timeStepsPerPeriod=timeStepsPerPeriod,
-        )
-
-    return clusterCenters, clusterCenterIndices, clusterOrder
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from tsam.representations import representations
+
+
+def aggregatePeriods(
+    candidates,
+    n_clusters=8,
+    n_iter=100,
+    clusterMethod="k_means",
+    solver="highs",
+    representationMethod=None,
+    representationDict=None,
+    distributionPeriodWise=True,
+    timeStepsPerPeriod=None,
+):
+    """
+    Clusters the data based on one of the cluster methods:
+    'averaging', 'k_means', 'exact k_medoid' or 'hierarchical'
+
+    :param candidates: Dissimilarity matrix where each row represents a candidate. required
+    :type candidates: np.ndarray
+
+    :param n_clusters: Number of aggregated cluster. optional (default: 8)
+    :type n_clusters: integer
+
+    :param n_iter: Only required for the number of starts of the k-mean algorithm. optional (default: 10)
+    :type n_iter: integer
+
+    :param clusterMethod: Chosen clustering algorithm. Possible values are
+        'averaging','k_means','exact k_medoid' or 'hierarchical'. optional (default: 'k_means')
+    :type clusterMethod: string
+    """
+
+    # cluster the data
+    if clusterMethod == "averaging":
+        n_sets = len(candidates)
+        if n_sets % n_clusters == 0:
+            cluster_size = int(n_sets / n_clusters)
+            clusterOrder = [
+                [n_cluster] * cluster_size for n_cluster in range(n_clusters)
+            ]
+        else:
+            cluster_size = int(n_sets / n_clusters)
+            clusterOrder = [
+                [n_cluster] * cluster_size for n_cluster in range(n_clusters)
+            ]
+            clusterOrder.append(
+                [n_clusters - 1] * int(n_sets - cluster_size * n_clusters)
+            )
+        clusterOrder = np.hstack(np.array(clusterOrder, dtype=object))
+        clusterCenters, clusterCenterIndices = representations(
+            candidates,
+            clusterOrder,
+            default="meanRepresentation",
+            representationMethod=representationMethod,
+            representationDict=representationDict,
+            distributionPeriodWise=distributionPeriodWise,
+            timeStepsPerPeriod=timeStepsPerPeriod,
+        )
+
+    if clusterMethod == "k_means":
+        from sklearn.cluster import KMeans
+
+        k_means = KMeans(n_clusters=n_clusters, max_iter=1000, n_init=n_iter, tol=1e-4)
+
+        clusterOrder = k_means.fit_predict(candidates)
+        # get with own mean representation to avoid numerical trouble caused by sklearn
+        clusterCenters, clusterCenterIndices = representations(
+            candidates,
+            clusterOrder,
+            default="meanRepresentation",
+            representationMethod=representationMethod,
+            representationDict=representationDict,
+            distributionPeriodWise=distributionPeriodWise,
+            timeStepsPerPeriod=timeStepsPerPeriod,
+        )
+
+    if clusterMethod == "k_medoids":
+        from tsam.utils.k_medoids_exact import KMedoids
+
+        k_medoid = KMedoids(n_clusters=n_clusters, solver=solver)
+
+        clusterOrder = k_medoid.fit_predict(candidates)
+        clusterCenters, clusterCenterIndices = representations(
+            candidates,
+            clusterOrder,
+            default="medoidRepresentation",
+            representationMethod=representationMethod,
+            representationDict=representationDict,
+            distributionPeriodWise=distributionPeriodWise,
+            timeStepsPerPeriod=timeStepsPerPeriod,
+        )
+
+    if clusterMethod == "k_maxoids":
+        from tsam.utils.k_maxoids import KMaxoids
+
+        k_maxoid = KMaxoids(n_clusters=n_clusters)
+
+        clusterOrder = k_maxoid.fit_predict(candidates)
+        clusterCenters, clusterCenterIndices = representations(
+            candidates,
+            clusterOrder,
+            default="maxoidRepresentation",
+            representationMethod=representationMethod,
+            representationDict=representationDict,
+            distributionPeriodWise=distributionPeriodWise,
+            timeStepsPerPeriod=timeStepsPerPeriod,
+        )
+
+    if clusterMethod == "hierarchical" or clusterMethod == "adjacent_periods":
+        if n_clusters == 1:
+            clusterOrder = np.asarray([0] * len(candidates))
+        else:
+            from sklearn.cluster import AgglomerativeClustering
+
+            if clusterMethod == "hierarchical":
+                clustering = AgglomerativeClustering(
+                    n_clusters=n_clusters, linkage="ward"
+                )
+            elif clusterMethod == "adjacent_periods":
+                adjacencyMatrix = np.eye(len(candidates), k=1) + np.eye(
+                    len(candidates), k=-1
+                )
+                clustering = AgglomerativeClustering(
+                    n_clusters=n_clusters, linkage="ward", connectivity=adjacencyMatrix
+                )
+            clusterOrder = clustering.fit_predict(candidates)
+        # represent hierarchical aggregation with medoid
+        clusterCenters, clusterCenterIndices = representations(
+            candidates,
+            clusterOrder,
+            default="medoidRepresentation",
+            representationMethod=representationMethod,
+            representationDict=representationDict,
+            distributionPeriodWise=distributionPeriodWise,
+            timeStepsPerPeriod=timeStepsPerPeriod,
+        )
+
+    return clusterCenters, clusterCenterIndices, clusterOrder

tsam/representations.py

@@ -1,167 +1,167 @@
-# -*- coding: utf-8 -*-
-
-import numpy as np
-from sklearn.metrics.pairwise import euclidean_distances
-from tsam.utils.durationRepresentation import durationRepresentation
-
-
-def representations(
-    candidates,
-    clusterOrder,
-    default,
-    representationMethod=None,
-    representationDict=None,
-    distributionPeriodWise=True,
-    timeStepsPerPeriod=None,
-):
-    clusterCenterIndices = None
-    if representationMethod is None:
-        representationMethod = default
-    if representationMethod == "meanRepresentation":
-        clusterCenters = meanRepresentation(candidates, clusterOrder)
-    elif representationMethod == "medoidRepresentation":
-        clusterCenters, clusterCenterIndices = medoidRepresentation(
-            candidates, clusterOrder
-        )
-    elif representationMethod == "maxoidRepresentation":
-        clusterCenters, clusterCenterIndices = maxoidRepresentation(
-            candidates, clusterOrder
-        )
-    elif representationMethod == "minmaxmeanRepresentation":
-        clusterCenters = minmaxmeanRepresentation(
-            candidates, clusterOrder, representationDict, timeStepsPerPeriod
-        )
-    elif representationMethod == "durationRepresentation" or representationMethod == "distributionRepresentation":
-        clusterCenters = durationRepresentation(
-            candidates, clusterOrder, distributionPeriodWise, timeStepsPerPeriod, representMinMax=False,
-        )
-    elif representationMethod == "distributionAndMinMaxRepresentation":
-        clusterCenters = durationRepresentation(
-            candidates, clusterOrder, distributionPeriodWise, timeStepsPerPeriod, representMinMax=True,
-        )
-    else:
-        raise ValueError("Chosen 'representationMethod' does not exist.")
-         
-    return clusterCenters, clusterCenterIndices
-
-
-def maxoidRepresentation(candidates, clusterOrder):
-    """
-    Represents the candidates of a given cluster group (clusterOrder)
-    by its medoid, measured with the euclidean distance.
-
-    :param candidates: Dissimilarity matrix where each row represents a candidate. required
-    :type candidates: np.ndarray
-
-    :param clusterOrder: Integer array where the index refers to the candidate and the
-        Integer entry to the group. required
-    :type clusterOrder: np.array
-    """
-    # set cluster member that is farthest away from the points of the other clusters as maxoid
-    clusterCenters = []
-    clusterCenterIndices = []
-    for clusterNum in np.unique(clusterOrder):
-        indice = np.where(clusterOrder == clusterNum)
-        innerDistMatrix = euclidean_distances(candidates, candidates[indice])
-        mindistIdx = np.argmax(innerDistMatrix.sum(axis=0))
-        clusterCenters.append(candidates[indice][mindistIdx])
-        clusterCenterIndices.append(indice[0][mindistIdx])
-
-    return clusterCenters, clusterCenterIndices
-
-
-def medoidRepresentation(candidates, clusterOrder):
-    """
-    Represents the candidates of a given cluster group (clusterOrder)
-    by its medoid, measured with the euclidean distance.
-
-    :param candidates: Dissimilarity matrix where each row represents a candidate. required
-    :type candidates: np.ndarray
-
-    :param clusterOrder: Integer array where the index refers to the candidate and the
-        Integer entry to the group. required
-    :type clusterOrder: np.array
-    """
-    # set cluster center as medoid
-    clusterCenters = []
-    clusterCenterIndices = []
-    for clusterNum in np.unique(clusterOrder):
-        indice = np.where(clusterOrder == clusterNum)
-        innerDistMatrix = euclidean_distances(candidates[indice])
-        mindistIdx = np.argmin(innerDistMatrix.sum(axis=0))
-        clusterCenters.append(candidates[indice][mindistIdx])
-        clusterCenterIndices.append(indice[0][mindistIdx])
-
-    return clusterCenters, clusterCenterIndices
-
-
-def meanRepresentation(candidates, clusterOrder):
-    """
-    Represents the candidates of a given cluster group (clusterOrder)
-    by its mean.
-
-    :param candidates: Dissimilarity matrix where each row represents a candidate. required
-    :type candidates: np.ndarray
-
-    :param clusterOrder: Integer array where the index refers to the candidate and the
-        Integer entry to the group. required
-    :type clusterOrder: np.array
-    """
-    # set cluster centers as means of the group candidates
-    clusterCenters = []
-    for clusterNum in np.unique(clusterOrder):
-        indice = np.where(clusterOrder == clusterNum)
-        currentMean = candidates[indice].mean(axis=0)
-        clusterCenters.append(currentMean)
-    return clusterCenters
-
-
-def minmaxmeanRepresentation(
-    candidates, clusterOrder, representationDict, timeStepsPerPeriod
-):
-    """
-    Represents the candidates of a given cluster group (clusterOrder)
-    by either the minimum, the maximum or the mean values of each time step for
-    all periods in that cluster depending on the command for each attribute.
-
-    :param candidates: Dissimilarity matrix where each row represents a candidate. required
-    :type candidates: np.ndarray
-
-    :param clusterOrder: Integer array where the index refers to the candidate and the
-        Integer entry to the group. required
-    :type clusterOrder: np.array
-
-    :param representationDict: A dictionary which defines for each attribute whether the typical
-        period should be represented by the minimum or maximum values within each cluster.
-        optional (default: None)
-    :type representationDict: dictionary
-
-    :param timeStepsPerPeriod: The number of discrete timesteps which describe one period. required
-    :type timeStepsPerPeriod: integer
-    """
-    # set cluster center depending of the representationDict
-    clusterCenters = []
-    for clusterNum in np.unique(clusterOrder):
-        indice = np.where(clusterOrder == clusterNum)
-        currentClusterCenter = np.zeros(len(representationDict) * timeStepsPerPeriod)
-        for attributeNum in range(len(representationDict)):
-            startIdx = attributeNum * timeStepsPerPeriod
-            endIdx = (attributeNum + 1) * timeStepsPerPeriod
-            if list(representationDict.values())[attributeNum] == "min":
-                currentClusterCenter[startIdx:endIdx] = candidates[
-                    indice, startIdx:endIdx
-                ].min(axis=1)
-            elif list(representationDict.values())[attributeNum] == "max":
-                currentClusterCenter[startIdx:endIdx] = candidates[
-                    indice, startIdx:endIdx
-                ].max(axis=1)
-            elif list(representationDict.values())[attributeNum] == "mean":
-                currentClusterCenter[startIdx:endIdx] = candidates[
-                    indice, startIdx:endIdx
-                ].mean(axis=1)
-            else:
-                raise ValueError(
-                    'At least one value in the representationDict is neither "min", "max" nor "mean".'
-                )
-        clusterCenters.append(currentClusterCenter)
-    return clusterCenters
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from sklearn.metrics.pairwise import euclidean_distances
+from tsam.utils.durationRepresentation import durationRepresentation
+
+
+def representations(
+    candidates,
+    clusterOrder,
+    default,
+    representationMethod=None,
+    representationDict=None,
+    distributionPeriodWise=True,
+    timeStepsPerPeriod=None,
+):
+    clusterCenterIndices = None
+    if representationMethod is None:
+        representationMethod = default
+    if representationMethod == "meanRepresentation":
+        clusterCenters = meanRepresentation(candidates, clusterOrder)
+    elif representationMethod == "medoidRepresentation":
+        clusterCenters, clusterCenterIndices = medoidRepresentation(
+            candidates, clusterOrder
+        )
+    elif representationMethod == "maxoidRepresentation":
+        clusterCenters, clusterCenterIndices = maxoidRepresentation(
+            candidates, clusterOrder
+        )
+    elif representationMethod == "minmaxmeanRepresentation":
+        clusterCenters = minmaxmeanRepresentation(
+            candidates, clusterOrder, representationDict, timeStepsPerPeriod
+        )
+    elif representationMethod == "durationRepresentation" or representationMethod == "distributionRepresentation":
+        clusterCenters = durationRepresentation(
+            candidates, clusterOrder, distributionPeriodWise, timeStepsPerPeriod, representMinMax=False,
+        )
+    elif representationMethod == "distributionAndMinMaxRepresentation":
+        clusterCenters = durationRepresentation(
+            candidates, clusterOrder, distributionPeriodWise, timeStepsPerPeriod, representMinMax=True,
+        )
+    else:
+        raise ValueError("Chosen 'representationMethod' does not exist.")
+         
+    return clusterCenters, clusterCenterIndices
+
+
+def maxoidRepresentation(candidates, clusterOrder):
+    """
+    Represents the candidates of a given cluster group (clusterOrder)
+    by its medoid, measured with the euclidean distance.
+
+    :param candidates: Dissimilarity matrix where each row represents a candidate. required
+    :type candidates: np.ndarray
+
+    :param clusterOrder: Integer array where the index refers to the candidate and the
+        Integer entry to the group. required
+    :type clusterOrder: np.array
+    """
+    # set cluster member that is farthest away from the points of the other clusters as maxoid
+    clusterCenters = []
+    clusterCenterIndices = []
+    for clusterNum in np.unique(clusterOrder):
+        indice = np.where(clusterOrder == clusterNum)
+        innerDistMatrix = euclidean_distances(candidates, candidates[indice])
+        mindistIdx = np.argmax(innerDistMatrix.sum(axis=0))
+        clusterCenters.append(candidates[indice][mindistIdx])
+        clusterCenterIndices.append(indice[0][mindistIdx])
+
+    return clusterCenters, clusterCenterIndices
+
+
+def medoidRepresentation(candidates, clusterOrder):
+    """
+    Represents the candidates of a given cluster group (clusterOrder)
+    by its medoid, measured with the euclidean distance.
+
+    :param candidates: Dissimilarity matrix where each row represents a candidate. required
+    :type candidates: np.ndarray
+
+    :param clusterOrder: Integer array where the index refers to the candidate and the
+        Integer entry to the group. required
+    :type clusterOrder: np.array
+    """
+    # set cluster center as medoid
+    clusterCenters = []
+    clusterCenterIndices = []
+    for clusterNum in np.unique(clusterOrder):
+        indice = np.where(clusterOrder == clusterNum)
+        innerDistMatrix = euclidean_distances(candidates[indice])
+        mindistIdx = np.argmin(innerDistMatrix.sum(axis=0))
+        clusterCenters.append(candidates[indice][mindistIdx])
+        clusterCenterIndices.append(indice[0][mindistIdx])
+
+    return clusterCenters, clusterCenterIndices
+
+
+def meanRepresentation(candidates, clusterOrder):
+    """
+    Represents the candidates of a given cluster group (clusterOrder)
+    by its mean.
+
+    :param candidates: Dissimilarity matrix where each row represents a candidate. required
+    :type candidates: np.ndarray
+
+    :param clusterOrder: Integer array where the index refers to the candidate and the
+        Integer entry to the group. required
+    :type clusterOrder: np.array
+    """
+    # set cluster centers as means of the group candidates
+    clusterCenters = []
+    for clusterNum in np.unique(clusterOrder):
+        indice = np.where(clusterOrder == clusterNum)
+        currentMean = candidates[indice].mean(axis=0)
+        clusterCenters.append(currentMean)
+    return clusterCenters
+
+
+def minmaxmeanRepresentation(
+    candidates, clusterOrder, representationDict, timeStepsPerPeriod
+):
+    """
+    Represents the candidates of a given cluster group (clusterOrder)
+    by either the minimum, the maximum or the mean values of each time step for
+    all periods in that cluster depending on the command for each attribute.
+
+    :param candidates: Dissimilarity matrix where each row represents a candidate. required
+    :type candidates: np.ndarray
+
+    :param clusterOrder: Integer array where the index refers to the candidate and the
+        Integer entry to the group. required
+    :type clusterOrder: np.array
+
+    :param representationDict: A dictionary which defines for each attribute whether the typical
+        period should be represented by the minimum or maximum values within each cluster.
+        optional (default: None)
+    :type representationDict: dictionary
+
+    :param timeStepsPerPeriod: The number of discrete timesteps which describe one period. required
+    :type timeStepsPerPeriod: integer
+    """
+    # set cluster center depending of the representationDict
+    clusterCenters = []
+    for clusterNum in np.unique(clusterOrder):
+        indice = np.where(clusterOrder == clusterNum)
+        currentClusterCenter = np.zeros(len(representationDict) * timeStepsPerPeriod)
+        for attributeNum in range(len(representationDict)):
+            startIdx = attributeNum * timeStepsPerPeriod
+            endIdx = (attributeNum + 1) * timeStepsPerPeriod
+            if list(representationDict.values())[attributeNum] == "min":
+                currentClusterCenter[startIdx:endIdx] = candidates[
+                    indice, startIdx:endIdx
+                ].min(axis=1)
+            elif list(representationDict.values())[attributeNum] == "max":
+                currentClusterCenter[startIdx:endIdx] = candidates[
+                    indice, startIdx:endIdx
+                ].max(axis=1)
+            elif list(representationDict.values())[attributeNum] == "mean":
+                currentClusterCenter[startIdx:endIdx] = candidates[
+                    indice, startIdx:endIdx
+                ].mean(axis=1)
+            else:
+                raise ValueError(
+                    'At least one value in the representationDict is neither "min", "max" nor "mean".'
+                )
+        clusterCenters.append(currentClusterCenter)
+    return clusterCenters