梯度下降法，调用pytorch实现（问题在哪？？？？？？？？老是调不好）

import numpy as np
import torch
def def_k_coefficient( k_shape ):
    # 定义系数的尺寸,随机初始化系数
    k_coefficient_real_img =  np.random.rand(k_shape,2)

    # k_coefficient_img   =  np.random.rand(k_shape,1)
    # 返回值是k系数的实数部和虚数部，都是(40,1)的尺寸
    # 若要求最终的系数，可采取k_sum = k_coefficient_real*1.0 + k_coefficient_img*(1j)
    return k_coefficient_real_img # 40,2系数  80个参数

def trans_3_27_to_esum(all_point,mode_temp01_tensor , mode_temp_tensor):
    # 最后的结果想干叠加后的结果 是 3，27
    # 输入是 3，27,2
    # 返回结果是27，1 ，
    import numpy as np

    # a 3   b 27 , 2
    all_point = (all_point)

    mode_fengliang , number_of_points  ,shibu_xubu = all_point.shape
    # 3,27,1
    # mode_temp01_tensor = torch.zeros(size = (mode_fengliang, number_of_points,1),dtype=torch.float64)
    # mode_temp_tensor = torch.zeros(size = (1, number_of_points),dtype= torch.float64)

    for a1 in range(number_of_points): # 27
        for a2 in range(mode_fengliang): # 3

            mode_temp01_tensor[a2 , a1, 0 ] = torch.sqrt( (mode_temp01_tensor[a2 , a1, 0 ])**2 +(all_point[a2,a1,0])**2)

    for a1 in range(number_of_points):
        for a3 in range(mode_fengliang):
            # 3,27,1
            mode_temp_tensor[0,a1] = mode_temp_tensor[0,a1] +(mode_temp01_tensor[a3 , a1, 0 ] )**2
    # 返回值为27，1.实数矩阵
    mode_temp_tensor =mode_temp_tensor.view(number_of_points,1) # 返回值为27，1
    return  mode_temp_tensor

def distanceFrom_A_To_B(array1 ,array2 ):
    import numpy as np
    # 加一个调整系数 ，中间为1 的数值很重要
    # 此处的是27，1和27，1的系数差距
    rows ,cols = (array1.shape)
    sum =torch.tensor(0.0,dtype=torch.float64)
    for row in range(rows):
        temp_sum = array1[row ,0 ] - array2[row ,0]
        sum = sum + temp_sum**2
    sum = sum *1.0
    return  sum

# def get_point(ndarray ):
#     # some action
#     # 返回值是两个  40，27的数组（分别是实数部、虚数部），
#     # 40代表40个模式，27代表27个点，
#     # 合起来是40
#     return point_real,point_img

def def_the_want_point_value( preSETpoint_number = 27 ,middle_point_intensity = 1):
    # 设置27个点，中心点强度设置为1
    temp  = np.zeros(shape = (preSETpoint_number,1) )
    #  中心点强度设置
    temp[0,0] = middle_point_intensity
    wanted_point = np.resize(np.array(temp), preSETpoint_number)
    # 得到[27,1]的矩阵
    print(wanted_point)
    # 27,1的实数矩阵
    return  wanted_point

# def compute_point_sum_value(preSETpoint_number = 27,mode_number =40, k_coefficient_real,k_coefficient_img,point_real,point_img):
#     # 输入是系数k，点的集合point ，输出是27，1的结果(如果是三个方向exeyez要用三次这个函数)
#     point_sum_result_real = np.ones(shape=(preSETpoint_number,1))
#     point_sum_result_img = np.ones(shape=(preSETpoint_number,1))
#     k_coefficient_real = k_coefficient_real
#     # 实数部的加和
#     for i in range(preSETpoint_number):
#         for j in range(mode_number):
#             # 两个实数部分的相乘求和还是实数
#             point_sum_result_real[i] = point_sum_result_real[i]\
#                                        + k_coefficient_real[j] * point_real[j, i]
#     for i in range(preSETpoint_number):
#         for j in range(mode_number):
#             # 两个虚数部分的相乘求和还是实数，只是多个-1 *
#             point_sum_result_real[i] = point_sum_result_real[i] \
#                                        + (-1.0) * (k_coefficient_img[j] * point_img[j, i])
#
#     # 虚数部的加和
#     for i in range(preSETpoint_number):
#         for j in range(mode_number):
#             # 实数系数相乘 虚数数值求和是虚数
#             point_sum_result_img[i] = point_sum_result_img[i] + k_coefficient_real[j] * point_img[j, i]
#     for i in range(preSETpoint_number):
#         for j in range(mode_number):
#             # 虚数系数相乘 实数数值得到虚数
#             point_sum_result_img[i] = point_sum_result_img[i] + (k_coefficient_img[j] * point_real[j, i])
#
#     # point_sum_abs_value = np.abs(point_sum_result_img * (1j) + point_sum_result_real * 1)
#     # # 返回值是27，1的两个数组，对应实部虚部
#     return point_sum_result_real,point_sum_result_img

