2022-5-第二周日报

2022/5/9 1 2048

修改和优化代码。

 def fill_grid_2(self, fill_steps, nums_list, difficulty_level_changge, num_path_last, now_num_path):

        num_max = np.max(self.Matrics)
        min = auto.matrix_min(self.Matrics)
        if np.log2(num_max) - np.log2(min) > 7:
            nums_list = [min, min*2, min*4, min*8, min*16, min*32]
        if len(nums_list) < 6 :
            nums_list = [min, min*2, min*4, min*8, min*16, min*32]

        # 随机填充
        if difficulty_level_changge == 1:
            self.random_num_list.append(self.random_num_list[-1]*2)
        length = len(nums_list)
        if len(fill_steps) > 4:
            random_list = fill_steps[0:len(fill_steps) - 4]
            control_list = fill_steps[len(fill_steps) - 4:]

            for i, j in random_list:
                new_number_index = random.randint(0, length - 1)
                new_number = nums_list[new_number_index]
                self.Matrics[i][j] = new_number
        else:
            control_list = fill_steps
        all_matrix_control_action = auto.all_action_numlist(nums_list, len(control_list))  # 所有动作
        index = 0
        socre = 0
        total_num_path = []
        total_smooth = []
        total_num = []
        total_num_value = []
        total_mat_score = []
        total_mat_score_less = []
        total_mat_score_bigger = []

        for i in range(len(all_matrix_control_action)):
            mat = self.Matrics.copy()
            mat = auto.matrix_action_pad(mat, control_list, all_matrix_control_action[i])
            # num_path = auto.feature_score(mat)
            smooth, num_path = auto.matrix_smooth(mat)
            num_1 = 0
            num_2 = 0
            for j in range(len(all_matrix_control_action[i])):
                if np.sum(np.where(self.Matrics == all_matrix_control_action[i][j])[0]) == 0:
                    num_1 = num_1
                else:
                    num_1 = num_1 + (25 - len(control_list)) / np.sum(
                        np.where(self.Matrics == all_matrix_control_action[i][j])[0])  # 少的棋子
                num_2 = num_2 + np.max(self.Matrics) / all_matrix_control_action[i][j]  # 小的棋子

            total_num.append(num_1)
            total_num_value.append(num_2)
            total_num_path.append(num_path)
            total_smooth.append(smooth)
        for i in range(len(all_matrix_control_action)):
            mat = self.Matrics.copy()
            mat = auto.matrix_action_pad(mat, control_list, all_matrix_control_action[i])

            if auto.feature_score(mat) < now_num_path:  # auto.matrix_smooth(mat) <= self.smooth and
                mat_socre = 0.3 * auto.Standardization(total_num_path, i) + 0.8 * auto.Standardization(
                    total_smooth,
                    i) + 0.3 * auto.Standardization(
                    total_num, i) + 0.2 * auto.Standardization(total_num_value, i)
                # mat_socre = total_num_path[i] + total_smooth[i] + total_num[i] + 2 * total_num_value[i]
                total_mat_score.append((mat_socre, i))
                total_mat_score_less.append((mat_socre, i))
            elif auto.feature_score(mat) >= now_num_path:
                mat_socre = 0.3 * auto.Standardization(total_num_path, i) + 0.8 * auto.Standardization(
                    total_smooth,
                    i) + 0.3 * auto.Standardization(
                    total_num, i) + 0.2 * auto.Standardization(total_num_value, i)
                total_mat_score.append((mat_socre, i))
                # mat_socre = total_num_path[i] + total_smooth[i] + total_num[i] + 2 * total_num_value[i]
                total_mat_score_bigger.append((mat_socre, i))
        total_mat_score_bigger.sort()
        total_mat_score_less.sort()
        # 难度控制
        if difficulty_level_changge == 1:  # 提升难度
            if len(total_mat_score_less) != 0:
                index = total_mat_score_less[-1][1]
            else:
                index = total_mat_score_bigger[0][1]

        elif difficulty_level_changge != 1:
            if len(total_mat_score_bigger) != 0:
                index = total_mat_score_bigger[0][1]
            else:
                index = total_mat_score_less[-1][1]

        auto.matrix_action_pad(self.Matrics, control_list, all_matrix_control_action[index])

        print('--------------------------------------------')
        print('上一步连接性：', num_path_last)
        print('当前连接性：', auto.feature_score(self.Matrics))

