AI Mass人工智能大模型即服务时代：大模型即服务的能源应用

    import numpy as np
    
    def k_means(data, n_clusters):
    # 获取数据点个数
    m = data.shape[0]
    
    # 初始化聚类中心
    centroids = initialize_centroids(data, n_clusters)
    
    while True:
        # 记录上一次迭代的聚类中心
        prev_centroids = centroids
    
        # 根据距离最近的聚类中心进行划分
        cluster_assignments = assign_clusters(data, centroids)
    
        # 对聚类结果进行重新计算新的聚类中心
        centroids = recalculate_centroids(data, cluster_assignments, n_clusters)
    
        # 判断是否收敛
        if is_converged(prev_centroids, centroids):
            break
    
    return centroids
    
    
    def initialize_centroids(data, n_clusters):
    """
    从数据集中随机选择k个点作为聚类中心
    :param data: 数据集
    :param n_clusters: 聚类中心个数
    :return: 聚类中心列表
    """
    idx = np.random.permutation(len(data))[:n_clusters]
    centroids = [data[i] for i in idx]
    return centroids
    
    
    def assign_clusters(data, centroids):
    """
    使用距离最近的聚类中心进行划分
    :param data: 数据集
    :param centroids: 聚类中心列表
    :return: 每个样本点所属的聚类索引
    """
    distances = []
    for point in data:
        distance = np.linalg.norm(point - centroids, axis=1).sum()
        distances.append((distance, len(distances)))
    sorted_points = sorted(distances)
    assignments = [p[1] for p in sorted_points]
    return assignments
    
    
    def recalculate_centroids(data, cluster_assignments, n_clusters):
    """
    对每个聚类重新计算新的聚类中心
    :param data: 数据集
    :param cluster_assignments: 每个样本点所属的聚类索引
    :param n_clusters: 聚类中心个数
    :return: 新的聚类中心列表
    """
    new_centroids = []
    for i in range(n_clusters):
        points = [d for j, d in enumerate(data) if cluster_assignments[j] == i]
        center = np.mean(np.array(points), axis=0)
        new_centroids.append(center)
    return new_centroids
    
    
    def is_converged(prev_centroids, curr_centroids):
    """
    判断是否收敛
    :param prev_centroids: 上一次迭代的聚类中心
    :param curr_centroids: 当前的聚类中心
    :return: 是否收敛
    """
    for i in range(len(curr_centroids)):
        if not np.allclose(prev_centroids[i], curr_centroids[i]):
            return False
    return True
    
    
    if __name__ == '__main__':
    # 生成测试数据
    np.random.seed(42)
    data = np.concatenate([np.random.randn(100, 2) + [-2, -2], 
                           np.random.randn(50, 2) + [2, 2]])
    
    # 训练K-Means模型
    model = k_means(data, 2)
    
    print('Model:')
    print(model)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    

    class Node():
    def __init__(self, value='', parent=None, children=[]):
        self.value = value
        self.parent = parent
        self.children = children
    
    def __str__(self):
        return 'Node({})'.format(self.value)
    
    
    class Tree():
    def __init__(self):
        self.root = None
    
    
    def create_tree(self, items, min_support):
        frequency_items = {}
        support_count = {}
    
        # count the frequency of each item and its support
        for transaction in items:
            for item in transaction:
                frequency_items[item] = frequency_items.get(item, 0) + 1
                support_count[item] = support_count.get(item, 0) + 1
    
        # sort by descending order of support
        freq_sorted = sorted([(v, k) for (k, v) in frequency_items.items()], reverse=True)
        support_set = set([x[1] for x in freq_sorted])
    
        current_node = Node('')
        self.root = current_node
    
        while support_set:
            next_item = max([(support_count[item]/len(items), item) for item in support_set])[1]
    
            node = Node(next_item)
            current_node.children.append(node)
    
    
            subsets = [[t for t in items if item in t] for item in transactions]
    
            # find all frequent subsets of this item among the transactions
            subset_counts = [{frozenset(subset)} for subset in subsets if len(subset) > 0]
            counts = list(map(lambda x: sum(subsets.count(c) for c in x)/len(transactions), subset_counts))
    
            current_freq = counts[-1]
            local_set = {frozenset({item})} | support_set & {(item,) for item in transactions}
    
            while current_freq >= min_support and any(tuple(subset)[0].issubset(local_set) for subset in subsets):
                subset_idx = max([(c/current_freq, s) for (c, s) in zip(counts[:-1], subset_counts)], key=lambda x: x[0])[1]
    
                current_freq -= counts[subset_idx] / len(transactions)
    
                local_set |= {tuple(subset)[0] for subset in subsets[subset_idx]}
                subset_counts[subset_idx] &= {s for s in subset_counts[subset_idx] if tuple(s)[0].issubset(local_set)}
    
                try:
                    counts[subset_idx] = sum(subsets.count(c) for c in subset_counts[subset_idx])/len(transactions)
                except ZeroDivisionError:
                    pass
    
            support_set -= local_set
    
        return self.root
    
    
    if __name__ == '__main__':
    # generate some sample data
    transactions = [['A', 'B'], ['B', 'C'], ['D']] 
    tree = Tree()
    root = tree.create_tree(transactions, 0.5)
    
    # traverse the tree to print out the frequent sets found
    queue = [(root, '')]
    while queue:
        node, prefix = queue.pop(0)
        if node.value!= '':
            print('{} -> {}'.format(prefix, str(node.value)))
        else:
            for child in reversed(node.children):
                queue.insert(0, ('{} -> {}'.format(prefix, str(child.value)), '{}{}'.format(prefix, str(child.value))))