def zuobiaoGet(middle_point,zhongxingdianqiangdu,banfenkuang_int):
    # 返回值是 27个点的坐标位置信息(x,y)---
    zuobiao = [(middle_point, middle_point)]
    result_wanted = [zhongxingdianqiangdu]  # 中心点强度设置

    # 预设结果初始化，想要得到的结果： （27，1）结果   （坐标为）（27个点）
    for i in range(banfenkuang_int, 3 * banfenkuang_int, 1):
        result_wanted.append(0.0)
        zuobiao_x = middle_point
        zuobiao_y = middle_point + i
        zuobiao.append((zuobiao_x, zuobiao_y))
    print(zuobiao)
    length = len(result_wanted)
    result_wanted = np.array(result_wanted)
    result_wanted = np.resize(result_wanted,new_shape=(length,1))
    return  zuobiao ,result_wanted


def read_Data(file_place='../mode_numpy//80mode.npy'):
    # 得到40，3，27的数据
    import numpy as np

    all_point = np.load(file_place)
    mode_number, mode_fenliang, numberofPreset = all_point.shape
    # 提取数据为40，3，27，2     2代表该点的实数部和虚数部
    all_point_real_img = np.zeros((mode_number, mode_fenliang, numberofPreset,1+1),dtype=float)
    for a1 in range(mode_number):
        for a2 in range(mode_fenliang):
            for a3 in range(numberofPreset):
                for a4 in range(1+1):
                    all_point_real_img[a1,a2,a3,0] =  np.real(all_point[a1,a2,a3])
                    all_point_real_img[a1, a2, a3, 0+1] = np.imag(all_point[a1, a2, a3])
    # 返回值是实数40，3，27，2
    return all_point_real_img

def readOriginData(file_place, numberofPreset,zuobiao ,mode_number ,mode_fenliang):
    # 读取原始数据mode
    import numpy as np
    mode_org = file_place

    # 原始数据
    mode_orign = np.load(mode_org)
    a, b = mode_orign.shape
    jingdu = int((max(a, b)) ** 0.5)  # 801精度

    mode_number = mode_number # 40个模式
    mode_fenliang = mode_fenliang  # ex ey ez分量
    # 得到复数矩阵
    mode_fushu = np.zeros(shape = (mode_number, mode_fenliang, jingdu * jingdu), dtype=complex)  # 40 , 3 ,801**2
    # 得到复数矩阵 ， 【40，3，801*801】维度 , 0维度是ex ，1维度是ey ，2 维度是ez
    for col in range(jingdu ** 2):
        for i in range(mode_number):
            ex_start = i * 12 + 0
            ey_start = i * 12 + 2
            ez_start = i * 12 + 4
            mode_fushu[i, 0, col] = mode_fushu[i, 0, col] +mode_orign[col, ex_start] + 1j * mode_orign[col, ex_start + 1]
            mode_fushu[i, 1, col] = mode_fushu[i, 1, col] +mode_orign[col, ey_start] + 1j * mode_orign[col, ey_start + 1]
            mode_fushu[i, 2, col] =  mode_fushu[i, 2, col]  +mode_orign[col, ez_start] + 1j * mode_orign[col, ez_start + 1]
    # mode_fushu 是40个本征模，三个维度，(40,3,801*801)复数矩阵
    mode_fushu = mode_fushu
    # 40个模式，每个提取3维度  ， 27个预设点 尺寸为（40 ， 3 ， 27 ） # 各自分量
    all_point = np.zeros((mode_number, mode_fenliang, numberofPreset), dtype=complex)
    for number in range(mode_number):
        for fenliang in range(mode_fenliang):
            temp_mode = np.resize(mode_fushu[number, fenliang, :], new_shape=(jingdu, jingdu))
            # 第几个点 ,
            numberPoint = 0
            for x, y in zuobiao:
                # 27 个坐标
                x = int(x)
                y = int(y)
                all_point[number, fenliang, numberPoint] = temp_mode[x, y]
                numberPoint = numberPoint + 1
    all_point = all_point
    # 提取数据为40，3，27，2     2代表该点的实数部和虚数部
    all_point_real_img = np.zeros((mode_number, mode_fenliang, numberofPreset,1+1),dtype=float)
    for a1 in range(mode_number):
        for a2 in range(mode_fenliang):
            for a3 in range(numberofPreset):
                for a4 in range(1+1):
                    all_point_real_img[a1,a2,a3,0] =  np.real(all_point[a1,a2,a3])
                    all_point_real_img[a1, a2, a3, 0+1] = np.imag(all_point[a1, a2, a3])
    # 返回值是实数40，3，27，2
    return all_point_real_img