def matrix_smooth(mat):
    mat_index = np.array([[0] * 5] * 5)
    num = 0
    smooth = 0
    for i in range(mat.shape[0]):
        for j in range(mat.shape[1]):
            smooth1, num1, mat_index = matrix_move(mat, i, j, 1, mat_index)
            smooth2, num2, mat_index = matrix_move(mat,  i, j, 2, mat_index)
            smooth3, num3, mat_index = matrix_move(mat, i, j, 3, mat_index)
            smooth = smooth - smooth1 - smooth2 - smooth3
            num = num + num1 + num2 + num3
    return smooth, num

0 2022/5/10 1 2048

优化代码之后，可控制的数字增加到了5个。

2 联邦学习 2.1 复现联邦学习FedAvg

model

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Dropout, Activation,Flatten
from keras.models import model_from_json
import tensorflow as tf


class Model:
    def __init__(self):
        self.model = Sequential()
        self.model.add(Flatten())
        self.model.add(Dense(128, activation='relu'))
        self.model.add(Dense(10, activation='softmax'))
        self.model.compile(optimizer='adam',
                           loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                           metrics=['accuracy'])

    def saveModel(self):
        model_json = self.model.to_json()
        with open("model.json", "w") as json_file:
            json_file.write(model_json)
        # serialize weights to HDF5
        self.model.save_weights("model.h5")
        print("Saved model to disk")

    def loadModel(self):
        json_file = open('model.json', 'r')
        loaded_model_json = json_file.read()
        json_file.close()
        loaded_model = model_from_json(loaded_model_json)
        # load weights into new model
        loaded_model.load_weights("model.h5")
        print("Loaded model from disk")
        loaded_model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy'])
        return loaded_model

    def run(self, X, Y, load=True):
        if (load):
            self.model = self.loadModel()
        self.model.fit(X, Y, epochs=5)

    def evaluate(self, X, Y,  verbose=2):
        return self.model.evaluate(X, Y, verbose=verbose)

    def loss(self, X, Y):
        return self.model.evaluate(X, Y)[0]

    def predict(self, X):
        return self.model.predict(X)

    def getWeights(self):
        return self.model.get_weights()

    def setWeights(self, weight):
        self.model.set_weights(weight)

data

from tensorflow.python.keras.datasets import cifar10, mnist, fashion_mnist


def Mnist_data():
    (x_train, y_train), (x_test, y_test) = mnist.load_data()
    x_train = x_train.reshape(-1, 28 * 28) / 255
    x_test = x_test.reshape(-1, 28 * 28) / 255
    return x_train, y_train, x_test, y_test

def generate_client_data(num_clients=10):
    (x_train, y_train), (x_test, y_test) = mnist.load_data()
    x_train = x_train.reshape(-1, 28 * 28) / 255
    x_test = x_test.reshape(-1, 28 * 28) / 255
    data = list(zip(x_train, y_train))
    size = len(data) // num_clients
    shards = [data[i:i+size] for i in range(0, size * num_clients, size)]
    return data, shards, x_test, y_test

# if __name__ == '__main__':
#     data, shards, x_test, y_test = generate_client_data(3)
#     print(shards[0])

aggregater

import numpy as np


class FedAvg:
    def __init__(self, global_model, different_client_values, client_count):
        global_weights = np.array(global_model.getWeights())
        for i in range(len(different_client_values)):
            global_weights -= different_client_values[i] / client_count
        global_model.setWeights(global_weights)

main

import numpy as np

