tf.tape.gradient() 为我的数值函数模型返回 None

问题描述

我正在尝试使用 tf.GradientTape()。 但问题是tape.gradient返回None，所以弹出错误输出（TypeError : unsupported operand type(s) for *: 'float' and 'nonetype'）。 正如您在我的代码中看到的，dloss_dparams = tape.gradient(Cost,[XX,YY]) 不返回任何值。 我不知道有什么问题。有人为什么会这样？

import tensorflow as tf
import math
import numpy as np
from numpy import loadtxt
import scipy.integrate as inte
from numpy import asarray
from numpy import savetxt

DPA_l=7.68e+5 #displacements/ion/cm
Na = 6.10e+22 # atomic density atoms/cm3
c=0.0424
S = math.pi*(0.05)**2
rmax=0.23#cm
rmin=-0.23
m=100
n=100
Ndpa =1
Ninitial=1
dx = (rmax-rmin)/m
dy = (rmax-rmin)/n

dfInd = loadtxt('intensity_2c_re2.csv',delimiter =',')
dfRi = loadtxt('p2c_t,ri,sd_re3.csv',')
Fnd = np.full((len(dfInd),m+1,n+1),np.nan)
DPAnd = np.full((len(dfInd),np.nan)
Lnd = np.full((len(dfInd),np.nan)

def I_V(bb):
    return 2.2e-8+bb*1e-9
def T_D(aa):
    return 7.9e-2 +aa*1e-3

Vnd = np.full((len(dfInd),np.nan)
And = np.full((len(dfInd),np.nan)
A2nd = np.full((len(dfInd),np.nan)
f_x = np.full((len(dfInd),1),np.nan)
f_y = np.full((len(dfInd),np.nan)
SSB = np.full((len(dfInd),0)
F0nd =np.full((len(dfInd),2),np.nan)

#initial value
for i in range(len(dfInd)): 
    F0nd[i,1] = (0.762*dfInd[i,2]*dfInd[i,0]/S)*0.1*np.sqrt(2)/(2*(np.sqrt(math.pi))*math.erf(1/(5*c*2**2.5))*c)
    F0nd[i,0]= dfInd[i,0]
 
f_x[0,0] = inte.quad(lambda x : np.math.exp((-(x-(rmax))**2)/(2*c**2)),rmax-rmin)[0]
f_y[0,0] = inte.quad(lambda y : np.exp((-(y-(rmax))**2)/(2*c**2)),rmax-rmin)[0]
F0nd[0,1] = (0.762*dfInd[0,2]*dfInd[1,0]/S)*0.1*math.sqrt(2)/(2*(math.sqrt(math.pi))*math.erf(1/(5*c*2**2.5))*c) ###추가 12/29
DPAnd[0,:,:] = 0
Lnd[0,:] = 0
Vnd[0,:] = 0

for j in range(m+1):
    for k in range(n+1):
        Fnd[0,j,k] = math.sqrt(F0nd[0,1])*np.math.exp(-(((j*dx-(rmax))**2)/(2*c**2)))*math.sqrt(F0nd[0,1])*np.exp(-(((k*dy-(rmax))**2)/(2*c**2)))
        And[0,k] = ((np.exp((-(j*dx-(rmax))**2)/(2*c**2))+np.exp((-((j+1)*dx-(rmax))**2)/(2*c**2)))*0.5*dx/f_x[0])*((np.exp((-(k*dy-(rmax))**2)/(2*c**2))+np.exp((-((k+1)*dy-(rmax))**2)/(2*c**2)))*0.5*dy/f_y[0])
        A2nd[0,k] = (1-Vnd[0,k])*And[0,k]


def predictions(XX,YY):
    i=0
    v=1
    aa=0.0
    bb=0.0
    
    f_x[i+1,0] = inte.quad(lambda x : np.exp((-(x-(rmax-XX))**2)/(2*c**2)),rmax-rmin)[0]  #f_x[1,0] #f_x[21,0]
    f_y[i+1,0] = inte.quad(lambda y : np.exp((-(y-(rmax-YY))**2)/(2*c**2)),rmax-rmin)[0]  #f_y[1,0] #f_y[21,0]
    for j in range(m+1):
        for k in range(n+1):
            Fnd[i+1,k] = F0nd[i+1,1]*np.exp(-(((j*dx-(rmax-XX))**2)/(2*c**2)))*np.exp(-(((k*dy-(rmax-YY))**2)/(2*c**2)))
            And[i+1,k] = ((np.exp((-(j*dx-(rmax-XX))**2)/(2*c**2))+np.exp((-((j+1)*dx-(rmax-XX))**2)/(2*c**2)))*0.5*dx/f_x[i+1])*((np.exp((-(k*dy-(rmax-YY))**2)/(2*c**2))+np.exp((-((k+1)*dy-(rmax-YY))**2)/(2*c**2)))*0.5*dy/f_y[i+1])
            DPAnd[i+1,k] = DPAnd[i,k] + DPA_l*Fnd[i,k]/Na
                
            if  DPAnd[i+1,k] < T_D(aa) :
                Lnd[i+1,k] = DPAnd[i+1,k]/(T_D(aa))
            elif DPAnd[i+1,k]>=T_D(aa) :
                Lnd[i+1,k] = 1.0
                    
            if Lnd[i+1,k]<1:
                A2nd[i+1,k] = (1.0-Lnd[i+1,k])*And[i+1,k]*0.79 + 1.0*And[i+1,k]*0.21
            elif Lnd[i+1,k]==1.0:
                A2nd[i+1,k]
                    
    SSB = I_V(bb)*(((A2nd).sum(axis=2)).sum(axis=1))
    loss = (SSB[v]-dfRi[v-1,1])
    return loss


XX = tf.Variable(0.1)
YY = tf.Variable(0.1)
learning_rate = 0.01
for j in range(100):
    with tf.GradientTape() as tape:
        tape.watch([XX,YY])
        Cost = tf.reduce_mean(tf.square(predictions(XX,YY)))
        print('Cost=',Cost)
    dloss_dparams = tape.gradient(Cost,YY])
    print('dloss_dparams[0] =',dloss_dparams[0],',dloss_dparams[1] =',dloss_dparams[1])
    XX.assign_sub(learning_rate * dloss_dparams[0])
    YY.aasign_sub(learning_rate * dloss_dparams[1])

    if i%10 ==0 :
        print("{:5} I {:10.4f} I {:10.4} I {:10.6f}".format(i,XX.numpy(),YY.numpy(),cost))    

输出是那个

Cost= tf.Tensor(2.803658208007937e-17,shape=(),dtype=float64)
dloss_dparams[0] = None,dloss_dparams[1] = None
Traceback (most recent call last):
File "C:/Users/USER/Downloads/tensorflow_gradient descent14.py",line 103,in <module>
XX.assign_sub(learning_rate * dloss_dparams[0])
TypeError: unsupported operand type(s) for *: 'float' and 'nonetype'

变量（XX，YY）和成本的关系图如下，以防万一。

解决方法

您正在 TensorFlow 之外进行计算。这将导致无梯度，请参阅指南：Getting a gradient of None

如果计算退出 TensorFlow，磁带将无法记录梯度路径。例如：

x = tf.Variable([[1.0,2.0],[3.0,4.0]],dtype=tf.float32)

with tf.GradientTape() as tape:
  x2 = x**2

  # This step is calculated with NumPy
  y = np.mean(x2,axis=0)

  # Like most ops,reduce_mean will cast the NumPy array to a constant tensor
  # using `tf.convert_to_tensor`.
  y = tf.reduce_mean(y,axis=0)

print(tape.gradient(y,x))

将打印

无