def k_x_point( k_coefficient_real_img_tensor , point_real_img ,result_fushu_tensor ):
    # size
    # 40,2
    # 40,3,27,2
    # k和point相乘
    # result = np.ones(shape= (3,27,2) ) # 3个维度， 27个点 ， 2代表实部虚部数值
    # result_tensor = torch.zeros(size= (3,27,2) ) # 3个维度， 27个点 ， 2代表实部虚部数值

    mode_number,mode_fengliang ,numbers_point, shibu_xubu  = point_real_img.shape
    # 2020-9-24 del
    # pointfushu 40,3,27维度
    # point_fushu = point_real_img[:,:,:,0]+ point_real_img[:,:,:,1] *(1j)
    # point_fushu = np.reshape(point_fushu ,newshape=(mode_number,mode_fengliang ,numbers_point))

    # # k_fushu 1，40 fushu矩阵
    # k_fushu  = k_cofficient_real_img[:,0]  + k_coefficient_real_img[:,1] *(1j)
    # k_fushu = np.reshape( k_fushu , newshape=(1,mode_number) )
    # result 为3，27维度
    # 1 40   *  40,3, 27
    # result_fushu = np.zeros(shape=(mode_fengliang,numbers_point,shibu_xubu),dtype=complex)
    # result_fushu_tensor : 是 3，27，2
    # result_fushu_tensor  = torch.zeros(size=(mode_fengliang,numbers_point,shibu_xubu),dtype=torch.float64)

    for a1 in range(mode_fengliang):
        for a2 in range(numbers_point):
            for a3 in range(mode_number):
                result_fushu_tensor[a1,a2,0] = result_fushu_tensor[a1,a2,0]  +\
                                               point_real_img_tensor[a3,a1,a2,0]*k_coefficient_real_img_tensor[a3,0]  +(-1)*point_real_img_tensor[a3,a1,a2,1]*k_coefficient_real_img_tensor[a3,1]
                result_fushu_tensor[a1, a2, 1] = result_fushu_tensor[a1, a2, 1] + \
                                                 point_real_img_tensor[a3, a1, a2, 1] * k_coefficient_real_img_tensor[
                                                     a3, 0] + (1) * point_real_img_tensor[a3, a1, a2, 0] * \
                                                 k_coefficient_real_img_tensor[a3, 1]

    # result_fushu = np.dot( k_fushu , point_fushu )
    # result[:,:,0] = np.real(result_fushu[:,:])
    # result[:,:,1] = np.imag(result_fushu[:,:])
    # 返回的tensor是3，27，2
    return result_fushu_tensor





    # # for j in range(mode_fengliang):
    # #     for point in range(numbers_point):
    # #         for  i in range(mode_number):
    #             result[j,point,0]  += \
    #                 k_coefficient_real_img[i,0] *  point_real_img[i,j,point,0] # 实部*实部还是实部
    #             result