import data
import model
from tensorflow import keras
import tensorflow as tf
import aggregator
if __name__ == '__main__':
    data, shards, x_test, y_test = data.generate_client_data(4)
    model1 = model.Model()
    model2 = model.Model()
    model3 = model.Model()

    global_model = model.Model()
    x, y = zip(*shards[0])
    x_train = np.array(x)
    y_train = np.array(y)
    # global_model.run(x_train, y_train, load=False)



    x_1, y_1 = zip(*shards[1])
    x_1 = np.array(x_1)
    y_1 = np.array(y_1)
    x_2, y_2 = zip(*shards[2])
    x_2 = np.array(x_2)
    y_2 = np.array(y_2)
    x_3, y_3 = zip(*shards[3])
    x_3 = np.array(x_3)
    y_3 = np.array(y_3)

    a_0 = np.argmax(global_model.predict(x_3[0:784]))
    global_model.saveModel()
    a_1 = np.argmax(model1.predict(x_3[0:784]))
    a_2 = np.argmax(model2.predict(x_3[0:784]))
    a_3 = np.argmax(model3.predict(x_3[0:784]))

    model1.setWeights(global_model.getWeights())
    model2.setWeights(global_model.getWeights())
    model3.setWeights(global_model.getWeights())

    model1.run(x_1, y_1)
    model2.run(x_2, y_2)
    model3.run(x_3, y_3)

    client_difference_value = [np.array(global_model.getWeights()) - np.array(model1.getWeights()),
                               np.array(global_model.getWeights()) - np.array(model2.getWeights()),
                               np.array(global_model.getWeights()) - np.array(model3.getWeights())]
    fedavg = aggregator.FedAvg(global_model, client_difference_value, 3)
    global_model.saveModel()
    test_loss, test_acc = global_model.evaluate(x_test, y_test, verbose=2)
    print('\nTest accuracy:', test_acc)

0 2022/5/11 1 2048难度控制

游戏前期，慢慢降低平滑性的权重，后期强制约束连接性。例如，死亡步数5000步，前4800步，将平滑性的权重由开始的0.8降至最后的0.2，最后200步，将连接性逐渐的降到0。

2 Provably Secure Federated Learning against Malicious Clients阅读报告 2.1 摘要

联邦学习使客户能够协作学习共享的全局模型，而无需与云服务器共享其本地培训数据。然而，恶意客户端可能会破坏全局模型，从而预测用于测试示例的错误标签。针对恶意客户端的现有防御措施利用拜占庭式健壮的联合学习方法。然而，这些方法无法证明测试示例的预测标签不受恶意客户端的影响。我们通过集成联邦学习来弥合这一差距。特别是，给定任何基本联邦学习算法，我们使用该算法学习多个全局模型，每个模型都是使用随机选择的客户端子集学习的。在预测测试示例的标签时，我们在全球模型中进行多数投票。我们证明了我们的集成联邦学习算法与任何基本联邦学习算法都是可证明安全的，可以抵御恶意客户端。具体来说，我们的集成全局模型为测试示例预测的标签可证明不受有限数量的恶意客户端的影响。此外，我们还证明了我们的导出界是紧的。我们在MNIST和人类活动识别数据集上评估了我们的方法。例如，当1000个客户端中有20个是恶意的时，我们的方法可以在MNIST上实现88%的认证准确率。

2.2 引言

在这项工作中，我们提出了集成联邦学习，这是第一种可证明对恶意客户端安全的联邦学习方法。具体来说，考虑到n个客户，我们将子样本定义为从n个客户机中均匀随机抽样的k个客户机的集合，无需替换。对于每个子样本，我们可以使用基本联邦学习算法学习一个全局模型，子样本中有k个客户机。既然有k个客户端的 ( n k ) \begin{pmatrix}n \ k\ \end{pmatrix} (nk​)个子样本全局模型可以进行总体训练。假设我们给出了一个测试示例x。我们将pi定义为 ( n k ) \begin{pmatrix}n \ k\ \end{pmatrix} (nk​)预测x的标签i的全局模型，其中i=1，2，···，L。我们称之为pi标签概率。我们的集成全局模型预测x标签概率最大的标签。换句话说，我们的集成全局模型在预测x标签的全局模型中占多数票。由于每个全局模型都是使用带有k个客户机的子样本学习的，当大多数客户机是正常的时，大多数全局模型都是使用正常客户机学习的。因此，全局模型中的大多数投票是安全的，可以抵御数量有限的恶意客户端。

理论：我们的第一个主要理论结果是，当恶意客户端的数量不超过阈值（我们称之为认证安全级别）时，我们的集成全局模型可证明地预测测试示例x的相同标签。我们的第二个主要理论结果是，我们证明了我们导出的认证安全级别是严格的，也就是说，当没有对基本联邦学习算法进行任何假设时，不可能导出比我们更大的认证安全级别。请注意，对于不同的测试示例，认证的安全级别可能不同。
评估：我们在MNIST（LeCun、Cortes和Burges 1998）和人类活动识别数据集（Anguita et al.2013）上对我们的方法进行了实证评估。我们将MNIST中的培训示例分发给客户机，以模拟联合学习场景，而人类活动识别数据集则代表一个真实的联合学习场景，其中每个用户都是一个客户机。我们使用谷歌（McMahan et al.2017）开发的流行FedAvg作为基础联邦学习算法。此外，我们使用认证准确度作为评估指标，这是一种方法可以证明达到的测试准确度的下限，无论恶意客户端如何篡改其本地训练数据和模型更新。例如，我们的集合FedAvg（N=500，k=10）在MNIST上可以实现88%的认证准确率，将训练示例平均分配给1000个客户端，其中20个是恶意的。

