def plotTest_MSEs_RELs_3act_funcs(mse2data1, mse2data2, mse2data3, rel2data1, rel2data2, rel2data3, actName1=None, actName2=None, actName3=None, seedNo=1000, outPath=None, xaxis_scale=False, yaxis_scale=False): plt.figure(figsize=(10, 8)) ax = plt.gca() plt.plot(mse2data1, 'g-.', label=str('MSE-' + actName1)) plt.plot(rel2data1, 'b:', label=str('REL-' + actName1)) plt.plot(mse2data2, 'm--.', label=str('MSE-' + actName2)) plt.plot(rel2data2, 'c-*', label=str('REL-' + actName2)) plt.plot(mse2data3, color='k', marker='v', label=str('MSE-' + actName3)) plt.plot(rel2data3, color='gold', marker='x', label=str('REL-' + actName3)) if xaxis_scale: ax.set_yscale('log') if yaxis_scale: ax.set_yscale('log') plt.xlabel('epoch', fontsize=14) plt.ylabel('error', fontsize=14) ax.legend(loc='center', bbox_to_anchor=(0.485, 1.055), ncol=3, fontsize=15) # plt.legend(fontsize=11) # plt.title(' train error', fontsize=15) fntmp = '%s/%stest_Errs' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plot_Test_MSE_REL_3Types(mse2s2ReLU, mse2sReLU, mse2ReLU, rel2s2ReLU, rel2sReLU, rel2ReLU, epoches=100, seedNo=1000, outPath=None): # fig2mse_test = plt.figure(figsize=(10, 8), dpi=98) fig2mse_test = plt.figure(figsize=(9, 6.5), dpi=98) ax = plt.gca() ax.plot(epoches, mse2s2ReLU, 'g-.', label='MSE-s2ReLU') ax.plot(epoches, rel2s2ReLU, 'b:', label='REL-s2ReLU') ax.plot(epoches, mse2sReLU, 'm--', label='MSE-sReLU') ax.plot(epoches, rel2sReLU, 'c-*', label='REL-sReLU') ax.plot(epoches, mse2ReLU, color='k', marker='v', label='MSE-ReLU') ax.plot(epoches, rel2ReLU, color='gold', marker='x', label='REL-ReLU') plt.xlabel('epoch/1000', fontsize=14) plt.ylabel('error', fontsize=14) ax.set_yscale('log') ax.legend(loc='center', bbox_to_anchor=(0.49, 1.06), ncol=3, fontsize=12) # plt.legend(fontsize=11) # plt.title('testing error ', fontsize=15) fntmp = '%s/%stest_error' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plot_Hot_point_wise_err(point_wise_err, size_vec2mat=20, actName=None, seedNo=1000, outPath=None): # 逐点误差分布热力图 square_err_color2sin = np.reshape(point_wise_err, (size_vec2mat, size_vec2mat)) plt.figure(figsize=(10, 8)) ax = plt.gca() plt.imshow(square_err_color2sin, interpolation='nearest', cmap=cm.coolwarm, origin='lower') plt.colorbar(shrink=0.85) plt.xticks(()) plt.yticks(()) # plt.title('point-wise error', fontsize=14) if str.lower(actName) == 'srelu': fntmp = '%s/%spErr_%s' % (outPath, seedNo, 'sReLU') elif str.lower(actName) == 's2relu': fntmp = '%s/%spErr_%s' % (outPath, seedNo, 's2ReLU') elif str.lower(actName) == 'relu': fntmp = '%s/%spErr_%s' % (outPath, seedNo, 'ReLU') elif str.lower(actName) == 'tanh': fntmp = '%s/%spErr_%s' % (outPath, seedNo, 'tanh') elif str.lower(actName) == 'sin': fntmp = '%s/%spErr_%s' % (outPath, seedNo, 'sin') elif str.lower(actName) == 'sintanh': fntmp = '%s/%spErr_%s' % (outPath, seedNo, 'stanh') elif str.lower(actName) == 'singauss': fntmp = '%s/%spErr_%s' % (outPath, seedNo, 'sgauss') elif str.lower(actName) == 'gauss': fntmp = '%s/%spErr_%s' % (outPath, seedNo, 'gauss') elif str.lower(actName) == 'mexican': fntmp = '%s/%spErr_%s' % (outPath, seedNo, 'mexican') elif str.lower(actName) == 'modify_mexican': fntmp = '%s/%spErr_%s' % (outPath, seedNo, 'mmexican') DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plot_Hot_solution2test(solu2test, size_vec2mat=20, actName=None, seedNo=1000, outPath=None): solu2color = np.reshape(solu2test, (size_vec2mat, size_vec2mat)) plt.figure() ax = plt.gca() plt.imshow(solu2color, interpolation='nearest', cmap=cm.coolwarm, origin='lower') plt.colorbar(shrink=0.9) plt.xticks(()) plt.yticks(()) # plt.title('exact solution', fontsize=14) if str.lower(actName) == 'utrue': fntmp = '%s/%s%s' % (outPath, seedNo, 'Utrue2test') elif str.lower(actName) == 'srelu': fntmp = '%s/%s_%s' % (outPath, seedNo, 'UsReLU2test') elif str.lower(actName) == 's2relu': fntmp = '%s/%s_%s' % (outPath, seedNo, 'Us2ReLU2test') elif str.lower(actName) == 'relu': fntmp = '%s/%s_%s' % (outPath, seedNo, 'UReLU2test') elif str.lower(actName) == 'tanh': fntmp = '%s/%s_%s' % (outPath, seedNo, 'Utanh2test') elif str.lower(actName) == 'sintanh': fntmp = '%s/%s_%s' % (outPath, seedNo, 'Ustanh2test') elif str.lower(actName) == 'singauss': fntmp = '%s/%s_%s' % (outPath, seedNo, 'Usgauss2test') elif str.lower(actName) == 'gauss': fntmp = '%s/%s_%s' % (outPath, seedNo, 'Ugauss2test') elif str.lower(actName) == 'mexican': fntmp = '%s/%s_%s' % (outPath, seedNo, 'Umexican2test') elif str.lower(actName) == 'modify_mexican': fntmp = '%s/%s_%s' % (outPath, seedNo, 'Ummexican2test') DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plot_scatter_solutions2test(solu1_test, solu2_test, test_batch, actName1=None, actName2=None, seedNo=1000, outPath=None): dim2test_batch = 2 if 2 == dim2test_batch: test_x_bach = np.reshape(test_batch[:, 0], newshape=[-1, 1]) test_y_bach = np.reshape(test_batch[:, 1], newshape=[-1, 1]) # 绘制解的3D散点图(真解和预测解) fig = plt.figure(figsize=(10, 10)) ax = Axes3D(fig) ax.scatter(test_x_bach, test_y_bach, solu1_test, c='b', label=actName1) ax.scatter(test_x_bach, test_y_bach, solu2_test, c='b', label=actName2) # 绘制图例 ax.legend(loc='best') # 添加坐标轴(顺序是X,Y, Z) ax.set_xlabel('X', fontdict={'size': 15, 'color': 'red'}) ax.set_ylabel('Y', fontdict={'size': 15, 'color': 'red'}) ax.set_zlabel('u', fontdict={'size': 15, 'color': 'red'}) # plt.title('solution', fontsize=15) fntmp = '%s/%ssolus_%s' % (outPath, seedNo, actName2) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0) else: return
def plot_Hot_point_wise_err(point_wise_err, size_vec2mat=20, actName=None, seedNo=1000, outPath=None): # 逐点误差分布热力图 square_err_color2sin = np.reshape(point_wise_err, (size_vec2mat, size_vec2mat)) plt.figure(figsize=(10, 8)) ax = plt.gca() plt.imshow(square_err_color2sin, interpolation='nearest', cmap=cm.coolwarm, origin='lower') plt.colorbar(shrink=0.85) plt.xticks(()) plt.yticks(()) # # plt.title('point-wise error', fontsize=14) # if actName == 'sReLU': # fntmp = '%s/%spErr_%s' % (outPath, seedNo, 'sReLU') # elif actName == 's2ReLU': # fntmp = '%s/%spErr_%s' % (outPath, seedNo, 's2ReLU') # elif actName == 'ReLU': # fntmp = '%s/%spErr_%s' % (outPath, seedNo, 'ReLU') fntmp = '%s/%spErr_%s' % (outPath, seedNo, actName) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plot_Hot_solution2test(solu2test, size_vec2mat=20, actName=None, seedNo=1000, outPath=None): solu2color = np.reshape(solu2test, (size_vec2mat, size_vec2mat)) plt.figure() ax = plt.gca() plt.imshow(solu2color, interpolation='nearest', cmap=cm.coolwarm, origin='lower') plt.colorbar(shrink=0.9) plt.xticks(()) plt.yticks(()) # # plt.title('exact solution', fontsize=14) # if actName == 'Utrue': # fntmp = '%s/%s%s' % (outPath, seedNo, 'Utrue2test') # elif actName == 'sReLU': # fntmp = '%s/%s_%s' % (outPath, seedNo, 'UsReLU2test') # elif actName == 's2ReLU': # fntmp = '%s/%s_%s' % (outPath, seedNo, 'Us2ReLU2test') # elif actName == 'ReLU': # fntmp = '%s/%s_%s' % (outPath, seedNo, 'UReLU2test') if str.lower(actName) == 'utrue': fntmp = '%s/%s%s' % (outPath, seedNo, 'Utrue2test') else: fntmp = '%s/%s_%s' % (outPath, seedNo, actName) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plotTrain_MSE_REL_1act_func(data2mse, data2rel, actName=None, seedNo=1000, outPath=None, xaxis_scale=False, yaxis_scale=False): plt.figure() ax = plt.gca() plt.plot(data2mse, 'r-.', label='MSE') plt.plot(data2rel, 'b:', label='REL') if xaxis_scale: ax.set_yscale('log') if yaxis_scale: ax.set_yscale('log') plt.xlabel('epoch', fontsize=18) plt.ylabel('error', fontsize=18) plt.legend(fontsize=18) # # plt.title('training error', fontsize=15) # if actName == 'sReLU': # fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'sReLU') # elif actName == 's2ReLU': # fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 's2ReLU') # elif actName == 'ReLU': # fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'ReLU') fntmp = '%s/%strainErr_%s' % (outPath, seedNo, actName) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plot_Test_MSE_REL_2ActFuncs(data_mse1, data_rel1, data_mse2, data_rel2, epoches, actName1=None, actName2=None, seedNo=1000, outPath=None, xaxis_scale=False, yaxis_scale=False): # fig2mse_test = plt.figure(figsize=(10, 8), dpi=98) fig2mse_test = plt.figure(figsize=(9, 6.5), dpi=98) ax = plt.gca() ax.plot(epoches, data_mse1, 'g-.', label=str('MSE-' + actName1)) ax.plot(epoches, data_rel1, 'b:', label=str('REL' + actName1)) ax.plot(epoches, data_mse2, 'm--', label=str('MSE' + actName2)) ax.plot(epoches, data_rel2, 'c-*', label=str('REL' + actName2)) plt.xlabel('epoch/1000', fontsize=14) plt.ylabel('error', fontsize=14) if xaxis_scale: ax.set_yscale('log') if yaxis_scale: ax.set_yscale('log') ax.legend(loc='center', bbox_to_anchor=(0.49, 1.06), ncol=3, fontsize=12) # plt.legend(fontsize=11) # plt.title('testing error ', fontsize=15) fntmp = '%s/%stest_error' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plot_3Trainlosses_1act_func(data2loss_1, data2loss_2, data2loss_3, lossName1=None, lossName2=None, lossName3=None, lossType=None, seedNo=1000, outPath=None, xaxis_scale=False, yaxis_scale=False): plt.figure() ax = plt.gca() plt.plot(data2loss_1, 'b-.', label=lossName1) plt.plot(data2loss_2, 'r:', label=lossName2) plt.plot(data2loss_3, 'c*', label=lossName3) plt.xlabel('epoch', fontsize=14) plt.ylabel('loss', fontsize=14) plt.legend(fontsize=13) if xaxis_scale: ax.set_yscale('log') if yaxis_scale: ax.set_yscale('log') # plt.title('loss_it', fontsize=15) fntmp = '%s/%s%s' % (outPath, seedNo, lossType) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plotTrain_MSE_REL_1act_func(data2mse, data2rel, actName=None, seedNo=1000, outPath=None, xaxis_scale=False, yaxis_scale=False): plt.figure() ax = plt.gca() plt.plot(data2mse, 'r-.', label='MSE') plt.plot(data2rel, 'b:', label='REL') if xaxis_scale: ax.set_yscale('log') if yaxis_scale: ax.set_yscale('log') plt.xlabel('epoch', fontsize=18) plt.ylabel('error', fontsize=18) plt.legend(fontsize=18) # plt.title('training error', fontsize=15) if str.lower(actName) == 'srelu': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'sReLU') elif str.lower(actName) == 'sin': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'sin') elif str.lower(actName) == 'sinaddcos': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'sincos') elif str.lower(actName) == 's2relu': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 's2ReLU') elif str.lower(actName) == 's3relu': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 's3ReLU') elif str.lower(actName) == 'csrelu': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'CsReLU') elif str.lower(actName) == 'relu': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'ReLU') elif str.lower(actName) == 'elu': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'elu') elif str.lower(actName) == 'gelu': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'gelu') elif str.lower(actName) == 'mgelu': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'mgelu') elif str.lower(actName) == 'tanh': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'tanh') elif str.lower(actName) == 'sintanh': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'sintanh') elif str.lower(actName) == 'singauss': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'singauss') elif str.lower(actName) == 'gauss': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'gauss') elif str.lower(actName) == 'mish': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'mish') elif str.lower(actName) == 'gcu': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'gcu') elif str.lower(actName) == 'mexican': fntmp = '%s/%strainErr_%s' % (outPath, seedNo, 'mexican') elif str.lower(actName) == 'modify_mexican': fntmp = '%s/%s_%s' % (outPath, seedNo, 'Ummexican2test') elif str.lower(actName) == 'sin_modify_mexican': fntmp = '%s/%s_%s' % (outPath, seedNo, 'Usm_mexican2test') else: fntmp = '%s/%s_%s' % (outPath, seedNo, actName) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def print_and_log_test_one_epoch(mse2test, res2test, log_out=None): # 将运行结果打印出来 print('mean square error of predict and real for testing: %.10f' % mse2test) print('residual error of predict and real for testing: %.10f\n' % res2test) DNN_tools.log_string( 'mean square error of predict and real for testing: %.10f' % mse2test, log_out) DNN_tools.log_string( 'residual error of predict and real for testing: %.10f\n\n' % res2test, log_out)
def plotTrain_REL_1act_func(data2rel, relType=None, seedNo=1000, outPath=None, xaxis_scale=False, yaxis_scale=False): plt.figure() ax = plt.gca() plt.plot(data2rel, 'b-.', label=relType) plt.xlabel('epoch', fontsize=14) plt.ylabel('error', fontsize=14) plt.legend(fontsize=13) if xaxis_scale: ax.set_yscale('log') if yaxis_scale: ax.set_yscale('log') # plt.title('training mse', fontsize=13) fntmp = '%s/%strain_mse' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plotTrain_loss_1act_func(data2loss, lossType=None, seedNo=1000, outPath=None, xaxis_scale=False, yaxis_scale=False): plt.figure() ax = plt.gca() plt.plot(data2loss, 'b-.', label=lossType) plt.xlabel('epoch', fontsize=14) plt.ylabel(lossType, fontsize=14) plt.legend(fontsize=18) if xaxis_scale: ax.set_yscale('log') if yaxis_scale: ax.set_yscale('log') # plt.title('loss_it', fontsize=15) fntmp = '%s/%s%s' % (outPath, seedNo, lossType) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plotTest_MSE_REL(data2mse, data2rel, epoches, actName=None, seedNo=1000, outPath=None, xaxis_scale=False, yaxis_scale=False): plt.figure() ax = plt.gca() plt.plot(epoches, data2mse, 'r-.', label='MSE') plt.plot(epoches, data2rel, 'b:', label='REL') plt.xlabel('epoch/1000', fontsize=18) # plt.ylabel('L2error', fontsize=18) if xaxis_scale: ax.set_yscale('log') if yaxis_scale: ax.set_yscale('log') plt.legend(fontsize=18) plt.title('testing error ', fontsize=15) fntmp = '%s/%stestERR_%s' % (outPath, seedNo, actName) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plot_2TestRELs(data2rel1, data2rel2, relType1=None, relType2=None, epoches=1000, seedNo=1000, outPath=None, xaxis_scale=False, yaxis_scale=False): plt.figure() ax = plt.gca() plt.plot(epoches, data2rel1, 'r-.', label=relType1) plt.plot(epoches, data2rel2, 'b:', label=relType2) plt.xlabel('epoch/1000', fontsize=18) # plt.ylabel('L2error', fontsize=18) if xaxis_scale: ax.set_yscale('log') if yaxis_scale: ax.set_yscale('log') plt.legend(fontsize=18) plt.title('testing mse ', fontsize=15) fntmp = '%s/%stest_rel' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plotTrain_MSEs_2act_funcs(data2mse1, data2mse2, mseName1=None, mseName2=None, seedNo=1000, outPath=None, xaxis_scale=False, yaxis_scale=False): plt.figure() ax = plt.gca() plt.plot(data2mse1, 'b-.', label=mseName1) plt.plot(data2mse2, 'r:', label=mseName2) plt.xlabel('epoch', fontsize=14) plt.ylabel('error', fontsize=14) plt.legend(fontsize=13) if xaxis_scale: ax.set_yscale('log') if yaxis_scale: ax.set_yscale('log') # plt.title('training mse', fontsize=13) fntmp = '%s/%strain_mses' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plot_2scatter_solus2test(exact_solu, predict_solu, coord_points=None, batch_size=100, seedNo=1000, outPath=None, actName=None): # fig11 = plt.figure(figsize=(9, 6.5)) # plt.scatter(coord_points, exact_solu, s=batch_size, c='b', marker='.', label='Exact') # plt.scatter(coord_points, predict_solu, s=batch_size, c='r', marker='1', label='UNN') # plt.legend(loc='right', bbox_to_anchor=(0.9, 1.05), ncol=4, fontsize=12) # plt.xlabel('x', fontsize=14) # plt.ylabel('y', fontsize=14) fig11 = plt.figure(figsize=(9, 6.5)) ax = plt.gca() ax.scatter(coord_points, exact_solu, s=batch_size, c='b', marker='.', label='Exact') ax.scatter(coord_points, predict_solu, s=batch_size, c='r', marker='1', label='UNN2'+actName) ax.legend(loc='right', bbox_to_anchor=(0.9, 1.05), ncol=4, fontsize=12) ax.set_xlabel('x', fontsize=14) ax.set_ylabel('solus', fontsize=14) fntmp = '%s/%ssolu2test' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plot_testSolu2convid(solu_arr, name2solu=None, coord_points2test=None, seedNo=1000, outPath=None, xaxis_scale=False, yaxis_scale=False): plt.figure(figsize=(10, 8)) ax = plt.gca() plt.plot(coord_points2test, solu_arr, 'r-.', label=str(name2solu)) plt.xlabel('day', fontsize=18) plt.ylabel(str(name2solu), fontsize=18) if xaxis_scale: ax.set_yscale('log') if yaxis_scale: ax.set_yscale('log') plt.legend(fontsize=18) plt.title(str(name2solu), fontsize=15) fntmp = '%s/%s' % (outPath, str(name2solu)) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plotTrain_losses(loss2act1, loss2act2, loss2act3, lossType=None, actName1=None, actName2=None, actName3=None, seedNo=1000, outPath=None): if 'loss_it' == lossType: plt.figure() ax = plt.gca() plt.plot(loss2act1, 'b-.', label='actName1') plt.plot(loss2act2, 'r:', label='actName2') plt.plot(loss2act3, 'c-*', label='actName3') plt.xlabel('epoch', fontsize=14) plt.ylabel('loss_it', fontsize=14) plt.legend(fontsize=13) # plt.title('loss_it', fontsize=15) fntmp = '%s/%s%s' % (outPath, seedNo, lossType) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def plotTrain_losses(loss2s2ReLU, loss2sReLU, loss2ReLU, lossType=None, seedNo=1000, outPath=None): if 'loss_it' == lossType: plt.figure() ax = plt.gca() plt.plot(loss2s2ReLU, 'b-.', label='s2ReLU') plt.plot(loss2sReLU, 'r:', label='sReLU') plt.plot(loss2ReLU, 'c-*', label='ReLU') plt.xlabel('epoch', fontsize=14) plt.ylabel('loss_it', fontsize=14) plt.legend(fontsize=13) # plt.title('loss_it', fontsize=15) fntmp = '%s/%sloss_it' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0) elif 'loss_bd' == lossType: plt.figure() ax = plt.gca() plt.plot(loss2s2ReLU, 'b-.', label='s2ReLU') plt.plot(loss2sReLU, 'r:', label='sReLU') plt.plot(loss2ReLU, 'c-*', label='ReLU') ax.set_yscale('log') plt.xlabel('epoch', fontsize=14) plt.ylabel('loss_bd', fontsize=14) plt.legend(fontsize=13) # plt.title('loss_bd', fontsize=15) fntmp = '%s/%sloss_bd' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0) elif 'loss' == lossType: plt.figure() ax = plt.gca() plt.plot(loss2s2ReLU, 'b-.', label='s2ReLU') plt.plot(loss2sReLU, 'r:', label='sReLU') plt.plot(loss2ReLU, 'c-*', label='ReLU') plt.xlabel('epoch', fontsize=14) plt.ylabel('loss', fontsize=14) plt.legend(fontsize=13) # plt.title('loss', fontsize=15) fntmp = '%s/%sloss' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def solve_Multiscale_PDE(R): log_out_path = R['FolderName'] # 将路径从字典 R 中提取出来 if not os.path.exists(log_out_path): # 判断路径是否已经存在 os.mkdir(log_out_path) # 无 log_out_path 路径,创建一个 log_out_path 路径 outfile_name1 = '%s%s.txt' % ('log2', 'train') log_fileout_NN = open(os.path.join(log_out_path, outfile_name1), 'w') # 在这个路径下创建并打开一个可写的 log_train.txt文件 dictionary_out2file(R, log_fileout_NN, actName2normal=R['act_name2NN1'], actName2scale=R['act_name2NN2']) # laplace 问题需要的设置 batchsize_it = R['batch_size2interior'] batchsize_bd = R['batch_size2boundary'] bd_penalty_init = R[ 'init_boundary_penalty'] # Regularization parameter for boundary conditions lr_decay = R['learning_rate_decay'] learning_rate = R['learning_rate'] init_penalty2powU = R['balance2solus'] hidden2normal = R['hidden2normal'] hidden2scale = R['hidden2scale'] wb_regular = R[ 'regular_weight_biases'] # Regularization parameter for weights and biases # ------- set the problem --------- input_dim = R['input_dim'] out_dim = R['output_dim'] act_func1 = R['act_name2NN1'] act_func2 = R['act_name2NN2'] region_l = 0.0 region_r = 1.0 if R['PDE_type'] == 'general_laplace': # -laplace u = f region_l = 0.0 region_r = 1.0 f, u_true, u_left, u_right = laplace_eqs1d.get_laplace_infos( input_dim=input_dim, out_dim=out_dim, left_bottom=region_l, right_top=region_r, laplace_name=R['equa_name']) elif R['PDE_type'] == 'p_laplace': # 求解如下方程, A_eps(x) 震荡的比较厉害,具有多个尺度 # d **** d **** # - ---- | A_eps(x)* ---- u_eps(x) | =f(x), x \in R^n # dx **** dx **** # 问题区域,每个方向设置为一样的长度。等网格划分,对于二维是方形区域 p_index = R['order2laplace'] epsilon = R['epsilon'] if 2 == p_index: region_l = 0.0 region_r = 1.0 u_true, f, A_eps, u_left, u_right = pLaplace_eqs1d.get_infos_2laplace( in_dim=input_dim, out_dim=out_dim, region_a=region_l, region_b=region_r, p=p_index, eps=epsilon) elif 3 == p_index: region_l = 0.0 region_r = 1.0 u_true, f, A_eps, u_left, u_right = pLaplace_eqs1d.get_infos_3laplace( in_dim=input_dim, out_dim=out_dim, region_a=region_l, region_b=region_r, p=p_index, eps=epsilon) elif 5 == p_index: region_l = 0.0 region_r = 1.0 u_true, f, A_eps, u_left, u_right = pLaplace_eqs1d.get_infos_5laplace( in_dim=input_dim, out_dim=out_dim, region_a=region_l, region_b=region_r, p=p_index, eps=epsilon) elif 8 == p_index: region_l = 0.0 region_r = 1.0 u_true, f, A_eps, u_left, u_right = pLaplace_eqs1d.get_infos_8laplace( in_dim=input_dim, out_dim=out_dim, region_a=region_l, region_b=region_r, p=p_index, eps=epsilon) else: region_l = 0.0 region_r = 1.0 u_true, f, A_eps, u_left, u_right = pLaplace_eqs1d.get_infos_pLaplace( in_dim=input_dim, out_dim=out_dim, region_a=region_l, region_b=region_r, p=p_index, eps=epsilon, eqs_name=R['equa_name']) # 初始化权重和和偏置的模式 if R['weight_biases_model'] == 'general_model': flag_normal = 'WB_NN2normal' flag_scale = 'WB_NN2scale' # Weights, Biases = PDE_DNN_base.Initial_DNN2different_hidden(input_dim, out_dim, hidden_layers, flag) # Weights, Biases = laplace_DNN1d_base.initialize_NN_xavier(input_dim, out_dim, hidden_layers, flag1) # Weights, Biases = laplace_DNN1d_base.initialize_NN_random_normal(input_dim, out_dim, hidden_layers, flag1) if R['model2normal'] == 'PDE_DNN_Cos_C_Sin_Base' or R[ 'model2normal'] == 'DNN_adaptCosSin_Base': W2NN_Normal, B2NN_Normal = DNN_base.initialize_NN_random_normal2_CS( input_dim, out_dim, hidden2normal, flag_normal) else: W2NN_Normal, B2NN_Normal = DNN_base.initialize_NN_random_normal2( input_dim, out_dim, hidden2normal, flag_normal) if R['model2scale'] == 'PDE_DNN_Cos_C_Sin_Base' or R[ 'model2scale'] == 'DNN_adaptCosSin_Base': W2NN_freqs, B2NN_freqs = DNN_base.initialize_NN_random_normal2_CS( input_dim, out_dim, hidden2scale, flag_scale) else: W2NN_freqs, B2NN_freqs = DNN_base.initialize_NN_random_normal2( input_dim, out_dim, hidden2scale, flag_scale) global_steps = tf.Variable(0, trainable=False) with tf.device('/gpu:%s' % (R['gpuNo'])): with tf.variable_scope('vscope', reuse=tf.AUTO_REUSE): X_it = tf.placeholder(tf.float32, name='X_it', shape=[None, input_dim]) # * 行 1 列 X_left_bd = tf.placeholder(tf.float32, name='X_left_bd', shape=[None, input_dim]) # * 行 1 列 X_right_bd = tf.placeholder(tf.float32, name='X_right_bd', shape=[None, input_dim]) # * 行 1 列 bd_penalty = tf.placeholder_with_default(input=1e3, shape=[], name='bd_p') penalty2powU = tf.placeholder_with_default(input=1.0, shape=[], name='p_powU') in_learning_rate = tf.placeholder_with_default(input=1e-5, shape=[], name='lr') train_opt = tf.placeholder_with_default(input=True, shape=[], name='train_opt') if R['model2normal'] == 'PDE_DNN': U_NN_Normal = DNN_base.PDE_DNN(X_it, W2NN_Normal, B2NN_Normal, hidden2normal, activate_name=act_func1) ULeft_NN_Normal = DNN_base.PDE_DNN(X_left_bd, W2NN_Normal, B2NN_Normal, hidden2normal, activate_name=act_func1) URight_NN_Normal = DNN_base.PDE_DNN(X_right_bd, W2NN_Normal, B2NN_Normal, hidden2normal, activate_name=act_func1) elif R['model2normal'] == 'PDE_DNN_Cos_C_Sin_Base': freq = [1] U_NN_Normal = DNN_base.PDE_DNN_Cos_C_Sin_Base( X_it, W2NN_Normal, B2NN_Normal, hidden2normal, freq, activate_name=act_func1) ULeft_NN_Normal = DNN_base.PDE_DNN_Cos_C_Sin_Base( X_left_bd, W2NN_Normal, B2NN_Normal, hidden2normal, freq, activate_name=act_func1) URight_NN_Normal = DNN_base.PDE_DNN_Cos_C_Sin_Base( X_right_bd, W2NN_Normal, B2NN_Normal, hidden2normal, freq, activate_name=act_func1) elif R['model2normal'] == 'DNN_adaptCosSin_Base': freq = [1] U_NN_Normal = DNN_base.DNN_adaptCosSin_Base( X_it, W2NN_Normal, B2NN_Normal, hidden2normal, freq, activate_name=act_func1) ULeft_NN_Normal = DNN_base.DNN_adaptCosSin_Base( X_left_bd, W2NN_Normal, B2NN_Normal, hidden2normal, freq, activate_name=act_func1) URight_NN_Normal = DNN_base.DNN_adaptCosSin_Base( X_right_bd, W2NN_Normal, B2NN_Normal, hidden2normal, freq, activate_name=act_func1) freqs = R['freqs'] if R['model2scale'] == 'PDE_DNN_scale': U_NN_freqs = DNN_base.PDE_DNN_scale(X_it, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) ULeft_NN_freqs = DNN_base.PDE_DNN_scale( X_left_bd, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) URight_NN_freqs = DNN_base.PDE_DNN_scale( X_right_bd, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) elif R['model2scale'] == 'PDE_DNN_adapt_scale': U_NN_freqs = DNN_base.PDE_DNN_adapt_scale( X_it, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) ULeft_NN_freqs = DNN_base.PDE_DNN_adapt_scale( X_left_bd, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) URight_NN_freqs = DNN_base.PDE_DNN_adapt_scale( X_right_bd, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) elif R['model2scale'] == 'PDE_DNN_FourierBase': U_NN_freqs = DNN_base.PDE_DNN_FourierBase( X_it, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) ULeft_NN_freqs = DNN_base.PDE_DNN_FourierBase( X_left_bd, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) URight_NN_freqs = DNN_base.PDE_DNN_FourierBase( X_right_bd, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) elif R['model2scale'] == 'PDE_DNN_Cos_C_Sin_Base': U_NN_freqs = DNN_base.PDE_DNN_Cos_C_Sin_Base( X_it, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) ULeft_NN_freqs = DNN_base.PDE_DNN_Cos_C_Sin_Base( X_left_bd, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) URight_NN_freqs = DNN_base.PDE_DNN_Cos_C_Sin_Base( X_right_bd, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) elif R['model2scale'] == 'DNN_adaptCosSin_Base': U_NN_freqs = DNN_base.DNN_adaptCosSin_Base( X_it, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) ULeft_NN_freqs = DNN_base.DNN_adaptCosSin_Base( X_left_bd, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) URight_NN_freqs = DNN_base.DNN_adaptCosSin_Base( X_right_bd, W2NN_freqs, B2NN_freqs, hidden2scale, freqs, activate_name=act_func2) U_NN = U_NN_Normal + U_NN_freqs # 变分形式的loss of interior,训练得到的 U_NN1 是 * 行 1 列, 因为 一个点对(x,y) 得到一个 u 值 dU_NN_Normal = tf.gradients(U_NN_Normal, X_it)[0] # * 行 2 列 dU_NN_freqs = tf.gradients(U_NN_freqs, X_it)[0] # * 行 2 列 if R['variational_loss'] == 1: dU_NN = tf.add(dU_NN_Normal, dU_NN_freqs) if R['PDE_type'] == 'general_laplace': laplace_norm2NN = tf.reduce_sum(tf.square(dU_NN), axis=-1) loss_it_NN = (1.0 / 2) * tf.reshape(laplace_norm2NN, shape=[-1, 1]) - \ tf.multiply(tf.reshape(f(X_it), shape=[-1, 1]), U_NN) elif R['PDE_type'] == 'p_laplace': # a_eps = A_eps(X_it) # * 行 1 列 a_eps = 1 / (2 + tf.cos(2 * np.pi * X_it / epsilon)) laplace_p_pow2NN = tf.reduce_sum( a_eps * tf.pow(tf.abs(dU_NN), p_index), axis=-1) loss_it_NN = (1.0 / p_index) * tf.reshape(laplace_p_pow2NN, shape=[-1, 1]) - \ tf.multiply(tf.reshape(f(X_it), shape=[-1, 1]), U_NN) Loss_it2NN = tf.reduce_mean(loss_it_NN) * (region_r - region_l) if R['wavelet'] == 1: # |Uc*Uf|^2-->0 norm2UdU = tf.square(tf.multiply(U_NN_Normal, U_NN_freqs)) UNN_dot_UNN = tf.reduce_mean(norm2UdU, axis=0) elif R['wavelet'] == 2: # |a(x)*(grad Uc)*(grad Uf)|^2-->0 dU_dot_dU = tf.multiply(dU_NN_Normal, dU_NN_freqs) sum2dUdU = tf.reshape(tf.reduce_sum(dU_dot_dU, axis=-1), shape=[-1, 1]) norm2AdUdU = tf.square(tf.multiply(a_eps, sum2dUdU)) # norm2AdUdU = tf.square(sum2dUdU) UNN_dot_UNN = tf.reduce_mean(norm2AdUdU, axis=0) else: U_dot_U = tf.reduce_mean(tf.square( tf.multiply(U_NN_Normal, U_NN_freqs)), axis=0) dU_dot_dU = tf.multiply(dU_NN_Normal, dU_NN_freqs) sum2dUdU = tf.reshape(tf.reduce_sum(dU_dot_dU, axis=-1), shape=[-1, 1]) norm2AdUdU = tf.square(tf.multiply(a_eps, sum2dUdU)) UNN_dot_UNN = tf.reduce_mean(norm2AdUdU, axis=0) + U_dot_U elif R['variational_loss'] == 2: dU_NN = tf.add(dU_NN_Normal, dU_NN_freqs) if R['PDE_type'] == 'general_laplace': laplace_norm2NN = tf.reduce_sum(tf.square(dU_NN), axis=-1) loss_it_NN = (1.0 / 2) * tf.reshape(laplace_norm2NN, shape=[-1, 1]) - \ tf.multiply(tf.reshape(f(X_it), shape=[-1, 1]), U_NN) elif R['PDE_type'] == 'p_laplace': # a_eps = A_eps(X_it) # * 行 1 列 a_eps = 1 / (2 + tf.cos(2 * np.pi * X_it / epsilon)) laplace_p_pow2NN = tf.reduce_sum( a_eps * tf.pow(tf.abs(dU_NN), p_index), axis=-1) loss_it_NN = (1.0 / p_index) * tf.reshape(laplace_p_pow2NN, shape=[-1, 1]) - \ tf.multiply(tf.reshape(f(X_it), shape=[-1, 1]), U_NN) Loss_it2NN = tf.reduce_mean(loss_it_NN) * (region_r - region_l) if R['wavelet'] == 1: norm2UdU = tf.square(tf.multiply(U_NN_Normal, U_NN_freqs)) UNN_dot_UNN = tf.reduce_mean(norm2UdU, axis=0) else: UNN_dot_UNN = tf.constant(0.0) Loss2UNN_dot_UNN = penalty2powU * UNN_dot_UNN U_left = tf.reshape(u_left(X_left_bd), shape=[-1, 1]) U_right = tf.reshape(u_right(X_right_bd), shape=[-1, 1]) loss_bd_Normal = tf.square(ULeft_NN_Normal - U_left) + tf.square(URight_NN_Normal - U_right) loss_bd_Freqs = tf.square(ULeft_NN_freqs - U_left) + tf.square(URight_NN_freqs - U_right) Loss_bd2NN = tf.reduce_mean(loss_bd_Normal) + tf.reduce_mean( loss_bd_Freqs) if R['regular_weight_model'] == 'L1': regular_WB_Normal = DNN_base.regular_weights_biases_L1( W2NN_Normal, B2NN_Normal) # 正则化权重和偏置 L1正则化 regular_WB_Scale = DNN_base.regular_weights_biases_L1( W2NN_freqs, B2NN_freqs) # 正则化权重和偏置 L1正则化 elif R['regular_weight_model'] == 'L2': regular_WB_Normal = DNN_base.regular_weights_biases_L2( W2NN_Normal, B2NN_Normal) # 正则化权重和偏置 L2正则化 regular_WB_Scale = DNN_base.regular_weights_biases_L2( W2NN_freqs, B2NN_freqs) # 正则化权重和偏置 L2正则化 else: regular_WB_Normal = tf.constant(0.0) # 无正则化权重参数 regular_WB_Scale = tf.constant(0.0) penalty_Weigth_Bias = wb_regular * (regular_WB_Normal + regular_WB_Scale) Loss2NN = Loss_it2NN + bd_penalty * Loss_bd2NN + Loss2UNN_dot_UNN + penalty_Weigth_Bias my_optimizer = tf.train.AdamOptimizer(in_learning_rate) if R['variational_loss'] == 1: if R['train_group'] == 1: train_op1 = my_optimizer.minimize(Loss_it2NN, global_step=global_steps) train_op2 = my_optimizer.minimize(Loss_bd2NN, global_step=global_steps) train_op3 = my_optimizer.minimize(Loss2UNN_dot_UNN, global_step=global_steps) train_op4 = my_optimizer.minimize(Loss2NN, global_step=global_steps) train_Loss2NN = tf.group(train_op1, train_op2, train_op3, train_op4) elif R['train_group'] == 2: train_op1 = my_optimizer.minimize(Loss2NN, global_step=global_steps) train_op2 = my_optimizer.minimize(Loss_bd2NN, global_step=global_steps) train_op3 = my_optimizer.minimize(Loss2UNN_dot_UNN, global_step=global_steps) train_Loss2NN = tf.group(train_op1, train_op2, train_op3) else: train_Loss2NN = my_optimizer.minimize( Loss2NN, global_step=global_steps) elif R['variational_loss'] == 2: if R['train_group'] == 1: train_op1 = my_optimizer.minimize(Loss_it2NN, global_step=global_steps) train_op2 = my_optimizer.minimize(Loss_bd2NN, global_step=global_steps) train_op3 = my_optimizer.minimize(Loss2NN, global_step=global_steps) train_Loss2NN = tf.group(train_op1, train_op2, train_op3) elif R['train_group'] == 2: train_op1 = my_optimizer.minimize(Loss2NN, global_step=global_steps) train_op2 = my_optimizer.minimize(Loss_bd2NN, global_step=global_steps) train_Loss2NN = tf.group(train_op1, train_op2) else: train_Loss2NN = my_optimizer.minimize( Loss2NN, global_step=global_steps) # 训练上的真解值和训练结果的误差 U_true = u_true(X_it) train_mse_NN = tf.reduce_mean(tf.square(U_true - U_NN)) train_rel_NN = train_mse_NN / tf.reduce_mean(tf.square(U_true)) t0 = time.time() # 空列表, 使用 append() 添加元素 lossIt_all2NN, lossBD_all2NN, loss_all2NN, UDU_NN, train_mse_all2NN, train_rel_all2NN = [], [], [], [], [], [] test_mse_all2NN, test_rel_all2NN = [], [] test_epoch = [] test_batch_size = 1000 test_x_bach = np.reshape( np.linspace(region_l, region_r, num=test_batch_size), [-1, 1]) saveData.save_testData_or_solus2mat(test_x_bach, dataName='testx', outPath=R['FolderName']) # ConfigProto 加上allow_soft_placement=True就可以使用 gpu 了 config = tf.ConfigProto(allow_soft_placement=True) # 创建sess的时候对sess进行参数配置 config.gpu_options.allow_growth = True # True是让TensorFlow在运行过程中动态申请显存,避免过多的显存占用。 config.allow_soft_placement = True # 当指定的设备不存在时,允许选择一个存在的设备运行。比如gpu不存在,自动降到cpu上运行 with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) tmp_lr = learning_rate for i_epoch in range(R['max_epoch'] + 1): x_it_batch = DNN_data.rand_it(batchsize_it, input_dim, region_a=region_l, region_b=region_r) xl_bd_batch, xr_bd_batch = DNN_data.rand_bd_1D(batchsize_bd, input_dim, region_a=region_l, region_b=region_r) tmp_lr = tmp_lr * (1 - lr_decay) if R['activate_penalty2bd_increase'] == 1: if i_epoch < int(R['max_epoch'] / 10): temp_penalty_bd = bd_penalty_init elif i_epoch < int(R['max_epoch'] / 5): temp_penalty_bd = 10 * bd_penalty_init elif i_epoch < int(R['max_epoch'] / 4): temp_penalty_bd = 50 * bd_penalty_init elif i_epoch < int(R['max_epoch'] / 2): temp_penalty_bd = 100 * bd_penalty_init elif i_epoch < int(3 * R['max_epoch'] / 4): temp_penalty_bd = 200 * bd_penalty_init else: temp_penalty_bd = 500 * bd_penalty_init elif R['activate_penalty2bd_increase'] == 2: if i_epoch < int(R['max_epoch'] / 10): temp_penalty_bd = 5 * bd_penalty_init elif i_epoch < int(R['max_epoch'] / 5): temp_penalty_bd = 1 * bd_penalty_init elif i_epoch < int(R['max_epoch'] / 4): temp_penalty_bd = 0.5 * bd_penalty_init elif i_epoch < int(R['max_epoch'] / 2): temp_penalty_bd = 0.1 * bd_penalty_init elif i_epoch < int(3 * R['max_epoch'] / 4): temp_penalty_bd = 0.05 * bd_penalty_init else: temp_penalty_bd = 0.02 * bd_penalty_init else: temp_penalty_bd = bd_penalty_init if R['activate_powSolus_increase'] == 1: if i_epoch < int(R['max_epoch'] / 10): temp_penalty_powU = init_penalty2powU elif i_epoch < int(R['max_epoch'] / 5): temp_penalty_powU = 10 * init_penalty2powU elif i_epoch < int(R['max_epoch'] / 4): temp_penalty_powU = 50 * init_penalty2powU elif i_epoch < int(R['max_epoch'] / 2): temp_penalty_powU = 100 * init_penalty2powU elif i_epoch < int(3 * R['max_epoch'] / 4): temp_penalty_powU = 200 * init_penalty2powU else: temp_penalty_powU = 500 * init_penalty2powU elif R['activate_powSolus_increase'] == 2: if i_epoch < int(R['max_epoch'] / 10): temp_penalty_powU = 5 * init_penalty2powU elif i_epoch < int(R['max_epoch'] / 5): temp_penalty_powU = 1 * init_penalty2powU elif i_epoch < int(R['max_epoch'] / 4): temp_penalty_powU = 0.5 * init_penalty2powU elif i_epoch < int(R['max_epoch'] / 2): temp_penalty_powU = 0.1 * init_penalty2powU elif i_epoch < int(3 * R['max_epoch'] / 4): temp_penalty_powU = 0.05 * init_penalty2powU else: temp_penalty_powU = 0.02 * init_penalty2powU else: temp_penalty_powU = init_penalty2powU p_WB = 0.0 _, loss_it_nn, loss_bd_nn, loss_nn, udu_nn, train_mse_nn, train_rel_nn = sess.run( [ train_Loss2NN, Loss_it2NN, Loss_bd2NN, Loss2NN, UNN_dot_UNN, train_mse_NN, train_rel_NN ], feed_dict={ X_it: x_it_batch, X_left_bd: xl_bd_batch, X_right_bd: xr_bd_batch, in_learning_rate: tmp_lr, bd_penalty: temp_penalty_bd, penalty2powU: temp_penalty_powU }) lossIt_all2NN.append(loss_it_nn) lossBD_all2NN.append(loss_bd_nn) loss_all2NN.append(loss_nn) UDU_NN.append(udu_nn) train_mse_all2NN.append(train_mse_nn) train_rel_all2NN.append(train_rel_nn) if i_epoch % 1000 == 0: run_times = time.time() - t0 DNN_tools.print_and_log_train_one_epoch(i_epoch, run_times, tmp_lr, temp_penalty_bd, temp_penalty_powU, p_WB, loss_it_nn, loss_bd_nn, loss_nn, udu_nn, train_mse_nn, train_rel_nn, log_out=log_fileout_NN) # --------------------------- test network ---------------------------------------------- test_epoch.append(i_epoch / 1000) train_option = False u_true2test, utest_nn, u_nn_normal, u_nn_scale = sess.run( [U_true, U_NN, U_NN_Normal, U_NN_freqs], feed_dict={ X_it: test_x_bach, train_opt: train_option }) test_mse2nn = np.mean(np.square(u_true2test - utest_nn)) test_mse_all2NN.append(test_mse2nn) test_rel2nn = test_mse2nn / np.mean(np.square(u_true2test)) test_rel_all2NN.append(test_rel2nn) DNN_tools.print_and_log_test_one_epoch(test_mse2nn, test_rel2nn, log_out=log_fileout_NN) # ----------------------- save training results to mat files, then plot them --------------------------------- saveData.save_trainLoss2mat_1actFunc(lossIt_all2NN, lossBD_all2NN, loss_all2NN, actName=act_func1, outPath=R['FolderName']) saveData.save_train_MSE_REL2mat(train_mse_all2NN, train_rel_all2NN, actName=act_func1, outPath=R['FolderName']) plotData.plotTrain_loss_1act_func(lossIt_all2NN, lossType='loss_it', seedNo=R['seed'], outPath=R['FolderName']) plotData.plotTrain_loss_1act_func(lossBD_all2NN, lossType='loss_bd', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) plotData.plotTrain_loss_1act_func(loss_all2NN, lossType='loss', seedNo=R['seed'], outPath=R['FolderName']) plotData.plotTrain_MSE_REL_1act_func(train_mse_all2NN, train_rel_all2NN, actName=act_func2, seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) # ---------------------- save testing results to mat files, then plot them -------------------------------- saveData.save_testData_or_solus2mat(u_true2test, dataName='Utrue', outPath=R['FolderName']) saveData.save_testData_or_solus2mat(utest_nn, dataName=act_func1, outPath=R['FolderName']) saveData.save_testData_or_solus2mat(u_nn_normal, dataName='normal', outPath=R['FolderName']) saveData.save_testData_or_solus2mat(u_nn_scale, dataName='scale', outPath=R['FolderName']) saveData.save_testMSE_REL2mat(test_mse_all2NN, test_rel_all2NN, actName=act_func2, outPath=R['FolderName']) plotData.plotTest_MSE_REL(test_mse_all2NN, test_rel_all2NN, test_epoch, actName=act_func2, seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True)
def dictionary_out2file(R_dic, log_fileout, actName2normal=None, actName2scale=None): DNN_tools.log_string('PDE type for problem: %s\n' % (R_dic['PDE_type']), log_fileout) DNN_tools.log_string( 'Equation name for problem: %s\n' % (R_dic['equa_name']), log_fileout) DNN_tools.log_string( 'The order to p-laplace: %s\n' % (R_dic['order2laplace']), log_fileout) DNN_tools.log_string('The epsilon to p-laplace: %s\n' % (R_dic['epsilon']), log_fileout) DNN_tools.log_string( 'Network model of solving normal-part: %s\n' % str(R_dic['model2normal']), log_fileout) DNN_tools.log_string( 'Network model of solving scale-part: %s\n' % str(R_dic['model2scale']), log_fileout) DNN_tools.log_string( 'Activate function for normal-part network: %s\n' % str(actName2normal), log_fileout) DNN_tools.log_string( 'Activate function for scale-part network: %s\n' % str(actName2scale), log_fileout) DNN_tools.log_string( 'hidden layer to normal:%s\n' % str(R_dic['hidden2normal']), log_fileout) DNN_tools.log_string( 'hidden layer to scale :%s\n' % str(R_dic['hidden2scale']), log_fileout) DNN_tools.log_string( 'The frequency to scale-part network: %s\n' % (R_dic['freqs']), log_fileout) if (R_dic['optimizer_name']).title() == 'Adam': DNN_tools.log_string('optimizer:%s\n' % str(R_dic['optimizer_name']), log_fileout) else: DNN_tools.log_string( 'optimizer:%s with momentum=%f\n' % (R_dic['optimizer_name'], R_dic['momentum']), log_fileout) if R_dic['variational_loss'] == 1 or R_dic['variational_loss'] == 2: DNN_tools.log_string( 'Loss function: variational loss ' + str(R_dic['variational_loss']) + '\n', log_fileout) else: DNN_tools.log_string('Loss function: original function loss\n', log_fileout) if R_dic['variational_loss'] == 1: if R_dic['wavelet'] == 1: DNN_tools.log_string( 'Option of loss for coarse and fine is: L2 wavelet. \n', log_fileout) elif R_dic['wavelet'] == 2: DNN_tools.log_string( 'Option of loss for coarse and fine is: Energy minimization. \n', log_fileout) else: DNN_tools.log_string( 'Option of loss for coarse and fine is: L2 wavelet + Energy minimization. \n', log_fileout) if R_dic['variational_loss'] == 2: if R_dic['wavelet'] == 1: DNN_tools.log_string( 'Option of loss for coarse and fine is: L2 wavelet. \n', log_fileout) if R_dic['activate_stop'] != 0: DNN_tools.log_string( 'activate the stop_step and given_step= %s\n' % str(R_dic['max_epoch']), log_fileout) else: DNN_tools.log_string( 'no activate the stop_step and given_step = default: %s\n' % str(R_dic['max_epoch']), log_fileout) DNN_tools.log_string( 'Init learning rate: %s\n' % str(R_dic['learning_rate']), log_fileout) DNN_tools.log_string( 'Decay to learning rate: %s\n' % str(R_dic['learning_rate_decay']), log_fileout) DNN_tools.log_string( 'Batch-size 2 interior: %s\n' % str(R_dic['batch_size2interior']), log_fileout) DNN_tools.log_string( 'Batch-size 2 boundary: %s\n' % str(R_dic['batch_size2boundary']), log_fileout) DNN_tools.log_string( 'Initial boundary penalty: %s\n' % str(R_dic['init_boundary_penalty']), log_fileout) if R_dic['activate_penalty2bd_increase'] == 1: DNN_tools.log_string( 'The penalty of boundary will increase with training going on.\n', log_fileout) elif R_dic['activate_penalty2bd_increase'] == 2: DNN_tools.log_string( 'The penalty of boundary will decrease with training going on.\n', log_fileout) else: DNN_tools.log_string( 'The penalty of boundary will keep unchanged with training going on.\n', log_fileout)
def dictionary_out2file(R_dic, log_fileout): DNN_tools.log_string( 'Equation name for problem: %s\n' % (R_dic['eqs_name']), log_fileout) DNN_tools.log_string( 'Network model for SIR: %s\n' % str(R_dic['model2sir']), log_fileout) DNN_tools.log_string( 'Network model for parameters: %s\n' % str(R_dic['model2paras']), log_fileout) DNN_tools.log_string( 'activate function for SIR : %s\n' % str(R_dic['act2sir']), log_fileout) DNN_tools.log_string( 'activate function for parameters : %s\n' % str(R_dic['act2paras']), log_fileout) DNN_tools.log_string( 'hidden layers for SIR: %s\n' % str(R_dic['hidden2SIR']), log_fileout) DNN_tools.log_string( 'hidden layers for parameters: %s\n' % str(R_dic['hidden2para']), log_fileout) DNN_tools.log_string( 'Init learning rate: %s\n' % str(R_dic['learning_rate']), log_fileout) DNN_tools.log_string( 'Decay to learning rate: %s\n' % str(R_dic['lr_decay']), log_fileout) DNN_tools.log_string( 'The type for Loss function: %s\n' % str(R_dic['loss_function']), log_fileout) if (R_dic['optimizer_name']).title() == 'Adam': DNN_tools.log_string('optimizer:%s\n' % str(R_dic['optimizer_name']), log_fileout) else: DNN_tools.log_string( 'optimizer:%s with momentum=%f\n' % (R_dic['optimizer_name'], R_dic['momentum']), log_fileout) if R_dic['activate_stop'] != 0: DNN_tools.log_string( 'activate the stop_step and given_step= %s\n' % str(R_dic['max_epoch']), log_fileout) else: DNN_tools.log_string( 'no activate the stop_step and given_step = default: %s\n' % str(R_dic['max_epoch']), log_fileout) DNN_tools.log_string( 'Initial penalty for difference of predict and true: %s\n' % str(R_dic['init_penalty2predict_true']), log_fileout) DNN_tools.log_string( 'The model of regular weights and biases: %s\n' % str(R_dic['regular_weight_model']), log_fileout) DNN_tools.log_string( 'Regularization parameter for weights and biases: %s\n' % str(R_dic['regular_weight']), log_fileout) DNN_tools.log_string( 'Size 2 training set: %s\n' % str(R_dic['size2train']), log_fileout) DNN_tools.log_string( 'Batch-size 2 training: %s\n' % str(R_dic['batch_size2train']), log_fileout) DNN_tools.log_string( 'Batch-size 2 testing: %s\n' % str(R_dic['batch_size2test']), log_fileout)
def solve_Integral_Equa(R): log_out_path = R['FolderName'] # 将路径从字典 R 中提取出来 if not os.path.exists(log_out_path): # 判断路径是否已经存在 os.mkdir(log_out_path) # 无 log_out_path 路径,创建一个 log_out_path 路径 outFile2para_name = '%s_%s.txt' % ('para2', 'beta') logfile_name = '%s%s.txt' % ('log2', R['activate_func']) log_fileout = open(os.path.join(log_out_path, logfile_name), 'w') # 在这个路径下创建并打开一个可写的 log_train.txt文件 para_outFile = open(os.path.join(log_out_path, outFile2para_name), 'w') # 在这个路径下创建并打开一个可写的 para_outFile.txt文件 DNN_Log_Print.dictionary_out2file(R, log_fileout) # 方程问题需要的设置 batchsize2bS = R['batch_size2bS'] batchsize2b = R['batch_size2y_b'] batchsize2integral = R['batch_size2integral'] wb_regular = R['regular_weight_biases'] if R['training_strategy'] == 'Alter_train': init_lr2b = R['init_learning_rate2b'] init_lr2S = R['init_learning_rate2S'] lr_decay2b = R['learning_rate_decay2b'] lr_decay2S = R['learning_rate_decay2S'] else: lr_decay = R['learning_rate_decay'] init_lr = R['init_learning_rate'] hidden_layers = R['hidden_layers'] act_func = R['activate_func'] # ------- set the problem --------- data_indim = R['input_dim'] para_dim = R['estimate_para_dim'] # bNN是否和参数 beta 显式相关,即参数 beta 作为bNN的一个输入。是:数据维数+参数维数;否:数据维数 if R['bnn2beta'] == 'explicitly_related': bNN_inDim = data_indim + para_dim else: bNN_inDim = data_indim # 初始化权重和和偏置的模式。bNN是一个整体的网络表示,还是分为几个独立的网格表示 b 的每一个分量 bi. b=(b0,b1,b2,......) if R['sub_networks'] == 'subDNNs': flag_b0 = 'bnn0' flag_b1 = 'bnn1' bNN_outDim = 1 if R['name2network'] == 'DNN_Cos_C_Sin_Base': W2b0, B2b0 = DNN_base.initialize_NN_random_normal2_CS( bNN_inDim, bNN_outDim, hidden_layers, flag_b0, unit_const_Init1layer=False) W2b1, B2b1 = DNN_base.initialize_NN_random_normal2_CS( bNN_inDim, bNN_outDim, hidden_layers, flag_b1, unit_const_Init1layer=False) else: W2b0, B2b0 = DNN_base.initialize_NN_random_normal2( bNN_inDim, bNN_outDim, hidden_layers, flag_b0, unit_const_Init1layer=False) W2b1, B2b1 = DNN_base.initialize_NN_random_normal2( bNN_inDim, bNN_outDim, hidden_layers, flag_b0, unit_const_Init1layer=False) else: bNN_outDim = para_dim flag_b = 'bnn' if R['name2network'] == 'DNN_Cos_C_Sin_Base': W2b, B2b = DNN_base.initialize_NN_random_normal2_CS( bNN_inDim, bNN_outDim, hidden_layers, flag_b, unit_const_Init1layer=False) else: W2b, B2b = DNN_base.initialize_NN_random_normal2( bNN_inDim, bNN_outDim, hidden_layers, flag_b, unit_const_Init1layer=False) global_steps = tf.Variable(0, trainable=False) with tf.device('/gpu:%s' % (R['gpuNo'])): with tf.variable_scope('vscope', reuse=tf.AUTO_REUSE): X = tf.placeholder(tf.float32, name='X_recv', shape=[batchsize2bS, data_indim]) Y = tf.placeholder(tf.float32, name='Y_recv', shape=[batchsize2bS, data_indim]) R2XY = tf.placeholder(tf.float32, name='R2XY_recv', shape=[batchsize2bS, data_indim]) tfOne = tf.placeholder(tf.float32, shape=[batchsize2bS, data_indim], name='tfOne') y = tf.placeholder(tf.float32, name='y_recv', shape=[batchsize2b, data_indim]) t_inte = tf.placeholder(tf.float32, name='t_integral', shape=[batchsize2integral, data_indim]) beta = tf.Variable(tf.random.uniform([1, para_dim]), dtype='float32', name='beta') # beta = tf.Variable([[0.25, -0.5]], dtype='float32', name='beta') # beta = tf.constant([[0.25, -0.5]], dtype=tf.float32, name='beta') inline_lr = tf.placeholder_with_default( input=1e-2, shape=[], name='inline_learning_rate') inline_lr2b = tf.placeholder_with_default( input=1e-2, shape=[], name='inline_learning_rate2b') inline_lr2S = tf.placeholder_with_default( input=1e-2, shape=[], name='inline_learning_rate2S') if R['bnn2beta'] == 'explicitly_related': Repeat_beta2t = tf.tile(beta, [batchsize2integral, 1]) tInte_beta = tf.concat([t_inte, Repeat_beta2t], axis=-1) Repeat_beta2y = tf.tile(beta, [batchsize2b, 1]) y_beta = tf.concat([y, Repeat_beta2y], axis=-1) Repeat_beta2Y = tf.tile(beta, [batchsize2bS, 1]) Y_beta = tf.concat([Y, Repeat_beta2Y], axis=-1) else: tInte_beta = t_inte y_beta = y Y_beta = Y if R['sub_networks'] == 'subDNNs': if R['name2network'] == str('DNN'): b0_NN2t = DNN_base.PDE_DNN(tInte_beta, W2b0, B2b0, hidden_layers, activate_name=act_func) b1_NN2t = DNN_base.PDE_DNN(tInte_beta, W2b1, B2b1, hidden_layers, activate_name=act_func) b0_NN2y = DNN_base.PDE_DNN(y_beta, W2b0, B2b0, hidden_layers, activate_name=act_func) b1_NN2y = DNN_base.PDE_DNN(y_beta, W2b1, B2b1, hidden_layers, activate_name=act_func) b0_NN2Y = DNN_base.PDE_DNN(Y_beta, W2b0, B2b0, hidden_layers, activate_name=act_func) b1_NN2Y = DNN_base.PDE_DNN(Y_beta, W2b1, B2b1, hidden_layers, activate_name=act_func) elif R['name2network'] == 'DNN_Cos_C_Sin_Base': freq = R['freqs'] b0_NN2t = DNN_base.PDE_DNN_Cos_C_Sin_Base( tInte_beta, W2b0, B2b0, hidden_layers, freq, activate_name=act_func) b1_NN2t = DNN_base.PDE_DNN_Cos_C_Sin_Base( tInte_beta, W2b1, B2b1, hidden_layers, freq, activate_name=act_func) b0_NN2y = DNN_base.PDE_DNN_Cos_C_Sin_Base( y_beta, W2b0, B2b0, hidden_layers, freq, activate_name=act_func) b1_NN2y = DNN_base.PDE_DNN_Cos_C_Sin_Base( y_beta, W2b1, B2b1, hidden_layers, freq, activate_name=act_func) b0_NN2Y = DNN_base.PDE_DNN_Cos_C_Sin_Base( Y_beta, W2b0, B2b0, hidden_layers, freq, activate_name=act_func) b1_NN2Y = DNN_base.PDE_DNN_Cos_C_Sin_Base( Y_beta, W2b1, B2b1, hidden_layers, freq, activate_name=act_func) b_NN2t = tf.concat([b0_NN2t, b1_NN2t], axis=-1) b_NN2y = tf.concat([b0_NN2y, b1_NN2y], axis=-1) b_NN2Y = tf.concat([b0_NN2Y, b1_NN2Y], axis=-1) else: if R['name2network'] == str('DNN'): b_NN2t = DNN_base.PDE_DNN(tInte_beta, W2b, B2b, hidden_layers, activate_name=act_func) b_NN2y = DNN_base.PDE_DNN(y_beta, W2b, B2b, hidden_layers, activate_name=act_func) b_NN2Y = DNN_base.PDE_DNN(Y_beta, W2b, B2b, hidden_layers, activate_name=act_func) elif R['name2network'] == 'DNN_Cos_C_Sin_Base': freq = R['freqs'] b_NN2t = DNN_base.PDE_DNN_Cos_C_Sin_Base( tInte_beta, W2b, B2b, hidden_layers, freq, activate_name=act_func) b_NN2y = DNN_base.PDE_DNN_Cos_C_Sin_Base( y_beta, W2b, B2b, hidden_layers, freq, activate_name=act_func) b_NN2Y = DNN_base.PDE_DNN_Cos_C_Sin_Base( Y_beta, W2b, B2b, hidden_layers, freq, activate_name=act_func) # 如下代码说明中 K 代表y的数目, N 代表 X 和 Y 的数目,M 代表 t 的数目 # 求 b 的代码,先处理等号左边,再处理等号右边 OneX = tf.concat([tfOne, X], axis=-1) # N 行 (1+dim) 列,N代表X数据数目 betaT = tf.transpose(beta, perm=[1, 0]) # (1+dim) 行 1 列 oneX_betaT = tf.matmul( OneX, betaT) # N 行 1 列。每个 Xi 都会对应 beta。 beta 是 (1+dim) 行 1 列的 tInte_beraXT = tf.transpose(t_inte, perm=[ 1, 0 ]) - oneX_betaT # N 行 M 列,t_inte 是 M 行 dim 列的 # b方程左边系数分母,关于t求和平均代替积分 fYX_t = fYX(z=tInte_beraXT, func_name='gaussian') # fY|X在t处的取值 # N 行 M 列 phi_1 = tf.transpose(1 - pi_star(t=t_inte), perm=[1, 0]) # M 行 dim 列转置为 dim 行 M 列 fYXt_1phi = tf.multiply(fYX_t, phi_1) # N 行 M 列 fYXt_1phi_intergal = tf.reduce_mean(fYXt_1phi, axis=-1) fYXt_1phi_intergal = tf.reshape(fYXt_1phi_intergal, shape=[-1, 1]) # N 行 dim 列 # b方程左边系数分子,关于t求和平均代替积分 dbeta2fYX_t = fYX_t * tInte_beraXT # N 行 M 列 expand_dbeta2fYX_t = tf.expand_dims(dbeta2fYX_t, axis=1) # N 页 1 行 M 列 tilde_Edbeta2fYX_t = tf.tile( expand_dbeta2fYX_t, [1, data_indim + 1, 1]) # N 页 (1+dim) 行 M 列 dfYX_beta_t = tf.multiply(tilde_Edbeta2fYX_t, tf.expand_dims( OneX, axis=-1)) # N 页 (1+dim) 行 M 列 phi_t = tf.transpose(pi_star(t=t_inte), perm=[1, 0]) # M 行 1 列转置为 1 行 M 列 dfYX_beta_phi_t = tf.multiply(dfYX_beta_t, phi_t) # N 页 (1+dim) 行 M 列 dfYX_beta_integral = tf.reduce_mean(dfYX_beta_phi_t, axis=-1) # N 行 (1+dim) 列 # b方程左边的系数 ceof2left = dfYX_beta_integral / fYXt_1phi_intergal # N 行 (1+dim) 列 # b方程左边积分系数的匹配项 yaux_beraXT = tf.transpose( y, perm=[1, 0]) - oneX_betaT # N 行 K 列, y 是 K 行 data_dim 列 fYX_y = fYX(z=yaux_beraXT, func_name='gaussian') # fY|X在y处的取值, N 行 K 列 expand_fYX_y = tf.expand_dims(fYX_y, axis=1) # N 页 1 行 K 列 bleft_fYX_y = tf.multiply(tf.expand_dims(ceof2left, axis=-1), expand_fYX_y) # N 页 (1+dim) 行 K 列 # b方程左边的第一个关于beta的导数项, 即dfYX2beta(y,Xi,beta) dbeta2fYX_y = fYX_y * yaux_beraXT # N 行 K 列 expand_dbeta2fYX_y = tf.expand_dims(dbeta2fYX_y, axis=1) # N 页 1 行 K 列 dfYX_beta_y = tf.multiply(expand_dbeta2fYX_y, tf.expand_dims( OneX, axis=-1)) # N 页 (1+dim) 行 K 列 # b方程左边的组合结果 sum2bleft = bleft_fYX_y + dfYX_beta_y # N 页 (1+dim) 行 K 列 bleft = tf.reduce_mean(sum2bleft, axis=0) # 1+dim 行 K 列 # b 方程的右边。右边的第一项,如下两行计算 trans_b_NN2y = tf.transpose( b_NN2y, perm=[1, 0]) # K 行 2 列转置为 2 行 K 列,然后扩为 1 X 2 X K 的 by_fYX_y = tf.multiply(tf.expand_dims(trans_b_NN2y, axis=0), tf.expand_dims(fYX_y, axis=1)) # N 页 1+dim 行 K 列 # b方程右边的系数的分子 expand_fYX_t = tf.tile( tf.expand_dims(fYX_t, axis=1), [1, 1 + data_indim, 1]) # N 页 (1+data_indim) 行 M 列 bt_fYXt = tf.multiply(tf.transpose(b_NN2t, perm=[1, 0]), expand_fYX_t) # N 页 (1+data_indim) 行 M 列 bt_fYXt_phi = tf.multiply(bt_fYXt, phi_t) # N 页 (1+data_indim) 行 M 列 bt_fYXt_phi_integral = tf.reduce_mean( bt_fYXt_phi, axis=-1) # N 行 (1+data_indim) 列 # b方程右边的系数。分母为共用b方程左边的分母 ceof2fight = bt_fYXt_phi_integral / fYXt_1phi_intergal # N 行 (1+data_indim) 列 # b方程系数与匹配项的线性积 expand_fYX_y_right = tf.expand_dims(fYX_y, axis=1) # N 页 1 行 K 列 bright_fYX_y = tf.multiply( tf.expand_dims(ceof2fight, axis=-1), expand_fYX_y_right) # N 页 (1+data_indim) 行 K 列 # b方程右边的组合结果 sum2right = by_fYX_y + bright_fYX_y # N 页 (1+dim) 行 K 列 bright = tf.reduce_mean(sum2right, axis=0) # 1+dim 行 K 列 # b方程左边和右边要相等,使用差的平方来估计 loss2b = tf.reduce_mean( tf.reduce_mean(tf.square(bleft - bright), axis=-1)) # 求 Seff 的代码 Y_beraXT = Y - oneX_betaT # N 行 dim 列, Y 和 oneX_betaT 都是 N 行 dim 列的 fYX_Y = fYX(z=Y_beraXT, func_name='gaussian') # fY|X在t处的取值 # N 行 dim 列 ceof2R = (R2XY / fYX_Y) # N 行 dim 列, R2XY 是 N 行 dim 列的 dbeta2fYX_Y = tf.multiply(fYX_Y, Y_beraXT) # N 行 dim 列 dfYX_beta_Y = tf.multiply( dbeta2fYX_Y, OneX) # fY|X(t)对beta的导数,N行(1+dim)列,OneX 是 N 行 (1+dim) 列 Sbeta_star1 = tf.multiply(ceof2R, dfYX_beta_Y) # N 行 (1+dim) Seff_temp = tf.reshape(tf.reduce_mean(fYXt_1phi_intergal, axis=-1), shape=[-1, 1]) # N 行 dim 列 ceof21R = (1 - R2XY) / Seff_temp # N 行 dim 列 Sbeta_star2 = tf.multiply(ceof21R, dfYX_beta_integral) # N 行 (1+dim) Sbeta_star = Sbeta_star1 - Sbeta_star2 # N 行 (1+dim) Seff2 = tf.multiply(R2XY, b_NN2Y) # N 行 (1+dim) Seff3 = tf.multiply(1 - R2XY, bt_fYXt_phi_integral / fYXt_1phi_intergal) # N 行 (1+dim) squareSeff = tf.square(Sbeta_star - Seff2 + Seff3) # N 行 (1+dim) loss2Seff = tf.reduce_mean(tf.reduce_mean(squareSeff, axis=0)) if R['sub_networks'] == 'subDNNs': if R['regular_weight_model'] == 'L1': regular_WB2b0 = DNN_base.regular_weights_biases_L1( W2b0, B2b0) regular_WB2b1 = DNN_base.regular_weights_biases_L1( W2b1, B2b1) elif R['regular_weight_model'] == 'L2': regular_WB2b0 = DNN_base.regular_weights_biases_L2( W2b0, B2b0) regular_WB2b1 = DNN_base.regular_weights_biases_L2( W2b1, B2b1) else: regular_WB2b0 = tf.constant(0.0) regular_WB2b1 = tf.constant(0.0) regular_WB2b = regular_WB2b0 + regular_WB2b1 else: if R['regular_weight_model'] == 'L1': regular_WB2b = DNN_base.regular_weights_biases_L1(W2b, B2b) elif R['regular_weight_model'] == 'L2': regular_WB2b = DNN_base.regular_weights_biases_L2(W2b, B2b) else: regular_WB2b = tf.constant(0.0) penalty_WB = wb_regular * regular_WB2b if R['training_strategy'] == 'Alter_train': lossB = loss2b + penalty_WB lossSeff = loss2Seff + penalty_WB if R['sub_networks'] == 'subDNNs': WB = [W2b0, B2b0, W2b1, B2b1] else: WB = [W2b, B2b] my_optimizer2b = tf.train.AdamOptimizer(inline_lr2b) my_optimizer2Seff = tf.train.AdamOptimizer(inline_lr2S) train_loss2b = my_optimizer2b.minimize( lossB, global_step=global_steps, var_list=WB) train_loss2Seff = my_optimizer2Seff.minimize( lossSeff, global_step=global_steps, var_list=beta) else: loss = 5 * loss2b + 10 * loss2Seff + penalty_WB # 要优化的loss function my_optimizer = tf.train.AdamOptimizer(inline_lr) if R['train_group'] == 0: train_my_loss = my_optimizer.minimize( loss, global_step=global_steps) if R['train_group'] == 1: if R['sub_networks'] == 'subDNNs': WB = [W2b0, B2b0, W2b1, B2b1] else: WB = [W2b, B2b] train_op1 = my_optimizer.minimize(loss2b, global_step=global_steps, var_list=WB) train_op2 = my_optimizer.minimize(loss2Seff, global_step=global_steps, var_list=beta) train_op3 = my_optimizer.minimize(loss, global_step=global_steps) train_my_loss = tf.group(train_op1, train_op2, train_op3) elif R['train_group'] == 2: if R['sub_networks'] == 'subDNNs': WB = [W2b0, B2b0, W2b1, B2b1] else: WB = [W2b, B2b] train_op1 = my_optimizer.minimize(loss2b, global_step=global_steps, var_list=WB) train_op2 = my_optimizer.minimize(loss2Seff, global_step=global_steps, var_list=beta) train_my_loss = tf.group(train_op1, train_op2) t0 = time.time() loss_b_all, loss_seff_all, loss_all = [], [], [] # 空列表, 使用 append() 添加元素 # ConfigProto 加上allow_soft_placement=True就可以使用 gpu 了 config = tf.ConfigProto(allow_soft_placement=True) # 创建sess的时候对sess进行参数配置 config.gpu_options.allow_growth = True # True是让TensorFlow在运行过程中动态申请显存,避免过多的显存占用。 config.allow_soft_placement = True # 当指定的设备不存在时,允许选择一个存在的设备运行。比如gpu不存在,自动降到cpu上运行 X_batch = DNN_data.randnormal_mu_sigma(size=batchsize2bS, mu=0.5, sigma=0.5) Y_init = 0.25 - 0.5 * X_batch + np.reshape( np.random.randn(batchsize2bS, 1), (-1, 1)) # y_batch = DNN_data.randnormal_mu_sigma(size=batchsize2aux, mu=0.0, sigma=1.5) # x_aux_batch = DNN_data.randnormal_mu_sigma(size=batchsize2aux, mu=0.5, sigma=0.5) # y_batch = 0.25 - 0.5 * x_aux_batch + np.reshape(np.random.randn(batchsize2aux, 1), (-1, 1)) relate2XY = np.reshape(np.random.randint(0, 2, batchsize2bS), (-1, 1)) Y_batch = np.multiply(Y_init, relate2XY) one2train = np.ones((batchsize2bS, 1)) y_batch = DNN_data.rand_it(batch_size=batchsize2b, variable_dim=data_indim, region_a=-2, region_b=2) t_batch = DNN_data.rand_it(batch_size=batchsize2integral, variable_dim=data_indim, region_a=-2, region_b=2) with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) if R['training_strategy'] == 'Alter_train': tmp_lr2b = init_lr2b tmp_lr2S = init_lr2S for i_epoch in range(R['max_epoch'] + 1): if i_epoch % 10 == 0 and i_epoch != 0: # 10, 20, 30, 40,..... tmp_lr2S = tmp_lr2S * (1 - lr_decay2S) _S, loss2seff_tmp, loss2b_tmp, p_WB, beta_temp = sess.run( [train_loss2Seff, loss2Seff, loss2b, penalty_WB, beta], feed_dict={ X: X_batch, Y: Y_batch, R2XY: relate2XY, y: y_batch, tfOne: one2train, t_inte: t_batch, inline_lr2S: tmp_lr2S }) else: # 0,1,2,3,4,5,6,7,8,9, 11,12,13,....,19, 21,22,.... tmp_lr2b = tmp_lr2b * (1 - lr_decay2b) _b, loss2b_tmp, loss2seff_tmp, p_WB, beta_temp = sess.run( [train_loss2b, loss2b, loss2Seff, penalty_WB, beta], feed_dict={ X: X_batch, Y: Y_batch, R2XY: relate2XY, y: y_batch, tfOne: one2train, t_inte: t_batch, inline_lr2b: tmp_lr2b }) loss_seff_all.append(loss2seff_tmp) loss_b_all.append(loss2b_tmp) if (i_epoch % 10) == 0: DNN_tools.log_string( '*************** epoch: %d*10 ****************' % int(i_epoch / 10), log_fileout) DNN_tools.log_string( 'lossb for training: %.10f\n' % loss2b_tmp, log_fileout) DNN_tools.log_string( 'lossS for training: %.10f\n' % loss2seff_tmp, log_fileout) DNN_tools.log_string( 'Penalty2Weights_Bias for training: %.10f\n' % p_WB, log_fileout) if (i_epoch % 100) == 0: print( '**************** epoch: %d*100 *******************' % int(i_epoch / 100)) print('beta:[%f %f]' % (beta_temp[0, 0], beta_temp[0, 1])) print('\n') DNN_tools.log_string( '*************** epoch: %d*100 *****************' % int(i_epoch / 100), para_outFile) DNN_tools.log_string( 'beta:[%f, %f]' % (beta_temp[0, 0], beta_temp[0, 1]), para_outFile) DNN_tools.log_string('\n', para_outFile) saveData.save_2trainLosses2mat(loss_b_all, loss_seff_all, data1Name='lossb', data2Name='lossSeff', actName=act_func, outPath=R['FolderName']) plotData.plotTrain_loss_1act_func(loss_b_all, lossType='loss_b', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) plotData.plotTrain_loss_1act_func(loss_seff_all, lossType='loss_s', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) else: tmp_lr = init_lr for i_epoch in range(R['max_epoch'] + 1): tmp_lr = tmp_lr * (1 - lr_decay) _, loss2b_tmp, loss2seff_tmp, loss_tmp, p_WB, beta_temp = sess.run( [train_my_loss, loss2b, loss2Seff, loss, penalty_WB, beta], feed_dict={ X: X_batch, Y: Y_batch, R2XY: relate2XY, y: y_batch, tfOne: one2train, t_inte: t_batch, inline_lr: tmp_lr }) loss_b_all.append(loss2b_tmp) loss_seff_all.append(loss2seff_tmp) loss_all.append(loss_tmp) if (i_epoch % 10) == 0: DNN_tools.log_string( '*************** epoch: %d*10 ****************' % int(i_epoch / 10), log_fileout) DNN_tools.log_string( 'lossb for training: %.10f\n' % loss2b_tmp, log_fileout) DNN_tools.log_string( 'lossS for training: %.10f\n' % loss2seff_tmp, log_fileout) DNN_tools.log_string( 'loss for training: %.10f\n' % loss_tmp, log_fileout) DNN_tools.log_string( 'Penalty2Weights_Bias for training: %.10f\n' % p_WB, log_fileout) if (i_epoch % 100) == 0: print( '**************** epoch: %d*100 *******************' % int(i_epoch / 100)) print('beta:[%f %f]' % (beta_temp[0, 0], beta_temp[0, 1])) print('\n') DNN_tools.log_string( '*************** epoch: %d*100 *****************' % int(i_epoch / 100), para_outFile) DNN_tools.log_string( 'beta:[%f, %f]' % (beta_temp[0, 0], beta_temp[0, 1]), para_outFile) DNN_tools.log_string('\n', para_outFile) saveData.save_3trainLosses2mat(loss_b_all, loss_seff_all, loss_all, data1Name='lossb', data2Name='lossSeff', data3Name='lossAll', actName=act_func, outPath=R['FolderName']) plotData.plotTrain_loss_1act_func(loss_b_all, lossType='loss_b', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) plotData.plotTrain_loss_1act_func(loss_seff_all, lossType='loss_s', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) plotData.plotTrain_loss_1act_func(loss_all, lossType='loss_all', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True)
def plot_3solutions2test(exact_solu2test, s2ReLU_solu2test, sReLU_solu2test, ReLU_solu2test, coord_points2test=None, batch_size2test=1000, seedNo=1000, outPath=None, subfig_type=1): # 嵌入绘制局部放大图的坐标系 if subfig_type == 1: subgfig = plt.figure(figsize=(10, 8), dpi=98) ax = plt.gca() # fig, ax = plt.subplots(a,b)用来控制子图个数:a为行数,b为列数。 ax.plot(coord_points2test, exact_solu2test, 'b-.', label='exact') ax.plot(coord_points2test, s2ReLU_solu2test, 'g:', label='s2ReLU') ax.plot(coord_points2test, sReLU_solu2test, 'm--', label='sReLU') ax.plot(coord_points2test, ReLU_solu2test, 'c-', label='ReLU') ax.legend(loc='right', bbox_to_anchor=(0.85, 1.03), ncol=4, fontsize=12) ax.set_xlabel('epoch', fontsize=14) axins = inset_axes(ax, width="50%", height="40%", loc=8, bbox_to_anchor=(0.2, 0.2, 0.5, 0.5), bbox_transform=ax.transAxes) # 在子坐标系中绘制原始数据 axins.plot(coord_points2test, exact_solu2test, color='b', linestyle='-.') axins.plot(coord_points2test, s2ReLU_solu2test, color='g', linestyle=':') axins.plot(coord_points2test, sReLU_solu2test, color='m', linestyle='--') axins.plot(coord_points2test, ReLU_solu2test, color='c', linestyle='-') axins.set_xticks([]) axins.set_yticks([]) # 设置放大区间 zone_left = int(0.4 * batch_size2test) zone_right = int(0.4 * batch_size2test) + 150 # 坐标轴的扩展比例(根据实际数据调整) x_ratio = 0.075 # x轴显示范围的扩展比例 y_ratio = 0.04 # y轴显示范围的扩展比例 # X轴的显示范围 xlim0 = coord_points2test[zone_left] - (coord_points2test[zone_right] - coord_points2test[zone_left]) * x_ratio xlim1 = coord_points2test[zone_right] + (coord_points2test[zone_right] - coord_points2test[zone_left]) * x_ratio # Y轴的显示范围 y = np.hstack((exact_solu2test[zone_left:zone_right], s2ReLU_solu2test[zone_left:zone_right])) ylim0 = np.min(y) - (np.max(y) - np.min(y)) * y_ratio ylim1 = np.max(y) + (np.max(y) - np.min(y)) * y_ratio # 调整子坐标系的显示范围 axins.set_xlim(xlim0, xlim1) axins.set_ylim(ylim0, ylim1) # 建立父坐标系与子坐标系的连接线 # loc1 loc2: 坐标系的四个角 # 1 (右上) 2 (左上) 3(左下) 4(右下) mark_inset(ax, axins, loc1=3, loc2=1, fc="none", ec='k', lw=1) fntmp = '%s/%ssolu2test' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0) elif subfig_type == 2: plt.figure(figsize=(16, 10), dpi=98) ax = plt.gca() p1 = plt.subplot(121) # 1行2列,第一个图 p2 = plt.subplot(122) # 1行2列,第二个图 p1.plot(coord_points2test, exact_solu2test, color='b', linestyle='-.', label='true') p1.plot(coord_points2test, s2ReLU_solu2test, color='g', linestyle=':', label='predict') ax.legend(fontsize=10) p2.plot(coord_points2test, exact_solu2test, color='b', linestyle='-.', label='true') p2.plot(coord_points2test, s2ReLU_solu2test, color='g', linestyle=':', label='predict') p2.axis([0.35, 0.65, 0.2, 0.27]) # plot the box of tx0 = 0.35 tx1 = 0.65 ty0 = 0.2 ty1 = 0.27 sx = [tx0, tx1, tx1, tx0, tx0] sy = [ty0, ty0, ty1, ty1, ty0] p1.plot(sx, sy, "purple") # plot patch lines xy = (0.64, 0.265) xy2 = (0.36, 0.265) con = ConnectionPatch(xyA=xy2, xyB=xy, coordsA="data", coordsB="data", axesA=p2, axesB=p1) p2.add_artist(con) xy = (0.64, 0.21) xy2 = (0.36, 0.205) con = ConnectionPatch(xyA=xy2, xyB=xy, coordsA="data", coordsB="data", axesA=p2, axesB=p1) p2.add_artist(con) fntmp = '%s/%ssolu2test' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0) else: # fig11 = plt.figure(figsize=(10, 8)) fig11 = plt.figure(figsize=(9, 6.5)) ax = plt.gca() ax.plot(coord_points2test, exact_solu2test, 'b-.', label='exact') ax.plot(coord_points2test, s2ReLU_solu2test, 'g:', label='s2ReLU') ax.plot(coord_points2test, sReLU_solu2test, 'm--', label='sReLU') ax.plot(coord_points2test, ReLU_solu2test, 'c-', label='ReLU') # box = ax.get_position() # ax.set_position([box.x0, box.y0, box.width, box.height * 0.8]) ax.legend(loc='right', bbox_to_anchor=(0.9, 1.05), ncol=4, fontsize=12) ax.set_xlabel('x', fontsize=14) ax.set_ylabel('u', fontsize=14) fntmp = '%s/%ssolu2test' % (outPath, seedNo) DNN_tools.mySaveFig(plt, fntmp, ax=ax, isax=1, iseps=0)
def solve_SIR2COVID(R): log_out_path = R['FolderName'] # 将路径从字典 R 中提取出来 if not os.path.exists(log_out_path): # 判断路径是否已经存在 os.mkdir(log_out_path) # 无 log_out_path 路径,创建一个 log_out_path 路径 log_fileout = open(os.path.join(log_out_path, 'log_train.txt'), 'w') # 在这个路径下创建并打开一个可写的 log_train.txt文件 DNN_LogPrint.dictionary_out2file(R, log_fileout) log2trianSolus = open(os.path.join(log_out_path, 'train_Solus.txt'), 'w') # 在这个路径下创建并打开一个可写的 log_train.txt文件 log2testSolus = open(os.path.join(log_out_path, 'test_Solus.txt'), 'w') # 在这个路径下创建并打开一个可写的 log_train.txt文件 log2testSolus2 = open(os.path.join(log_out_path, 'test_Solus_temp.txt'), 'w') # 在这个路径下创建并打开一个可写的 log_train.txt文件 log2testParas = open(os.path.join(log_out_path, 'test_Paras.txt'), 'w') # 在这个路径下创建并打开一个可写的 log_train.txt文件 trainSet_szie = R['size2train'] batchSize_train = R['batch_size2train'] batchSize_test = R['batch_size2test'] pt_penalty_init = R[ 'init_penalty2predict_true'] # Regularization parameter for difference of predict and true wb_penalty = R['regular_weight'] # Regularization parameter for weights lr_decay = R['lr_decay'] learning_rate = R['learning_rate'] act_func2SIR = R['act2sir'] act_func2paras = R['act2paras'] input_dim = R['input_dim'] out_dim = R['output_dim'] flag2S = 'WB2S' flag2I = 'WB2I' flag2R = 'WB2R' flag2beta = 'WB2beta' flag2gamma = 'WB2gamma' hidden_sir = R['hidden2SIR'] hidden_para = R['hidden2para'] Weight2S, Bias2S = DNN.init_DNN(size2in=input_dim, size2out=out_dim, hiddens=hidden_sir, scope=flag2S, opt2Init=R['SIR_opt2init_NN']) Weight2I, Bias2I = DNN.init_DNN(size2in=input_dim, size2out=out_dim, hiddens=hidden_sir, scope=flag2I, opt2Init=R['SIR_opt2init_NN']) Weight2R, Bias2R = DNN.init_DNN(size2in=input_dim, size2out=out_dim, hiddens=hidden_sir, scope=flag2R, opt2Init=R['SIR_opt2init_NN']) Weight2beta, Bias2beta = DNN.init_DNN(size2in=input_dim, size2out=out_dim, hiddens=hidden_para, scope=flag2beta, opt2Init=R['Para_opt2init_NN']) Weight2gamma, Bias2gamma = DNN.init_DNN(size2in=input_dim, size2out=out_dim, hiddens=hidden_para, scope=flag2gamma, opt2Init=R['Para_opt2init_NN']) global_steps = tf.Variable(0, trainable=False) with tf.device('/gpu:%s' % (R['gpuNo'])): with tf.variable_scope('vscope', reuse=tf.AUTO_REUSE): T_it = tf.placeholder(tf.float32, name='T_it', shape=[None, input_dim]) I_observe = tf.placeholder(tf.float32, name='I_observe', shape=[None, input_dim]) N_observe = tf.placeholder(tf.float32, name='N_observe', shape=[None, input_dim]) predict_true_penalty = tf.placeholder_with_default(input=1e3, shape=[], name='bd_p') in_learning_rate = tf.placeholder_with_default(input=1e-5, shape=[], name='lr') train_opt = tf.placeholder_with_default(input=True, shape=[], name='train_opt') SNN_temp = DNN.PDE_DNN(x=T_it, hiddenLayer=hidden_sir, Weigths=Weight2S, Biases=Bias2S, DNNmodel=R['model2sir'], activation=act_func2SIR, freqs=R['freqs']) INN_temp = DNN.PDE_DNN(x=T_it, hiddenLayer=hidden_sir, Weigths=Weight2I, Biases=Bias2I, DNNmodel=R['model2sir'], activation=act_func2SIR, freqs=R['freqs']) RNN_temp = DNN.PDE_DNN(x=T_it, hiddenLayer=hidden_sir, Weigths=Weight2R, Biases=Bias2R, DNNmodel=R['model2sir'], activation=act_func2SIR, freqs=R['freqs']) in_beta = DNN.PDE_DNN(x=T_it, hiddenLayer=hidden_para, Weigths=Weight2beta, Biases=Bias2beta, DNNmodel=R['model2paras'], activation=act_func2paras, freqs=R['freqs']) in_gamma = DNN.PDE_DNN(x=T_it, hiddenLayer=hidden_para, Weigths=Weight2gamma, Biases=Bias2gamma, DNNmodel=R['model2paras'], activation=act_func2paras, freqs=R['freqs']) # Remark: beta, gamma,S_NN.I_NN,R_NN都应该是正的. beta.1--15之间,gamma在(0,1)使用归一化的话S_NN.I_NN,R_NN都在[0,1)范围内 if (R['total_population'] == R['scale_population']) and R['scale_population'] != 1: beta = in_beta gamma = in_gamma # SNN = SNN_temp # INN = INN_temp # RNN = RNN_temp # SNN = tf.nn.relu(SNN_temp) # INN = tf.nn.relu(INN_temp) # RNN = tf.nn.relu(RNN_temp) # SNN = tf.abs(SNN_temp) # INN = tf.abs(INN_temp) # RNN = tf.abs(RNN_temp) # SNN = DNN_base.gauss(SNN_temp) # INN = tf.square(INN_temp) # RNN = tf.square(RNN_temp) # SNN = DNN_base.gauss(SNN_temp) # INN = tf.square(INN_temp) # RNN = tf.nn.sigmoid(RNN_temp) # SNN = DNN_base.gauss(SNN_temp) # INN = tf.nn.sigmoid(INN_temp) # RNN = tf.square(RNN_temp) # SNN = tf.sqrt(tf.square(SNN_temp)) # INN = tf.sqrt(tf.square(INN_temp)) # RNN = tf.sqrt(tf.square(RNN_temp)) SNN = tf.nn.sigmoid(SNN_temp) INN = tf.nn.sigmoid(INN_temp) RNN = tf.nn.sigmoid(RNN_temp) else: beta = in_beta gamma = in_gamma # SNN = SNN_temp # INN = INN_temp # RNN = RNN_temp # SNN = tf.nn.relu(SNN_temp) # INN = tf.nn.relu(INN_temp) # RNN = tf.nn.relu(RNN_temp) SNN = tf.nn.sigmoid(SNN_temp) INN = tf.nn.sigmoid(INN_temp) RNN = tf.nn.sigmoid(RNN_temp) N_NN = SNN + INN + RNN dSNN2t = tf.gradients(SNN, T_it)[0] dINN2t = tf.gradients(INN, T_it)[0] dRNN2t = tf.gradients(RNN, T_it)[0] dN_NN2t = tf.gradients(N_NN, T_it)[0] temp_snn2t = -beta * SNN * INN temp_inn2t = beta * SNN * INN - gamma * INN temp_rnn2t = gamma * INN if str.lower( R['loss_function']) == 'l2_loss' and R['scale_up'] == 0: # LossS_Net_obs = tf.reduce_mean(tf.square(SNN - S_observe)) LossI_Net_obs = tf.reduce_mean(tf.square(INN - I_observe)) # LossR_Net_obs = tf.reduce_mean(tf.square(RNN - R_observe)) LossN_Net_obs = tf.reduce_mean(tf.square(N_NN - N_observe)) Loss2dS = tf.reduce_mean(tf.square(dSNN2t - temp_snn2t)) Loss2dI = tf.reduce_mean(tf.square(dINN2t - temp_inn2t)) Loss2dR = tf.reduce_mean(tf.square(dRNN2t - temp_rnn2t)) Loss2dN = tf.reduce_mean(tf.square(dN_NN2t)) elif str.lower( R['loss_function']) == 'l2_loss' and R['scale_up'] == 1: scale_up = R['scale_factor'] # LossS_Net_obs = tf.reduce_mean(tf.square(scale_up*SNN - scale_up*S_observe)) LossI_Net_obs = tf.reduce_mean( tf.square(scale_up * INN - scale_up * I_observe)) # LossR_Net_obs = tf.reduce_mean(tf.square(scale_up*RNN - scale_up*R_observe)) LossN_Net_obs = tf.reduce_mean( tf.square(scale_up * N_NN - scale_up * N_observe)) Loss2dS = tf.reduce_mean( tf.square(scale_up * dSNN2t - scale_up * temp_snn2t)) Loss2dI = tf.reduce_mean( tf.square(scale_up * dINN2t - scale_up * temp_inn2t)) Loss2dR = tf.reduce_mean( tf.square(scale_up * dRNN2t - scale_up * temp_rnn2t)) Loss2dN = tf.reduce_mean(tf.square(scale_up * dN_NN2t)) elif str.lower(R['loss_function']) == 'lncosh_loss': # LossS_Net_obs = tf.reduce_mean(tf.ln(tf.cosh(SNN - S_observe))) LossI_Net_obs = tf.reduce_mean(tf.log(tf.cosh(INN - I_observe))) # LossR_Net_obs = tf.reduce_mean(tf.log(tf.cosh(RNN - R_observe))) LossN_Net_obs = tf.reduce_mean( tf.log(tf.cosh(N_NN - N_observe))) Loss2dS = tf.reduce_mean(tf.log(tf.cosh(dSNN2t - temp_snn2t))) Loss2dI = tf.reduce_mean(tf.log(tf.cosh(dINN2t - temp_inn2t))) Loss2dR = tf.reduce_mean(tf.log(tf.cosh(dRNN2t - temp_rnn2t))) Loss2dN = tf.reduce_mean(tf.log(tf.cosh(dN_NN2t))) if R['regular_weight_model'] == 'L1': regular_WB2S = DNN_base.regular_weights_biases_L1( Weight2S, Bias2S) regular_WB2I = DNN_base.regular_weights_biases_L1( Weight2I, Bias2I) regular_WB2R = DNN_base.regular_weights_biases_L1( Weight2R, Bias2R) regular_WB2Beta = DNN_base.regular_weights_biases_L1( Weight2beta, Bias2beta) regular_WB2Gamma = DNN_base.regular_weights_biases_L1( Weight2gamma, Bias2gamma) elif R['regular_weight_model'] == 'L2': regular_WB2S = DNN_base.regular_weights_biases_L2( Weight2S, Bias2S) regular_WB2I = DNN_base.regular_weights_biases_L2( Weight2I, Bias2I) regular_WB2R = DNN_base.regular_weights_biases_L2( Weight2R, Bias2R) regular_WB2Beta = DNN_base.regular_weights_biases_L2( Weight2beta, Bias2beta) regular_WB2Gamma = DNN_base.regular_weights_biases_L2( Weight2gamma, Bias2gamma) else: regular_WB2S = tf.constant(0.0) regular_WB2I = tf.constant(0.0) regular_WB2R = tf.constant(0.0) regular_WB2Beta = tf.constant(0.0) regular_WB2Gamma = tf.constant(0.0) PWB2S = wb_penalty * regular_WB2S PWB2I = wb_penalty * regular_WB2I PWB2R = wb_penalty * regular_WB2R PWB2Beta = wb_penalty * regular_WB2Beta PWB2Gamma = wb_penalty * regular_WB2Gamma Loss2S = Loss2dS + PWB2S Loss2I = predict_true_penalty * LossI_Net_obs + Loss2dI + PWB2I Loss2R = Loss2dR + PWB2R Loss2N = predict_true_penalty * LossN_Net_obs + Loss2dN Loss = Loss2S + Loss2I + Loss2R + Loss2N + PWB2Beta + PWB2Gamma my_optimizer = tf.train.AdamOptimizer(in_learning_rate) if R['train_model'] == 'train_group': train_Loss2S = my_optimizer.minimize(Loss2S, global_step=global_steps) train_Loss2I = my_optimizer.minimize(Loss2I, global_step=global_steps) train_Loss2R = my_optimizer.minimize(Loss2R, global_step=global_steps) train_Loss2N = my_optimizer.minimize(Loss2N, global_step=global_steps) train_Loss = my_optimizer.minimize(Loss, global_step=global_steps) train_Losses = tf.group(train_Loss2S, train_Loss2I, train_Loss2R, train_Loss2N, train_Loss) elif R['train_model'] == 'train_union_loss': train_Losses = my_optimizer.minimize(Loss, global_step=global_steps) t0 = time.time() loss_s_all, loss_i_all, loss_r_all, loss_n_all, loss_all = [], [], [], [], [] test_epoch = [] test_mse2I_all, test_rel2I_all = [], [] # filename = 'data2csv/Wuhan.csv' # filename = 'data2csv/Italia_data.csv' filename = 'data2csv/Korea_data.csv' date, data = DNN_data.load_csvData(filename) assert (trainSet_szie + batchSize_test <= len(data)) train_date, train_data2i, test_date, test_data2i = \ DNN_data.split_csvData2train_test(date, data, size2train=trainSet_szie, normalFactor=R['scale_population']) if R['scale_population'] == 1: nbatch2train = np.ones(batchSize_train, dtype=np.float32) * float( R['total_population']) elif (R['total_population'] != R['scale_population']) and R['scale_population'] != 1: nbatch2train = np.ones(batchSize_train, dtype=np.float32) * ( float(R['total_population']) / float(R['scale_population'])) elif (R['total_population'] == R['scale_population']) and R['scale_population'] != 1: nbatch2train = np.ones(batchSize_train, dtype=np.float32) # 对于时间数据来说,验证模型的合理性,要用连续的时间数据验证 test_t_bach = DNN_data.sample_testDays_serially(test_date, batchSize_test) i_obs_test = DNN_data.sample_testData_serially(test_data2i, batchSize_test, normalFactor=1.0) print('The test data about i:\n', str(np.transpose(i_obs_test))) print('\n') DNN_tools.log_string( 'The test data about i:\n%s\n' % str(np.transpose(i_obs_test)), log_fileout) # ConfigProto 加上allow_soft_placement=True就可以使用 gpu 了 config = tf.ConfigProto(allow_soft_placement=True) # 创建sess的时候对sess进行参数配置 config.gpu_options.allow_growth = True # True是让TensorFlow在运行过程中动态申请显存,避免过多的显存占用。 config.allow_soft_placement = True # 当指定的设备不存在时,允许选择一个存在的设备运行。比如gpu不存在,自动降到cpu上运行 with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) tmp_lr = learning_rate for i_epoch in range(R['max_epoch'] + 1): t_batch, i_obs = \ DNN_data.randSample_Normalize_existData(train_date, train_data2i, batchsize=batchSize_train, normalFactor=1.0, sampling_opt=R['opt2sample']) n_obs = nbatch2train.reshape(batchSize_train, 1) tmp_lr = tmp_lr * (1 - lr_decay) train_option = True if R['activate_stage_penalty'] == 1: if i_epoch < int(R['max_epoch'] / 10): temp_penalty_pt = pt_penalty_init elif i_epoch < int(R['max_epoch'] / 5): temp_penalty_pt = 10 * pt_penalty_init elif i_epoch < int(R['max_epoch'] / 4): temp_penalty_pt = 50 * pt_penalty_init elif i_epoch < int(R['max_epoch'] / 2): temp_penalty_pt = 100 * pt_penalty_init elif i_epoch < int(3 * R['max_epoch'] / 4): temp_penalty_pt = 200 * pt_penalty_init else: temp_penalty_pt = 500 * pt_penalty_init elif R['activate_stage_penalty'] == 2: if i_epoch < int(R['max_epoch'] / 3): temp_penalty_pt = pt_penalty_init elif i_epoch < 2 * int(R['max_epoch'] / 3): temp_penalty_pt = 10 * pt_penalty_init else: temp_penalty_pt = 50 * pt_penalty_init else: temp_penalty_pt = pt_penalty_init _, loss_s, loss_i, loss_r, loss_n, loss, pwb2s, pwb2i, pwb2r = sess.run( [ train_Losses, Loss2S, Loss2I, Loss2R, Loss2N, Loss, PWB2S, PWB2I, PWB2R ], feed_dict={ T_it: t_batch, I_observe: i_obs, N_observe: n_obs, in_learning_rate: tmp_lr, train_opt: train_option, predict_true_penalty: temp_penalty_pt }) loss_s_all.append(loss_s) loss_i_all.append(loss_i) loss_r_all.append(loss_r) loss_n_all.append(loss_n) loss_all.append(loss) if i_epoch % 1000 == 0: # 以下代码为输出训练过程中 S_NN, I_NN, R_NN, beta, gamma 的训练结果 DNN_LogPrint.print_and_log2train(i_epoch, time.time() - t0, tmp_lr, temp_penalty_pt, pwb2s, pwb2i, pwb2r, loss_s, loss_i, loss_r, loss_n, loss, log_out=log_fileout) s_nn2train, i_nn2train, r_nn2train = sess.run( [SNN, INN, RNN], feed_dict={T_it: np.reshape(train_date, [-1, 1])}) # 以下代码为输出训练过程中 S_NN, I_NN, R_NN, beta, gamma 的测试结果 test_epoch.append(i_epoch / 1000) train_option = False s_nn2test, i_nn2test, r_nn2test, beta_test, gamma_test = sess.run( [SNN, INN, RNN, beta, gamma], feed_dict={ T_it: test_t_bach, train_opt: train_option }) point_ERR2I = np.square(i_nn2test - i_obs_test) test_mse2I = np.mean(point_ERR2I) test_mse2I_all.append(test_mse2I) test_rel2I = test_mse2I / np.mean(np.square(i_obs_test)) test_rel2I_all.append(test_rel2I) DNN_tools.print_and_log_test_one_epoch(test_mse2I, test_rel2I, log_out=log_fileout) DNN_tools.log_string( '------------------The epoch----------------------: %s\n' % str(i_epoch), log2testSolus) DNN_tools.log_string( 'The test result for s:\n%s\n' % str(np.transpose(s_nn2test)), log2testSolus) DNN_tools.log_string( 'The test result for i:\n%s\n' % str(np.transpose(i_nn2test)), log2testSolus) DNN_tools.log_string( 'The test result for r:\n%s\n\n' % str(np.transpose(r_nn2test)), log2testSolus) # --------以下代码为输出训练过程中 S_NN_temp, I_NN_temp, R_NN_temp, in_beta, in_gamma 的测试结果------------- s_nn_temp2test, i_nn_temp2test, r_nn_temp2test, in_beta_test, in_gamma_test = sess.run( [SNN_temp, INN_temp, RNN_temp, in_beta, in_gamma], feed_dict={ T_it: test_t_bach, train_opt: train_option }) DNN_tools.log_string( '------------------The epoch----------------------: %s\n' % str(i_epoch), log2testSolus2) DNN_tools.log_string( 'The test result for s_temp:\n%s\n' % str(np.transpose(s_nn_temp2test)), log2testSolus2) DNN_tools.log_string( 'The test result for i_temp:\n%s\n' % str(np.transpose(i_nn_temp2test)), log2testSolus2) DNN_tools.log_string( 'The test result for r_temp:\n%s\n\n' % str(np.transpose(r_nn_temp2test)), log2testSolus2) DNN_tools.log_string( '------------------The epoch----------------------: %s\n' % str(i_epoch), log2testParas) DNN_tools.log_string( 'The test result for in_beta:\n%s\n' % str(np.transpose(in_beta_test)), log2testParas) DNN_tools.log_string( 'The test result for in_gamma:\n%s\n' % str(np.transpose(in_gamma_test)), log2testParas) DNN_tools.log_string( 'The train result for S:\n%s\n' % str(np.transpose(s_nn2train)), log2trianSolus) DNN_tools.log_string( 'The train result for I:\n%s\n' % str(np.transpose(i_nn2train)), log2trianSolus) DNN_tools.log_string( 'The train result for R:\n%s\n\n' % str(np.transpose(r_nn2train)), log2trianSolus) saveData.true_value2convid(train_data2i, name2Array='itrue2train', outPath=R['FolderName']) saveData.save_Solu2mat_Covid(s_nn2train, name2solus='s2train', outPath=R['FolderName']) saveData.save_Solu2mat_Covid(i_nn2train, name2solus='i2train', outPath=R['FolderName']) saveData.save_Solu2mat_Covid(r_nn2train, name2solus='r2train', outPath=R['FolderName']) saveData.save_SIR_trainLoss2mat_Covid(loss_s_all, loss_i_all, loss_r_all, loss_n_all, actName=act_func2SIR, outPath=R['FolderName']) plotData.plotTrain_loss_1act_func(loss_s_all, lossType='loss2s', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) plotData.plotTrain_loss_1act_func(loss_i_all, lossType='loss2i', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) plotData.plotTrain_loss_1act_func(loss_r_all, lossType='loss2r', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) plotData.plotTrain_loss_1act_func(loss_n_all, lossType='loss2n', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) saveData.true_value2convid(i_obs_test, name2Array='i_true2test', outPath=R['FolderName']) saveData.save_testMSE_REL2mat(test_mse2I_all, test_rel2I_all, actName='Infected', outPath=R['FolderName']) plotData.plotTest_MSE_REL(test_mse2I_all, test_rel2I_all, test_epoch, actName='Infected', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) saveData.save_SIR_testSolus2mat_Covid(s_nn2test, i_nn2test, r_nn2test, name2solus1='snn2test', name2solus2='inn2test', name2solus3='rnn2test', outPath=R['FolderName']) saveData.save_SIR_testParas2mat_Covid(beta_test, gamma_test, name2para1='beta2test', name2para2='gamma2test', outPath=R['FolderName']) plotData.plot_testSolu2convid(i_obs_test, name2solu='i_true', coord_points2test=test_t_bach, outPath=R['FolderName']) plotData.plot_testSolu2convid(s_nn2test, name2solu='s_test', coord_points2test=test_t_bach, outPath=R['FolderName']) plotData.plot_testSolu2convid(i_nn2test, name2solu='i_test', coord_points2test=test_t_bach, outPath=R['FolderName']) plotData.plot_testSolu2convid(r_nn2test, name2solu='r_test', coord_points2test=test_t_bach, outPath=R['FolderName']) plotData.plot_testSolus2convid(i_obs_test, i_nn2test, name2solu1='i_true', name2solu2='i_test', coord_points2test=test_t_bach, seedNo=R['seed'], outPath=R['FolderName']) plotData.plot_testSolu2convid(beta_test, name2solu='beta_test', coord_points2test=test_t_bach, outPath=R['FolderName']) plotData.plot_testSolu2convid(gamma_test, name2solu='gamma_test', coord_points2test=test_t_bach, outPath=R['FolderName'])
def solve_Integral_Equa(R): log_out_path = R['FolderName'] # 将路径从字典 R 中提取出来 if not os.path.exists(log_out_path): # 判断路径是否已经存在 os.mkdir(log_out_path) # 无 log_out_path 路径,创建一个 log_out_path 路径 outFile2para_name = '%s_%s.txt' % ('para2', 'beta') logfile_name = '%s%s.txt' % ('log2', R['activate_func']) log_fileout = open(os.path.join(log_out_path, logfile_name), 'w') # 在这个路径下创建并打开一个可写的 log_train.txt文件 para_outFile = open(os.path.join(log_out_path, outFile2para_name), 'w') # 在这个路径下创建并打开一个可写的 para_outFile.txt文件 dictionary_out2file(R, log_fileout) # 积分方程问题需要的设置 batchsize = R['batch_size2integral'] batchsize2aux = R['batch_size2auxiliary'] wb_regular = R['regular_weight_biases'] lr_decay = R['learning_rate_decay'] learning_rate = R['learning_rate'] hidden_layers = R['hidden_layers'] act_func = R['activate_func'] # ------- set the problem --------- data_indim = R['input_dim'] data_outdim = R['output_dim'] para_dim = R['estimate_para_dim'] # 初始化权重和和偏置的模式 flag2bnn = 'bnn' input_dim = 1 if R['model'] == 'PDE_DNN_Cos_C_Sin_Base': W2b, B2b = DNN_base.initialize_NN_random_normal2_CS(input_dim, para_dim, hidden_layers, flag2bnn) else: W2b, B2b = DNN_base.initialize_NN_random_normal2(input_dim, para_dim, hidden_layers, flag2bnn) global_steps = tf.Variable(0, trainable=False) with tf.device('/gpu:%s' % (R['gpuNo'])): with tf.variable_scope('vscope', reuse=tf.AUTO_REUSE): X = tf.placeholder(tf.float32, name='X_recv', shape=[batchsize, data_indim]) Y = tf.placeholder(tf.float32, name='Y_recv', shape=[batchsize, data_indim]) R2XY = tf.placeholder(tf.float32, name='R2XY_recv', shape=[batchsize, data_indim]) y_aux = tf.placeholder(tf.float32, name='y_auxiliary', shape=[batchsize2aux, 1]) beta = tf.Variable(tf.random.uniform([1, para_dim]), dtype='float32', name='beta') # beta = tf.Variable([[0.25, -0.5]], dtype='float32', name='beta') # beta = tf.constant([[0.25, -0.5]], dtype=tf.float32, name='beta') tfOne = tf.placeholder(tf.float32, shape=[1, 1], name='tfOne') inline_lr = tf.placeholder_with_default(input=1e-5, shape=[], name='inline_learning_rate') # 供选择的网络模式 if R['model'] == str('DNN'): b_NN2y = DNN_base.PDE_DNN(y_aux, W2b, B2b, hidden_layers, activate_name=act_func) # b_NN2Y = DNN_base.PDE_DNN(Y, W2b, B2b, hidden_layers, activate_name=act_func) elif R['model'] == 'DNN_scale': freq = R['freqs'] b_NN2y = DNN_base.PDE_DNN_scale(y_aux, W2b, B2b, hidden_layers, freq, activate_name=act_func) # b_NN2Y = DNN_base.PDE_DNN_scale(Y, W2b, B2b, hidden_layers, freq, activate_name=act_func) elif R['model'] == 'DNN_adapt_scale': freq = R['freqs'] b_NN2y = DNN_base.PDE_DNN_adapt_scale(y_aux, W2b, B2b, hidden_layers, freq, activate_name=act_func) # b_NN2Y = DNN_base.PDE_DNN_adapt_scale(Y, W2b, B2b, hidden_layers, freq, activate_name=act_func) elif R['model'] == 'DNN_FourierBase': freq = R['freqs'] b_NN2y = DNN_base.PDE_DNN_FourierBase(y_aux, W2b, B2b, hidden_layers, freq, activate_name=act_func) # b_NN2Y = DNN_base.PDE_DNN_FourierBase(Y, W2b, B2b, hidden_layers, freq, activate_name=act_func) elif R['model'] == 'DNN_Cos_C_Sin_Base': freq = R['freqs'] b_NN2y = DNN_base.PDE_DNN_Cos_C_Sin_Base(y_aux, W2b, B2b, hidden_layers, freq, activate_name=act_func) # b_NN2Y = DNN_base.PDE_DNN_Cos_C_Sin_Base(Y, W2b, B2b, hidden_layers, freq, activate_name=act_func) # 下面怎么把循环改为向量操作呢? sum2bleft = tf.zeros(shape=[1, 1], dtype=tf.float32, name='01') sum2bright = tf.zeros(shape=[1, 1], dtype=tf.float32, name='02') # 使用循环将Xi取出来,然后带入方程计算b(·:beta),需要对i累加,最后取均值 for i in range(batchsize): Xtemp = tf.reshape(X[i], shape=[1, 1]) # Xi取出 OneX = tf.concat([tfOne, Xtemp], axis=-1) # 1 行 (1+dim) 列 XiTrans = tf.transpose(OneX, [1, 0]) # (1,Xi) fYX_y = my_normal(t=y_aux-tf.matmul(beta, XiTrans)) # fY|X在y处的取值,fY|X(y) dfYX_beta = tf.matmul(my_normal(t=y_aux-tf.matmul(beta, XiTrans))*(y_aux-tf.matmul(beta, XiTrans)), OneX) # fY|X(y)对beta的导数 # beta 是 1 行 para_dim 列 fyx_1minus_phi_integral = tf.reduce_mean(fYX_y * (1 - pi_star(t=y_aux)), axis=0) # fY|X(t)*(1-pi(t))的积分 dfyx_phi_integral = tf.reduce_mean(dfYX_beta * pi_star(t=y_aux), axis=0) # diff_fY|X(y)*pi(t)的积分 ceof_vec2left = dfyx_phi_integral/fyx_1minus_phi_integral sum2bleft = sum2bleft + dfYX_beta + ceof_vec2left*fYX_y b_fyx_phi_integral = tf.reduce_mean(b_NN2y*fYX_y*pi_star(t=y_aux), axis=0) # b(t, beta)*fY|X(t)*pi(t)的积分 ceof_vec2right = b_fyx_phi_integral / fyx_1minus_phi_integral sum2bright = sum2bright + b_NN2y * fYX_y + ceof_vec2right * fYX_y bleft = sum2bleft / batchsize # (1/N)sum{i=1:i=N(·)} bright = sum2bright / batchsize # (1/N)sum{i=1:i=N(·)} loss2b = tf.reduce_mean(tf.reduce_mean(tf.square(bleft - bright), axis=0)) sum2Seff = tf.zeros(shape=[1, 1], dtype=tf.float32, name='03') for i in range(batchsize): Xtemp = tf.reshape(X[i], shape=[1, 1]) OneX = tf.concat([tfOne, Xtemp], axis=-1) # 1 行 (1+dim) 列 XiTrans = tf.transpose(OneX, [1, 0]) fYX2y = my_normal(t=y_aux - tf.matmul(beta, XiTrans)) # fY|X在y处的取值,fY|X(y) Yi = tf.reshape(Y[i], shape=[1, 1]) # Yi fYX2Y = my_normal(t=Yi-tf.matmul(beta, XiTrans)) # fY|X在Yi处的取值,fY|X(Yi) dfYX_beta2Y = tf.matmul(my_normal(t=Yi-tf.matmul(beta, XiTrans))*(Yi-tf.matmul(beta, XiTrans)), OneX) # diff_fY|X(Yi) dfYX_beta2y = tf.matmul(my_normal(t=y_aux - tf.matmul(beta, XiTrans)) * (y_aux - tf.matmul(beta, XiTrans)), OneX) # diff_fY|X(t) fyx_1minus_phi_integral = tf.reduce_mean(fYX2y * (1 - pi_star(t=y_aux)), axis=0) # fY|X(t)*(1-pi(t))的积分 dfyx_phi_integral = tf.reduce_mean(dfYX_beta2y * pi_star(t=y_aux), axis=0) # diff_fY|X(y)*pi(t)的积分 fyx_b_phi_integral = tf.reduce_mean(fYX2y * b_NN2y * pi_star(t=y_aux), axis=0) # fY|X(t)*b(t, beta)*pi(t)的积分 R2XY_i = tf.reshape(R2XY[i], shape=[1, -1]) # Ri Seff1 = (R2XY_i/fYX2Y) * dfYX_beta2Y - ((1-R2XY_i)/fyx_1minus_phi_integral) * dfyx_phi_integral # S^*_beta if R['model'] == 'DNN': b_NN2Yi = DNN_base.PDE_DNN(Yi, W2b, B2b, hidden_layers, activate_name=act_func) elif R['model'] == 'DNN_scale': freq = R['freqs'] b_NN2Yi = DNN_base.PDE_DNN_scale(Yi, W2b, B2b, hidden_layers, freq, activate_name=act_func) elif R['model'] == 'DNN_adapt_scale': freq = R['freqs'] b_NN2Yi = DNN_base.PDE_DNN_adapt_scale(Yi, W2b, B2b, hidden_layers, freq, activate_name=act_func) elif R['model'] == 'DNN_FourierBase': freq = R['freqs'] b_NN2Yi = DNN_base.PDE_DNN_FourierBase(Yi, W2b, B2b, hidden_layers, freq, activate_name=act_func) elif R['model'] == 'DNN_Cos_C_Sin_Base': freq = R['freqs'] b_NN2Yi = DNN_base.PDE_DNN_Cos_C_Sin_Base(Yi, W2b, B2b, hidden_layers, freq, activate_name=act_func) Seff2 = R2XY_i * tf.reshape(b_NN2Yi, shape=[1, -1]) Seff3 = (1-R2XY_i) * (fyx_b_phi_integral/fyx_1minus_phi_integral) Seff = Seff1 - Seff2 + Seff3 sum2Seff = sum2Seff + Seff loss2s_temp = sum2Seff/batchsize loss2Seff = tf.reduce_mean(tf.square(loss2s_temp)) if R['regular_weight_model'] == 'L1': regular_WB2b = DNN_base.regular_weights_biases_L1(W2b, B2b) elif R['regular_weight_model'] == 'L2': regular_WB2b = DNN_base.regular_weights_biases_L2(W2b, B2b) else: regular_WB2b = tf.constant(0.0) penalty_WB = wb_regular * regular_WB2b loss = loss2b + loss2Seff + penalty_WB # 要优化的loss function my_optimizer = tf.train.AdamOptimizer(inline_lr) if R['train_group'] == 0: train_my_loss = my_optimizer.minimize(loss, global_step=global_steps) if R['train_group'] == 1: train_op1 = my_optimizer.minimize(loss2b, global_step=global_steps) train_op2 = my_optimizer.minimize(loss2Seff, global_step=global_steps) train_op3 = my_optimizer.minimize(loss, global_step=global_steps) train_my_loss = tf.group(train_op1, train_op2, train_op3) elif R['train_group'] == 2: train_op1 = my_optimizer.minimize(loss2b, global_step=global_steps) train_op2 = my_optimizer.minimize(loss2Seff, global_step=global_steps) train_my_loss = tf.group(train_op1, train_op2) t0 = time.time() loss_b_all, loss_seff_all, loss_all = [], [], [] # 空列表, 使用 append() 添加元素 # ConfigProto 加上allow_soft_placement=True就可以使用 gpu 了 config = tf.ConfigProto(allow_soft_placement=True) # 创建sess的时候对sess进行参数配置 config.gpu_options.allow_growth = True # True是让TensorFlow在运行过程中动态申请显存,避免过多的显存占用。 config.allow_soft_placement = True # 当指定的设备不存在时,允许选择一个存在的设备运行。比如gpu不存在,自动降到cpu上运行 x_batch = DNN_data.randnormal_mu_sigma(size=batchsize, mu=0.5, sigma=0.5) y_init = 0.25 - 0.5 * x_batch + np.reshape(np.random.randn(batchsize, 1), (-1, 1)) y_aux_batch = DNN_data.rand_it(batch_size=batchsize2aux, variable_dim=data_indim, region_a=-2, region_b=2) # y_aux_batch = DNN_data.randnormal_mu_sigma(size=batchsize2aux, mu=0.0, sigma=1.5) # x_aux_batch = DNN_data.randnormal_mu_sigma(size=batchsize2aux, mu=0.5, sigma=0.5) # y_aux_batch = 0.25 - 0.5 * x_aux_batch + np.reshape(np.random.randn(batchsize2aux, 1), (-1, 1)) relate2XY = np.reshape(np.random.randint(0, 2, batchsize), (-1, 1)) y_batch = np.multiply(y_init, relate2XY) one2train = np.ones((1, 1)) with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) tmp_lr = learning_rate for i_epoch in range(R['max_epoch'] + 1): tmp_lr = tmp_lr * (1 - lr_decay) _, loss2b_tmp, loss2seff_tmp, loss_tmp, p_WB, beta_temp = sess.run( [train_my_loss, loss2b, loss2Seff, loss, penalty_WB, beta], feed_dict={X: x_batch, Y: y_batch, R2XY: relate2XY, y_aux: y_aux_batch, tfOne: one2train, inline_lr: tmp_lr}) loss_b_all.append(loss2b_tmp) loss_seff_all.append(loss2seff_tmp) loss_all.append(loss_tmp) if (i_epoch % 10) == 0: DNN_tools.log_string('*************** epoch: %d*10 ****************' % int(i_epoch / 10), log_fileout) DNN_tools.log_string('lossb for training: %.10f\n' % loss2b_tmp, log_fileout) DNN_tools.log_string('lossS for training: %.10f\n' % loss2seff_tmp, log_fileout) DNN_tools.log_string('loss for training: %.10f\n' % loss_tmp, log_fileout) if (i_epoch % 100) == 0: print('**************** epoch: %d*100 *******************'% int(i_epoch/100)) print('beta:[%f %f]' % (beta_temp[0, 0], beta_temp[0, 1])) print('\n') DNN_tools.log_string('*************** epoch: %d*100 *****************' % int(i_epoch/100), para_outFile) DNN_tools.log_string('beta:[%f, %f]' % (beta_temp[0, 0], beta_temp[0, 1]), para_outFile) DNN_tools.log_string('\n', para_outFile) saveData.save_trainLoss2mat_1actFunc(loss_b_all, loss_seff_all, loss_all, actName=act_func, outPath=R['FolderName']) plotData.plotTrain_loss_1act_func(loss_b_all, lossType='loss_b', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) plotData.plotTrain_loss_1act_func(loss_seff_all, lossType='loss_s', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True) plotData.plotTrain_loss_1act_func(loss_all, lossType='loss_all', seedNo=R['seed'], outPath=R['FolderName'], yaxis_scale=True)
def dictionary_out2file(R_dic, log_fileout): DNN_tools.log_string('PDE type for problem: %s\n' % (R_dic['PDE_type']), log_fileout) DNN_tools.log_string('Equation name for problem: %s\n' % (R_dic['eqs_name']), log_fileout) if R_dic['activate_stop'] != 0: DNN_tools.log_string('activate the stop_step and given_step= %s\n' % str(R_dic['max_epoch']), log_fileout) else: DNN_tools.log_string('no activate the stop_step and given_step = default: %s\n' % str(R_dic['max_epoch']), log_fileout) DNN_tools.log_string('Network model of solving problem: %s\n' % str(R_dic['model']), log_fileout) DNN_tools.log_string('Activate function for network: %s\n' % str(R_dic['activate_func']), log_fileout) if R_dic['model'] != 'DNN': DNN_tools.log_string('The frequency to neural network: %s\n' % (R_dic['freqs']), log_fileout) if (R_dic['optimizer_name']).title() == 'Adam': DNN_tools.log_string('optimizer:%s\n' % str(R_dic['optimizer_name']), log_fileout) else: DNN_tools.log_string('optimizer:%s with momentum=%f\n' % (R_dic['optimizer_name'], R_dic['momentum']), log_fileout) if R_dic['train_group'] == 0: DNN_tools.log_string('Training total loss \n', log_fileout) elif R_dic['train_group'] == 1: DNN_tools.log_string('Training total loss + parts loss \n', log_fileout) elif R_dic['train_group'] == 2: DNN_tools.log_string('Training parts loss \n', log_fileout) DNN_tools.log_string('Init learning rate: %s\n' % str(R_dic['learning_rate']), log_fileout) DNN_tools.log_string('Decay to learning rate: %s\n' % str(R_dic['learning_rate_decay']), log_fileout) DNN_tools.log_string('hidden layer:%s\n' % str(R_dic['hidden_layers']), log_fileout) DNN_tools.log_string('Batch-size 2 integral: %s\n' % str(R_dic['batch_size2integral']), log_fileout) DNN_tools.log_string('Batch-size 2 auxiliary: %s\n' % str(R_dic['batch_size2auxiliary']), log_fileout)
def print_and_log2train(i_epoch, run_time, tmp_lr, temp_penalty_nt, penalty_wb2s, penalty_wb2i, penalty_wb2r, loss_s, loss_i, loss_r, loss_n, loss, log_out=None): print('train epoch: %d, time: %.3f' % (i_epoch, run_time)) print('learning rate: %f' % tmp_lr) print('penalty for difference of predict and true : %f' % temp_penalty_nt) print('penalty weights and biases for S: %f' % penalty_wb2s) print('penalty weights and biases for I: %f' % penalty_wb2i) print('penalty weights and biases for R: %f' % penalty_wb2r) print('loss for S: %.16f' % loss_s) print('loss for I: %.16f' % loss_i) print('loss for R: %.16f' % loss_r) print('loss for N: %.16f\n' % loss_n) print('total loss: %.16f\n' % loss) DNN_tools.log_string('train epoch: %d,time: %.3f' % (i_epoch, run_time), log_out) DNN_tools.log_string('learning rate: %f' % tmp_lr, log_out) DNN_tools.log_string( 'penalty for difference of predict and true : %f' % temp_penalty_nt, log_out) DNN_tools.log_string('penalty weights and biases for S: %f' % penalty_wb2s, log_out) DNN_tools.log_string('penalty weights and biases for I: %f' % penalty_wb2i, log_out) DNN_tools.log_string( 'penalty weights and biases for R: %.10f' % penalty_wb2r, log_out) DNN_tools.log_string('loss for S: %.16f' % loss_s, log_out) DNN_tools.log_string('loss for I: %.16f' % loss_i, log_out) DNN_tools.log_string('loss for R: %.16f' % loss_r, log_out) DNN_tools.log_string('loss for N: %.16f' % loss_n, log_out) DNN_tools.log_string('total loss: %.16f \n\n' % loss, log_out)