def forward(self, x):
    x = self.conv(x)
    x = F.relu(x)
    x = self.pooling(x)
    x = torch.flatten(x,1)
    x = self.d1(x)
    return x

def forward(self, x):
    # x = torch.cat(tuple(x), dim=1)
    # x = self.d1(x)
    # x = self.d2(x)
    x = F.softmax(torch.add(x[0],x[1]), dim=1)
    return x

    # 设置被动方模型
    passive_model_up = VFLPassiveModel().cuda()
    passive_model_down = VFLPassiveModel().cuda()

    # 设置主动方模型
    active_model = VFLActiveModel().cuda()
    print('training_mode', training_mode)

    # 设置优化器
    opt_p1 = optim.Adam(passive_model_up.parameters(), lr=0.001)
    opt_p2 = optim.Adam(passive_model_down.parameters(), lr=0.001)
    opt_a = optim.Adam(active_model.parameters(), lr=0.001)


    acc_train = []
    acc_test = []
    acc_test_label = []
    acc_backdoor = []
    loss_train = []
    loss_test = []
    loss_backdoor = []

    active_up_gradient_res = None
    has_poison_up_grad = False
    active_down_gradient_res = None
    has_poison_down_grad = True
    poison_N = 600

    for epoch in range(EPOCHS):

        loss_init = 0
        right_init = 0
        opt_p1.zero_grad()
        opt_p2.zero_grad()
        opt_a.zero_grad()
        number_of_poison = 0
        poison_number = 0
        iter_num = 10 # 一个批量中中毒的数量


        has_found_target_grad = False

        for i, (images, labels) in enumerate(train_loader):

            # 如何确定被中毒的样本
            poison_indx = random.sample(range(images.shape[0]), iter_num)

            images = images.cuda()
            labels = labels.cuda()


            if poison_number<poison_N and i!=0:

                images[poison_indx, :, 27, 27] = 1.0
                images[poison_indx, :, 26, 26] = 1.0
                images[poison_indx, :, 25, 27] = 1.0
                images[poison_indx, :, 27, 25] = 1.0

            images_up = images[:, :, :, :14]
            images_down = images[:, :, :, 14:]

            passive_up_output = passive_model_up(images_up)
            passive_down_output = passive_model_down(images_down)

            if poison_number<poison_N and i!=0:
                passive_down_output[poison_indx]=torch.zeros(passive_down_output[poison_indx].shape).cuda()

            poisoned_up_output = torch.autograd.Variable(passive_up_output.detach().clone(), requires_grad=True)
            poisoned_down_output = torch.autograd.Variable(passive_down_output.detach().clone(), requires_grad=True)

            concat_tensor = [poisoned_up_output, poisoned_down_output]

            # 主动方基于被动方的输出计算损失函数
            active_output = active_model(concat_tensor)
            loss = nn.CrossEntropyLoss()(active_output, labels)

            # 计算主动方和被动方的梯度信息
            activate_gradient_list = [torch.autograd.grad(loss, a, retain_graph=True) for a in concat_tensor]

            # 找到已知辅助样本的梯度信息
            if not has_found_target_grad:
                # 需要被替换的梯度信息
                inject_gard = activate_gradient_list[1][0][sample_id_need_copy]
                has_found_target_grad = True

            # 将训练中中毒的样本进行改变梯度
            amplify_rate = 10
            if poison_number<poison_N:
                activate_gradient_list[1][0][poison_indx]=inject_gard * amplify_rate
                poison_number+=iter_num

            passive_model_up_gradient = torch.autograd.grad(passive_up_output, passive_model_up.parameters(), grad_outputs=activate_gradient_list[0], retain_graph=True)
            passive_model_down_gradient = torch.autograd.grad(passive_down_output, passive_model_down.parameters(), grad_outputs=activate_gradient_list[1], retain_graph=True)

            for w, g in zip(passive_model_up.parameters(), passive_model_up_gradient):
                w.grad = g.detach()
            opt_p1.step()

            for w, g in zip(passive_model_down.parameters(), passive_model_down_gradient):
                w.grad = g.detach()
            opt_p2.step()

            # 更新主动方模型
            loss.backward()
            opt_a.step()

            # 计算被动方梯度信息
            loss_init += loss.item()
            pred = np.argmax(active_output.detach().cpu(), axis=1)
            # print('pred',pred)
            # print('label',labels)
            right_init += np.sum(np.array(pred == labels.cpu()) + 0)
        print('poison number', poison_number)
        print('epoch: {}, loss is {}'.format(epoch, loss_init/trainset.shape[0]))

            # 主动方基于被动方的输出计算损失函数
            active_output = active_model(concat_tensor)

            pred = np.argmax(active_output.detach().cpu(), axis=1)
            right_init += np.sum(np.array(pred == labels.cpu()) + 0)
        print('epoch: {}, testing acc is {}'.format(epoch, right_init / testset.shape[0]))


        # 测试后门攻击的成功率
        loss_init = 0
        right_init = 0
        # for images, labels in test_loader:
        for i, (images, labels) in enumerate(test_loader):

            # print(torch.max(images))
            # images[:, :, 25:, 25:] = 1.0
            images[:, :, 27, 27] = 1.0
            images[:, :, 26, 26] = 1.0
            images[:, :, 25, 27] = 1.0
            images[:, :, 27, 25] = 1.0

            labels[:] = train_labels[sample_id_need_copy]
            images_up = images[:, :, :, :14].cuda()
            images_down = images[:, :, :, 14:].cuda()
            labels = labels.cuda()

            passive_up_output = passive_model_up(images_up)
            passive_down_output = passive_model_down(images_down)
            concat_tensor = [passive_up_output, passive_down_output]

            # 主动方基于被动方的输出计算损失函数
            active_output = active_model(concat_tensor)

            if i == 0 and epoch==0:
                output_distribution = np.average(active_output.cpu().detach().numpy(), axis=0)
                X = np.arange(10)
                plt.bar(X, output_distribution)
                plt.show()

            pred = np.argmax(active_output.detach().cpu(), axis=1)
            right_init += np.sum(np.array(pred == labels.cpu()) + 0)

        print('epoch: {}, testing asr is {}'.format(epoch, right_init / testset.shape[0]))
        print(' ')