0 2022/5/12 1 2048

实现了通过平滑性控制难度。

 def key_down(self, event):
        # while True:
            self.num_path_last = auto.feature_score(self.matrix)
            key = event.keysym
            self.step = self.step + 1
            #  难度控制
            if self.end <= 200:
              difficulty_level = int(self.step / self.end_key)
              if difficulty_level > self.difficulty_level_last:
                  difficulty_level_changge = 1
                  self.mygrid.num_path = self.mygrid.num_path - 1
              else:
                  difficulty_level_changge = 2
              self.difficulty_level_last = difficulty_level
              smooth_change = 0
            else:
                if self.step < (self.end - 200):
                    smooth_change_key = (self.end - 200) / 8
                    smooth_change = int(self.step / smooth_change_key)
                    difficulty_level_changge = 2
                else:
                    difficulty_level = int(self.step / self.end_key)
                    if difficulty_level > self.difficulty_level_last:
                        difficulty_level_changge = 1
                        self.mygrid.num_path = self.mygrid.num_path - 1
                    else:
                        difficulty_level_changge = 2
                    self.difficulty_level_last = difficulty_level
                    smooth_change = 0
            print('当前步数：', self.step)
            # self.auto_connect()
            if key == c.KEY_QUIT:exit()
            if key == c.KEY_BACK and len(self.history_matrixs) > 1:
                self.matrix = self.history_matrixs.pop()
                self.update_grid_cells()
                # print('back on step total step:', len(self.history_matrixs)
            elif key in self.commands:
                # self.matrix, done = self.commands[key](self.matrix)
                done = True
                x = 0
                if done:
                    # eval 将字符串按代码执行
                    # steps = eval(input("请输入你要链接的棋子下标："))
                    steps = self.connect_steps
                    for i in range(len(self.connect_steps) - 1):
                        label = auto.is_connect(self.matrix, self.connect_steps[i][0], self.connect_steps[i][1],
                                                self.connect_steps[i + 1][0], self.connect_steps[i + 1][1])
                        if label != 1:
                            x = 1
                    if x == 1:
                        self.update_grid_cells()
                        self.connect_steps = []
                        msgbox.showinfo('警告', '非法连接！！')
                        return
                    # 连接后，返回空出来的格子
                    down_steps = self.mygrid.connect(steps)
                    if down_steps is None:
                        self.update_grid_cells()
                        self.connect_steps = []
                        msgbox.showinfo('警告', '非法连接！！')
                        return
                    else:
                        # 将空出来的格子往下填满，返回需要生成数字的格子位置
                        fill_steps = self.mygrid.down(down_steps)
                        # print("下降后的棋局：\n", self.grid.Matrics)
                        self.mygrid.fill_grid_2(fill_steps, self.mygrid.get_num_list(), difficulty_level_changge, self.num_path_last, self.mygrid.num_path, smooth_change)
                        # print("随机生存数字后的棋局：\n", self.grid.Matrics)
                        self.matrix = auto.matrix_unify(self.matrix)
                        self.matrix = self.mygrid.Matrics
                        # self.matrix = logic.add_two(self.matrix)
                        # record last move
                        self.history_matrixs.append(self.matrix)
                        self.update_grid_cells()
                        self.connect_steps = []

0 2022/5/13 1 2048

