def __init__(self,mol,shifted=False): self.mol = select_geom.get(mol) System_mol.__init__(self,self.mol,select_basis.get(mol),select_e.get(mol),mol) self.tape = "./test/"+mol self.energy = select_energy.get(mol) self.coef = normalization(np.array(self.alpha),self.coef,self.l,self.list_contr) #coef = normalization(np.array(self.alpha),np.copy(self.coef),self.xyz,self.l,self.list_contr) self.alpha_algopy = UTPM.init_jacobian(self.alpha) self.coef_algopy = UTPM.init_jacobian(self.coef) return
def test_expm(self): def f(x): x = x.reshape((2,2)) return sum(expm(x)) x = numpy.random.random(2*2) # forward mode ax = UTPM.init_jacobian(x) ay = f(ax) g1 = UTPM.extract_jacobian(ay) # reverse mode cg = CGraph() ax = Function(x) ay = f(ax) cg.independentFunctionList = [ax] cg.dependentFunctionList = [ay] g2 = cg.gradient(x) assert_array_almost_equal(g1, g2)
def algo_jaco(*args, **kwargs): var = UTPM.init_jacobian(args[narg]) diff_args = list(args) # We are making a copy of args diff_args[narg] = var diff_args[-1]= var diff_args = tuple(diff_args) return UTPM.extract_jacobian(rhfenergy(*(diff_args)))
def _energy_gradss(self,argnum,max_scf=301,max_d=300,printguess=None,name='Output.molden',output=False,order='first'): """This function returns the gradient of args""" ## For the moment it retuns a value at a time ## This is used only by testing functions. eigen = True rguess = False args=[np.log(self.sys.alpha),self.sys.coef,self.sys.xyz,self.sys.l,self.sys.charges,self.sys.atom,self.sys.natoms,self.sys.nbasis, self.sys.list_contr,self.sys.ne, max_scf,max_d,log,eigen,None,None, name,output,self.sys.alpha] # Last term is only used for Algopy if self.verbose: self.tape.write(' \n Grad point ...\n') self.tape.write(' ---Start--- \n') self.tape.write(' Initial parameters \n') self.tape.write(' Maximum number of SCF: %d\n'%max_scf) self.tape.write(' Default SCF tolerance: %f\n'%1e-8) self.tape.write(' Initial density matrix: %s\n'%str(rguess)) self.sys.printcurrentgeombasis(self.tape) grad_fun =[] for i in argnum: var = UTPM.init_jacobian(args[i]) diff_args = list(args) # We are making a copy of args diff_args[i] = var diff_args[-1]= var t0 = time.clock() grad = UTPM.extract_jacobian(rhfenergy(*(diff_args))) timer = time.clock() - t0 self.sys.grad = grad self.tape.write(' ---End--- \n') self.tape.write(' Time %3.7f :\n'%timer) return grad
def nuclear_gradient(mol,center = np.array([0.0,0.0,0.0])): ''' In computes the geometric derivatives of the kinetics matrix ''' ''' grad_algo_xyz = np.zeros((mol.nbasis,mol.nbasis,3)) #for i in range(len(mol.alpha)): for i in range(1): xyz = np.array(mol.xyz[i] - center) print xyz xyz_algopy = UTPM.init_jacobian(xyz) charges = [1] ncharges = 1 grad_algo_xyz = grad_algo_xyz + UTPM.extract_jacobian(nuclearmatrix(mol.alpha,mol.coef,mol.xyz,mol.l,mol.nbasis,charges,xyz_algopy,ncharges,xyz_algopy)) ''' xyz = np.array(center) xyz_algopy = UTPM.init_jacobian(xyz) charges = [1] ncharges = 1 grad_algo_xyz = UTPM.extract_jacobian(nuclearmatrix(mol.alpha,mol.coef,mol.xyz,mol.l,mol.nbasis,charges,xyz_algopy,ncharges,xyz_algopy)) print mol.atom print grad_algo_xyz[:,:,0] print grad_algo_xyz[:,:,1] print grad_algo_xyz[:,:,2] print grad_algo_xyz.shape return grad_algo_xyz
def d_f(x): """function""" return x[0] * x[1] * x[2] + exp(x[0]) * x[1] # x[differnce] # forward AD without building a computational graph x = UTPM.init_jacobian([3, 5, 7]) y = d_f(x) algopy_jacobian = UTPM.extract_jacobian(y) print('jacobian = ', algopy_jacobian) # reverse mode using a computational graph # Step 1/2 - trace the evaluation function cg = algopy.CGraph() x = algopy.Function([1, 2, 3]) y = d_f(x) cg.trace_off() cg.independentFunctionList = [x] cg.dependentFunctionList = [y] # Step 2/2 - use the graph to evaluate derivatives print('gradient =', cg.gradient([3., 5, 7])) print( 'Jacobian =', cg.jacobian([3., 5, 7]) ) # a square matrix of first order partial derivatives, the derivative of f at all possible points wrt x print( 'Hessian =', cg.hessian([3., 5., 7.]) ) # a matrix of second order partial derivatives of the function in question (square), can use optimisation for local min/max/saddle of a critical value. print('Hessian vector product =', cg.hess_vec([3., 5., 7.], [4, 5, 6]))
def gradient(x): out = [] if type(x) == float: i = UTPM.init_jacobian([x]) y = f(i) algopy_jacobian = UTPM.extract_jacobian(y) out = algopy_jacobian else: for i in x: i = UTPM.init_jacobian([i]) y = f(i) algopy_jacobian = UTPM.extract_jacobian(y) # print('jacobian = ',algopy_jacobian) out.append(algopy_jacobian[0]) return np.array(out)
def alg_grad(x, func, args=()): if not algopy_avail: raise ImportError( "Algopy not installed. Please install algopy or use diff_grad") x = UTPM.init_jacobian(x) y = func(x, *args) #print("Y", y) return UTPM.extract_jacobian(y)
def alg_jac(x, func, args=()): try: func(x, *args)[0] except IndexError: # If func returns a scalar, the jacobian is just the gradient return alg_grad(x, func, args) if not algopy_avail: raise ImportError( "Algopy not installed. Please install algopy or use diff_jac") x = UTPM.init_jacobian(x) y = func_part(x, func, args) return UTPM.extract_jacobian(y)
def init_UTPM_jacobian(x): # print 'type(x)=', type(x) if isinstance(x, Function): return x.init_UTPM_jacobian() elif isinstance(x, numpy.ndarray): return UTPM.init_jacobian(x) elif isinstance(x, UTPM): # print x.data.shape return UTPM.init_UTPM_jacobian(x.data[0,0]) else: raise ValueError('don\'t know what to do with this input!')
def init_UTPM_jacobian(x): # print 'type(x)=', type(x) if isinstance(x, Function): return x.init_UTPM_jacobian() elif isinstance(x, numpy.ndarray): return UTPM.init_jacobian(x) elif isinstance(x, UTPM): # print x.data.shape return UTPM.init_UTPM_jacobian(x.data[0, 0]) else: raise ValueError('don\'t know what to do with this input!')
def algopy_fprime(xk, *args): """ Evaluates the gradient of the function Parameters: xk : array_like The coordinate vector at which to determine the gradient of `f`. Returns: grad : ndarray The partial derivatives of `f` to `xk`. """ var = UTPM.init_jacobian(xk) grad = UTPM.extract_jacobian(function(*(tuple([var])+args))) return grad
def test_expm_jacobian(self): n = 4 x = numpy.random.randn(n, n) # use algopy to get the jacobian ax = UTPM.init_jacobian(x) ay = expm(ax) g1 = UTPM.extract_jacobian(ay) # compute the jacobian directly using expm_frechet M = numpy.zeros((n, n, n*n)) ident = numpy.identity(n*n) for i in range(n*n): E = ident[i].reshape(n, n) M[:, :, i] = expm_frechet(x, E, compute_expm=False) assert_allclose(g1, M, rtol=1e-6)
def test_expm_jacobian(self): n = 4 x = numpy.random.randn(n, n) # use algopy to get the jacobian ax = UTPM.init_jacobian(x) ay = expm(ax) g1 = UTPM.extract_jacobian(ay) # compute the jacobian directly using expm_frechet M = numpy.zeros((n, n, n * n)) ident = numpy.identity(n * n) for i in range(n * n): E = ident[i].reshape(n, n) M[:, :, i] = expm_frechet(x, E, compute_expm=False) assert_allclose(g1, M, rtol=1e-6)
def IV_algopy_jac (Ee, Tc, Rs, Rsh, Isat1_0, Isat2, Isc0, alpha_Isc, Eg, Vd): """ Calculate Jacobian of IV curve using AlgoPy :param Ee: [suns] effective irradiance :param Tc: [C] cell temperature :param Rs: [ohms] series resistance :param Rsh: [ohms] shunt resistance :param Isat1_0: [A] saturation current of first diode at STC :param Isat2: [A] saturation current of second diode :param Isc0: [A] short circuit current at STC :param alpha_Isc: [1/K] short circuit current temperature coefficient :param Eg: [eV] band gap :param Vd: [V] diode voltages :return: Jacobian :math:`\\frac{\\partial f_i}{\\partial x_{j,k}}` where :math:`k` are independent observations of :math:`x` """ x = UTPM.init_jacobian([ Ee, Tc, Rs, Rsh, Isat1_0, Isat2, Isc0, alpha_Isc, Eg ]) return UTPM.extract_jacobian(IV_algopy(x, Vd))
def test_expm(self): def f(x): x = x.reshape((2, 2)) return sum(expm(x)) x = numpy.random.random(2 * 2) # forward mode ax = UTPM.init_jacobian(x) ay = f(ax) g1 = UTPM.extract_jacobian(ay) # reverse mode cg = CGraph() ax = Function(x) ay = f(ax) cg.independentFunctionList = [ax] cg.dependentFunctionList = [ay] g2 = cg.gradient(x) assert_array_almost_equal(g1, g2)
y = F(x) print('y0 = ', y0) print('y = ', y) print('y.shape =', y.shape) print('y.data.shape =', y.data.shape) print('dF/dx(x0) * x1 =', y.data[1, 0]) import numpy from numpy import log, exp, sin, cos, abs import algopy from algopy import UTPM, dot, inv, zeros def f(x): A = zeros((2, 2), dtype=x) A[0, 0] = numpy.log(x[0] * x[1]) A[0, 1] = numpy.log(x[1]) + exp(x[0]) A[1, 0] = sin(x[0])**2 + abs(cos(x[0]))**3.1 A[1, 1] = x[0]**cos(x[1]) return log(dot(x.T, dot(inv(A), x))) x = numpy.array([3., 7.]) x = UTPM.init_jacobian(x) y = f(x) print('normal function evaluation f(x) = ', y.data[0, 0]) print('Jacobian df/dx = ', UTPM.extract_jacobian(y))
#define parameters params = np.array([r_0, alpha]) #define values that we want to take a derivative with respect to xin = np.array([x_r[3], x_r[6], y_r[3], y_r[6]]) #Finite Differencing step = 1e-6 p1 = np.array([step, 0, 0, 0]) p2 = np.array([0, step, 0, 0]) p3 = np.array([0, 0, step, 0]) p4 = np.array([0, 0, 0, step]) p = np.array([p1, p2, p3, p4]) derivative_FD = np.zeros(4) for i in range(len(p)): derivative_FD[i] = (overlap(xin + p[i], params) - overlap(xin, params)) / step print "FD: ", derivative_FD #Automatic Differentiation x_algopy = UTPM.init_jacobian(xin) overlap_fraction = overlap(x_algopy, params) derivative_auto = UTPM.extract_jacobian(overlap_fraction) print "Automatic: ", derivative_auto
import numpy, algopy from algopy import UTPM, exp def eval_f(x): """ some function """ return x[0] * x[1] * x[2] + exp(x[0]) * x[1] # forward mode without building the computational graph # ----------------------------------------------------- x = UTPM.init_jacobian([3, 5, 7]) y = eval_f(x) algopy_jacobian = UTPM.extract_jacobian(y) print('jacobian = ', algopy_jacobian) # reverse mode using a computational graph # ---------------------------------------- # STEP 1: trace the function evaluation cg = algopy.CGraph() x = algopy.Function([1, 2, 3]) y = eval_f(x) cg.trace_off() cg.independentFunctionList = [x] cg.dependentFunctionList = [y] # STEP 2: use the computational graph to evaluate derivatives print('gradient =', cg.gradient([3., 5, 7])) print('Jacobian =', cg.jacobian([3., 5, 7])) print('Hessian =', cg.hessian([3., 5., 7.]))
def eval_jac_g_forward(x): x = UTPM.init_jacobian(x) return UTPM.extract_jacobian(eval_g(x))
print eval_jac_g_forward(x) print eval_g(x) def f(x): nobs = x.shape[1:] f0 = x[0]**2 * sin(x[1])**2 f1 = x[0]**2 * cos(x[1])**2 out = zeros((2,) + nobs, dtype=x) out[0,:] = f0 out[1,:] = f1 return out x = np.array([(1, 2, 3, 4),(5, 6, 7, 8)],dtype=float) y = f(x) xj = UTPM.init_jacobian(x) j = UTPM.extract_jacobian(f(xj)) print "x =\n%r\n" % x print "f =\n%r\n" % y print "j =\n%r\n" % j # time it jaca = nda.Jacobian(f) x = np.array([np.arange(100),np.random.rand(100)]) %timeit jaca(x) # x = # array([[ 1., 2., 3., 4.], # [ 5., 6., 7., 8.]])
def ANN_Model(X, Y, test_X, test_y): """----------测试集原数据作图----------------""" # plt.figure(0) # 创建图表1 # plt.title('observe') # plt.scatter([_ for _ in range(test_y.shape[0])], test_y) # 训练次数 # epochs = input('输入训练批次:\n') # loss_func = input('loss函数(' # 'mae[mean_absolute_error]\n' # 'mse[mean_squared_error]\n' # 'msle[mean_squared_logarithmic_error]\n' # 'squared_hinge[squared_hinge]\n' # 'logcosh[logcosh]\n' # '):\n') loss_func = 'mse' """----------配置网络模型----------------""" # 配置网络结构 model = Sequential() # hidden_units = input('隐藏层单元数量:\n') hidden_units = 20 # 第一隐藏层的配置:输入17,输出20 if layers_num == 1: model.add( Dense(hidden_units, input_dim=len(InputIndex), activation='sigmoid')) model.add(Dense(1, activation='sigmoid')) else: hidden_units1 = 20 hidden_units2 = 16 model.add( Dense(hidden_units1, input_dim=len(InputIndex), activation='sigmoid')) model.add(Dense(hidden_units2, activation='sigmoid')) model.add(Dense(1)) # 编译模型,指明代价函数和更新方法 Ada = optimizers.Adagrad(lr=0.018, epsilon=1e-06) model.compile(loss=loss_func, optimizer=Ada, metrics=[loss_func]) """----------训练模型--------------------""" print("training starts.....") model.fit(X, Y, epochs=epochs, verbose=1, batch_size=256) """----------评估模型--------------------""" # 用测试集去评估模型的准确度 cost = model.evaluate(test_X, test_y) print('\nTest accuracy:', cost) """----------模型存储--------------------""" save_model(model, weight_file_path) # 数据反归一化 trueTestYv = org_teY temp = model.predict(test_X).reshape(-1, 1) predTestYv = (temp.T * npscale.reshape(-1, 1)[-1, :] + npminthred.reshape(-1, 1)[-1, :]).T save_data = { 'Test': list(trueTestYv.T[0]), 'Predict': list(predTestYv.T[0]) } predict_predYv = pd.DataFrame(save_data) predict_predYv.to_csv('data/predict_test_value.csv') """----------计算R^2--------------------""" testYv = test_y.values.flatten() predYv = model.predict(test_X).flatten() slope, intercept, r_value, p_value, std_err = scipy.stats.linregress( testYv, predYv) print('R square is: ', r_value**2) # 数据反归一化 trueAllYv = org_target.values temp = model.predict(train).reshape(-1, 1) predAllYv = (temp.T * npscale.reshape(-1, 1)[-1, :] + npminthred.reshape(-1, 1)[-1, :]).T save_data = { 'TrueData': list(trueAllYv.T[0]), 'PredictData': list(predAllYv.T[0]) } predict_AllYv = pd.DataFrame(save_data) predict_AllYv.to_csv('data/predict_all_value.csv') # 求偏导,然后直接作图 # 获取每一层的权重 weights = {} for layer in model.layers: weight = layer.get_weights() info = layer.get_config() weights[info['name']] = weight if info['name'] == 'dense_1': df_weights = pd.DataFrame(weight[0].T, columns=InputIndex) else: df_weights = pd.DataFrame(weight[0].T) df_bias = pd.DataFrame(weight[1].T, columns=['bias']) df = pd.concat([df_weights, df_bias], axis=1) df.to_csv('weights/' + info['name'] + '.csv') res = [] for RawNo in range(train.shape[0]): TargetValue = list(train.loc[RawNo].values) x = UTPM.init_jacobian(TargetValue) # 求导函数,根据隐藏层数量选择 # 1层:DerivativeExpression_jac1 # 2层:DerivativeExpression_jac2 if layers_num == 1: y = DerivativeExpression_jac1(x, weights) else: y = DerivativeExpression_jac2(x, weights) algopy_jacobian = UTPM.extract_jacobian(y) # 最后一列插入NEE res.append(list(algopy_jacobian)) res = np.array(res) save_data = { 'TrueNEE': list(trueAllYv.T[0]), 'PredNEE': list(predAllYv.T[0]) } predict_AllYv = pd.DataFrame(save_data) deriColumns = ['d' + str(_) for _ in train.columns.tolist()] result = pd.DataFrame(res, columns=deriColumns) result = pd.concat([result, original_data, predict_AllYv], axis=1) result.to_csv('data/result_jacobian.csv') result.dropna(inplace=True) for i in range(len(InputIndex)): plt.figure(i) # 创建图表1 IndexName = InputIndex[i] # result = result[(result['d'+IndexName] > -5000) & (result['d'+IndexName] < 5000)] y = abs(result['d' + IndexName].values * scale[IndexName]) / result.shape[0] x = result[IndexName].values plt.xlabel(IndexName) plt.ylabel("NEE-" + IndexName) plt.scatter(x, y, s=1) plt.savefig("res/" + IndexName + ".png") plt.show()
y = f(i) algopy_jacobian = UTPM.extract_jacobian(y) # print('jacobian = ',algopy_jacobian) out.append(algopy_jacobian[0]) return np.array(out) def eval_f(x): """ some function """ return x[0]**2 * x[1]**2 #x[1]*x[2] + np.exp(x[0])*x[1] # forward mode without building the computational graph # ----------------------------------------------------- x = UTPM.init_jacobian([10, 10]) y = eval_f(x) algopy_jacobian = UTPM.extract_jacobian(y) # xax = np.linspace(-8,8,100) # gradient(xax) # right a = np.linspace(1, 10, 1000) # plt.plot(a, f([a])) # xopt = spo.brenth(lambda x: gradient(x), 0, 20, xtol = 10e-7, full_output = True) h = gradient(a) plt.plot(a, h)
import numpy, algopy from algopy import UTPM, exp def eval_f(x): """ some function """ return x[0]*x[1]*x[2] + exp(x[0])*x[1] # forward mode without building the computational graph # ----------------------------------------------------- x = UTPM.init_jacobian([3,5,7]) y = eval_f(x) algopy_jacobian = UTPM.extract_jacobian(y) print('jacobian = ',algopy_jacobian) # reverse mode using a computational graph # ---------------------------------------- # STEP 1: trace the function evaluation cg = algopy.CGraph() x = algopy.Function([1,2,3]) y = eval_f(x) cg.trace_off() cg.independentFunctionList = [x] cg.dependentFunctionList = [y] # STEP 2: use the computational graph to evaluate derivatives print('gradient =', cg.gradient([3.,5,7])) print('Jacobian =', cg.jacobian([3.,5,7])) print('Hessian =', cg.hessian([3.,5.,7.])) print('Hessian vector product =', cg.hess_vec([3.,5.,7.],[4,5,6]))
def _forward(self, x, *args, **kwds): # forward mode without building the computational graph tmp = UTPM.init_jacobian(x) y = self.fun(tmp, *args, **kwds) return UTPM.extract_jacobian(y)
a = 1./3. Cp = 4.*a*(1-a)**2. A = r_0**2*np.pi V = (1-loss)*U_velocity "Calculate Power from a single turbine" P = 0.5*rho*A*Cp*V**3 return P if __name__ == '__main__': rho = 1.1716 U_velocity = 8. r_0 = 40 loss = 0.5 params = np.array([r_0, rho, U_velocity]) xin = loss x_algopy = UTPM.init_jacobian(xin) power = jensen_power(x_algopy,params) derivative_automatic = UTPM.extract_jacobian(power) print "Automatic Differentiation Derivative: ", derivative_automatic h = 1e-6 xin_h = xin + h power_h = jensen_power(xin_h,params) power_normal = jensen_power(loss,params) derivative_finite = (power_h - power_normal)/h print derivative_finite