if __name__ == '__main__':
    import torch

    k_shape = 40
    # k的尺寸为40，2，下面2分别代表系数中的 实部 ， 虚部
    k_coefficient_real_img = def_k_coefficient(k_shape= k_shape)
    k_coefficient_real_img_tensor =  torch.from_numpy(k_coefficient_real_img)
    k_coefficient_real_img_tensor.requires_grad_(True) # 要改变的值，要计算梯度
    # 预设27个点观察结果，一个中心点，剩下的一些零点

    mode_number = 40 # 40 modes
    mode_fengliang = 3 #
    intensity_middle_point = 1 #
    # （27，1）维度的矩阵实数值，
    jingdu = 801
    banfenkuang_int=int(jingdu*0.33/10)
    # wanted_point  = def_the_want_point_value(preSETpoint_number=27,middle_point_intensity=1)
    # print(wanted_point)

    zuobiao ,result_wanted = zuobiaoGet(middle_point=jingdu//2
                                        ,zhongxingdianqiangdu=intensity_middle_point
                         ,banfenkuang_int=int(jingdu*0.33/10))
    zuobiao = zuobiao
    result_wanted_tensor = torch.from_numpy(result_wanted) #
    result_wanted_tensor.double()# 64
    result_wanted_tensor.requires_grad_(False)
    # point_real_img  :# 返回值是实数40，3，27，2 ， 2代表实数部，虚数部
    point_real_img  = read_Data(file_place='../mode_numpy'
                                           '//allpoint_40_3_27_complex.npy')

    point_real_img_tensor = torch.from_numpy(point_real_img)
    point_real_img_tensor.requires_grad_(False)
    mode_number  , mode_fengliang , numberOfpoints ,shibuxubu = point_real_img_tensor.shape



    result_fushu_tensor  = torch.zeros(size=(mode_fengliang,numberOfpoints,shibuxubu),dtype=torch.float64)

    mode_number, mode_fengliang, numbers_point, shibu_xubu = point_real_img.shape

    for a1 in range(mode_fengliang):
        for a2 in range(numbers_point):
            for a3 in range(mode_number):
                result_fushu_tensor[a1, a2, 0] = (result_fushu_tensor[a1, a2, 0]).clone() + \
                                                  ( point_real_img_tensor[a3, a1, a2, 0] ).clone() *k_coefficient_real_img_tensor[
                                                     a3, 0] + (-1) * ( point_real_img_tensor[a3, a1, a2, 1]).clone()  * \
                                                k_coefficient_real_img_tensor[a3, 1]
                result_fushu_tensor[a1, a2, 1] = ( result_fushu_tensor[a1, a2, 1]).clone()  + \
                                               ( point_real_img_tensor[a3, a1, a2, 1] ).clone() * k_coefficient_real_img_tensor[
                                                     a3, 0] + (1) * ( point_real_img_tensor[a3, a1, a2, 0] ).clone() * \
                                                 k_coefficient_real_img_tensor[a3, 1]


    result_fushu_tensor =  (result_fushu_tensor).clone()

    mode_temp01_tensor = torch.zeros(size=(mode_fengliang, numberOfpoints, 1), dtype=torch.float64)
    result_sum_tensor = torch.zeros(size=(1, numberOfpoints), dtype=torch.float64)
    mode_temp_tensor = torch.zeros(size=(1, numberOfpoints), dtype=torch.float64)
    # a 3   b 27 , 2
    all_point = (result_fushu_tensor)

    mode_fengliang, number_of_points, shibu_xubu = all_point.shape
    # 3,27,1
    # mode_temp01_tensor = torch.zeros(size = (mode_fengliang, number_of_points,1),dtype=torch.float64)
    # mode_temp_tensor = torch.zeros(size = (1, number_of_points),dtype= torch.float64)

    for a1 in range(number_of_points):  # 27
        for a2 in range(mode_fengliang):  # 3

            mode_temp01_tensor[a2, a1, 0] = torch.sqrt(
                (mode_temp01_tensor[a2, a1, 0]).clone() ** 2 + (all_point[a2, a1, 0]).clone()  ** 2
            )

    for a1 in range(number_of_points):
        for a3 in range(mode_fengliang):
            # 3,27,1
            mode_temp_tensor[0, a1] = ( mode_temp_tensor[0, a1] ).clone() + ((mode_temp01_tensor[a3, a1, 0]) ).clone() ** 2
    # 返回值为27，1.实数矩阵
    mode_temp_tensor = mode_temp_tensor.view(number_of_points, 1)  # 返回值为27，1



    result_sum_tensor = mode_temp_tensor
    # result_sum_tensor = result_sum_tensor.double()


    # distance  = distanceFrom_A_To_B(result_sum_tensor,result_wanted_tensor)

    loss_fn  = torch.nn.MSELoss(reduce=True , size_average=False)

    distance  = loss_fn(result_sum_tensor,result_wanted_tensor)
    print(distance)
    #########question ！

    ############
    distance.backward( )
    k_gradient = k_coefficient_real_img_tensor.grad
    # distance.backward()
    print('k_gradient is' , k_gradient)
    print('want point ', result_wanted_tensor)
    print('real point ', result_sum_tensor)
    print()
    print('now dist is ',distance )