今天根据李老师的意见修改代码。

    def fill_grid_2(self, fill_steps, nums_list, difficulty_level_changge, num_path_last,  now_num_path, smooth_change):

        num_max = np.max(self.Matrics)
        min = auto.matrix_min(self.Matrics)
        if np.log2(num_max) - np.log2(min) > 7:
            nums_list = [min, min*2, min*4, min*8, min*16, min*32]
        if len(nums_list) < 6 :
            nums_list = [min, min*2, min*4, min*8, min*16, min*32]
        # 找到场上最小的数字并判断能否连接
        # list_min = []
        # m = 0
        # for i in range(len(np.where(self.Matrics == min)[0])):
        #     tuple_min = (np.where(self.Matrics == min)[0][i], np.where(self.Matrics == min)[1][i])
        #     list_min.append(tuple_min)
        # for i, j in list_min:
        #     m += auto.matrix_find_path(self.Matrics, i, j)
        #
        # if m == len(np.where(self.Matrics == min)[0]) and len(fill_steps) >= 2:
        #     index = auto.find_near(fill_steps, list_min)
        #     self.Matrics[fill_steps[index][0]][fill_steps[index][1]] = min
        #     fill_steps.pop(index)

        # 随机填充
        if difficulty_level_changge == 1:
            self.random_num_list.append(self.random_num_list[-1]*2)
        length = len(nums_list)
        if len(fill_steps) > 4:
            random_list = fill_steps[0:len(fill_steps) - 4]
            control_list = fill_steps[len(fill_steps) - 4:]

            for i, j in random_list:
                new_number_index = random.randint(0, length - 1)
                new_number = nums_list[new_number_index]
                self.Matrics[i][j] = new_number
        else:
            control_list = fill_steps
        all_matrix_control_action = auto.all_action_numlist(nums_list, len(control_list))  # 所有动作
        index = 0
        socre = 0
        total_num_path = []
        total_smooth = []
        total_num = []
        total_num_value = []
        total_mat_score = []
        total_mat_score_less = []
        total_mat_score_bigger = []

        for i in range(len(all_matrix_control_action)):
            mat = self.Matrics.copy()
            mat = auto.matrix_action_pad(mat, control_list, all_matrix_control_action[i])
            # num_path = auto.feature_score(mat)
            smooth, num_path = auto.matrix_smooth(mat)
            num_1 = 0
            num_2 = 0
            for j in range(len(all_matrix_control_action[i])):
                if np.sum(np.where(self.Matrics == all_matrix_control_action[i][j])[0]) == 0:
                    num_1 = num_1
                else:
                    num_1 = num_1 + (25 - len(control_list)) / np.sum(
                        np.where(self.Matrics == all_matrix_control_action[i][j])[0])  # 少的棋子
                num_2 = num_2 + np.max(self.Matrics) / all_matrix_control_action[i][j]  # 小的棋子

            total_num.append(num_1)
            total_num_value.append(num_2)
            total_num_path.append(num_path)
            total_smooth.append(smooth)
        for i in range(len(all_matrix_control_action)):
            mat = self.Matrics.copy()
            mat = auto.matrix_action_pad(mat, control_list, all_matrix_control_action[i])
            s, num_total_path = auto.matrix_smooth(mat)

            if num_total_path < now_num_path:  # (self.weight_smooth - smooth_change * 0.1)
                mat_socre = 0.3 * auto.Standardization(total_num_path, i) + 4 * auto.Standardization(
                    total_smooth,
                    i) + 0.3 * auto.Standardization(
                    total_num, i) + 0.2 * auto.Standardization(total_num_value, i)
                # mat_socre = total_num_path[i] + total_smooth[i] + total_num[i] + 2 * total_num_value[i]
                total_mat_score.append((mat_socre, i))
                total_mat_score_less.append((mat_socre, i))
            elif num_total_path >= now_num_path:
                mat_socre = 0.3 * auto.Standardization(total_num_path, i) + 4 * auto.Standardization(
                    total_smooth,
                    i) + 0.3 * auto.Standardization(
                    total_num, i) + 0.2 * auto.Standardization(total_num_value, i)
                total_mat_score.append((mat_socre, i))
                # mat_socre = total_num_path[i] + total_smooth[i] + total_num[i] + 2 * total_num_value[i]
                total_mat_score_bigger.append((mat_socre, i))
        total_mat_score_bigger.sort()
        total_mat_score_less.sort()
        # 难度控制
        if difficulty_level_changge == 1:  # 提升难度
            if len(total_mat_score_less) != 0:
                index = total_mat_score_less[-1][1]
            else:
                index = total_mat_score_bigger[0][1]

        elif difficulty_level_changge != 1:
            if len(total_mat_score_bigger) != 0:
                index = total_mat_score_bigger[0][1]
            else:
                index = total_mat_score_less[-1][1]

        auto.matrix_action_pad(self.Matrics, control_list, all_matrix_control_action[index])

        print('--------------------------------------------')
        print('上一步连接性：', num_path_last)
        print('当前连接性：', auto.feature_score(self.Matrics))