nngen_backward_2front.py

#coding:utf-8
#预测多或预测少的影响一样
#0导入模块，生成数据集
from __future__ import print_function
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import os
import random
import math
import matplotlib as mpl
import nngen_forward_2front # 导入前向传播模型  
mpl.rcParams['font.family'] = 'sans-serif'  #config the matplot
mpl.rcParams['font.sans-serif'] = 'NSimSun,Times New Roman'
BATCH_SIZE = 1
LEARNING_RATE_BASE = 0.1
LEARNING_RATE_DECAY = 0.99  # 学习衰减率
REGULARIZER = 0.0001  #正则化系数   
STEPS = 200000  #2000000 # 训练步数
a = 1
train_flag = 1  # 设置为训练模式
MODEL_SAVE_PATH = "model/model_2front" # 模型保存路径
MODEL_NAME="2front_model" # 模型名称    

# 检查并创建模型保存路径
if not os.path.exists(MODEL_SAVE_PATH):
    try:
        os.makedirs(MODEL_SAVE_PATH)
        print(f"创建模型保存目录: {MODEL_SAVE_PATH}")
    except Exception as e:
        print(f"创建模型保存目录失败: {e}")
        raise
else:
    print(f"模型保存目录已存在: {MODEL_SAVE_PATH}")

# 打印完整的模型保存路径
model_path = os.path.join(MODEL_SAVE_PATH, MODEL_NAME)
print(f"模型将保存到: {model_path}")

##############################读取训练数据##########################################
number_of_each_group = 15  # 11为4个输入点，1个答案点，一个model # 每组数据包含的点数
number_input=10 # 输入点数  
#############################训练数据##############################################

##############################读取训练数据##########################################
number_of_each_group = 15  # 11为4个输入点，1个答案点，一个model # 每组数据包含的点数
number_input=10 # 输入点数  
#############################训练数据##############################################
train_data_nn1 = np.loadtxt('train_data_output3.txt', delimiter=',', unpack=True)
#调用本级目录直接写，调用上级目录下其他目录里面的文件like this data = np.loadtxt("../data/numeric.txt", dtype=np.int32, delimiter=',', skiprows=0, encoding='utf-8')
# train_data_nn1 = np.loadtxt('/home/lupeng/Downloads/anntest1/train_data_output_2019071801.txt', delimiter=',', unpack=True)

train_data_nn_len=int(len(train_data_nn1))
print(train_data_nn_len) #打印出训练数据的长度 #46110
train_data_nn_group=int(train_data_nn_len/number_of_each_group)  #一组15个数
print(train_data_nn_group) #打印出训练数据的分组数   #3074 每个样本都是一个网格生成场景，包含5个点的位置信息和对应的正确生成模式。这些数据将用于训练神经网络识别不同的网格生成模式。  
train_data_nn=[]#初始化训练数据 
y_ref=[]#初始化训练标签
test_data_nn=[]#初始化测试数据
y_ref_test=[]#初始化测试标签
# for i in range(train_data_nn_group): #
#     train_data_nn.append([])
#     y_ref.append([])
#     for j in range(number_input):
#         train_data_nn[i].append(train_data_nn1[i*number_of_each_group+j])
#     # for k in range(4):  #只加了两个点进来，模式没有加进来
#     #     y_ref[i].append(train_data_nn1[i*number_of_each_group+number_input+k])
#     lable=[0,0,0,0,0,0,0,0,0,0]
#     for m in range(10):#分类的个数
#         if train_data_nn1[i*number_of_each_group+14]==m+1:
#             lable[m]=1
#     for n in range(10):
#         y_ref[i].append(lable[n])
train_data_nn_test1=[] # 按模式分类后的训练数
y_ref_test1=[]  # 按模式分类后的标签数据

for i in range(10): #从0到9
    num_flag=0
    m = 0
    train_data_nn_test1.append([]) # 为每种模式初始化一个空列表
    y_ref_test.append([]) # 为当前模式创建标签列表  
     # 内循环：为每种模式收集931个样本          
    while(num_flag<931): #931为内部最模式最多的
        m=m % train_data_nn_group # 取模运算，确保m在0到train_data_nn_group-1之间循环
        if train_data_nn1[m*number_of_each_group+14]==i+1: # 检查当前模式是否与目标模式匹配 

            train_data_nn_test1[len(train_data_nn_test1) - 1].append([])
            for k in range(number_of_each_group): #一共15个数，7个点，加一个模式
                train_data_nn_test1[len(train_data_nn_test1) - 1][num_flag].append(train_data_nn1[m*number_of_each_group+k])
            num_flag=num_flag+1 # 计数器+1
        m=m+1 #移动到下一组数据

#调用本级目录直接写，调用上级目录下其他目录里面的文件like this data = np.loadtxt("../data/numeric.txt", dtype=np.int32, delimiter=',', skiprows=0, encoding='utf-8')
# train_data_nn1 = np.loadtxt('/home/lupeng/Downloads/anntest1/train_data_output_2019071801.txt', delimiter=',', unpack=True)

train_data=[]
for i in range(10): #10个分类
    for j in range(931):  #931为内部最模式最多的
        train_data.append([])
        train_data[len(train_data)-1]=train_data_nn_test1[i][j]
np.random.seed(116)  #按照随机种子打乱数据
np.random.shuffle(train_data)#随机打乱数据  

print(train_data)

len_train_data=len(train_data)
train_data_temp=[]#存储输入特征
y_ref_temp=[]#存储标签  
for i in range(len_train_data):  #把数据分开，就是输入和标签分开
    train_data_temp.append([])
    y_ref_temp.append([])
    #  取前10个值作为输入特征(5个点的xy坐标)
    for j in  range(number_input):
        train_data_temp[len(train_data_temp)-1].append(train_data[i][j])
    y_ref_temp[len(y_ref_temp)-1].append(train_data[i][number_of_each_group-1])  #提取最后一个作为模式

len_train_data_all=len(train_data_temp)
len_train=int(0.85*len_train_data_all)#85%作为训练集    
#训练集
train_data_nn_test1=train_data_temp[0:len_train]  #
y_ref_test2=y_ref_temp[0:len_train]
#标签one-hot编码:
y_ref_test1=[]
for i in range(len(y_ref_test2)):
    y_ref_test1.append([])
    lable=[0,0,0,0,0,0,0,0,0,0]
    for m in range(10):#分类的个数
        if y_ref_test2[i][0]==m+1:
            lable[m]=1
    for n in range(10):#分类的个数
        y_ref_test1[i].append(lable[n])
    yyy=1



#测试集
test_data_nn_test1=train_data_temp[len_train:len_train_data_all]  #
y_test=y_ref_temp[len_train:len_train_data_all]


# train_data_nn_test1=[]
# train_data_nn_test1.append([])
# train_data_nn_test1[len(train_data_nn_test1)-1]=train_data_nn[0] #1
# train_data_nn_test1.append([])
# train_data_nn_test1[len(train_data_nn_test1)-1]=train_data_nn[99] #2
# train_data_nn_test1.append([])
# train_data_nn_test1[len(train_data_nn_test1)-1]=train_data_nn[98]#3
# train_data_nn_test1.append([])
# train_data_nn_test1[len(train_data_nn_test1)-1]=train_data_nn[105]#4
# train_data_nn_test1.append([])
# train_data_nn_test1[len(train_data_nn_test1)-1]=train_data_nn[130] #5
# train_data_nn_test1.append([])
# train_data_nn_test1[len(train_data_nn_test1)-1]=train_data_nn[109] #6
# train_data_nn_test1.append([])
# train_data_nn_test1[len(train_data_nn_test1)-1]=train_data_nn[129]#7
# train_data_nn_test1.append([])
# train_data_nn_test1[len(train_data_nn_test1)-1]=train_data_nn[108]#8
# train_data_nn_test1.append([])
# train_data_nn_test1[len(train_data_nn_test1)-1]=train_data_nn[92]#9
# train_data_nn_test1.append([])
# train_data_nn_test1[len(train_data_nn_test1)-1]=train_data_nn[91]#10


#
#
# y_ref_test1=[]
# y_ref_test1.append([])
# y_ref_test1[len(y_ref_test1)-1]=y_ref[0] #1
# y_ref_test1.append([])
# y_ref_test1[len(y_ref_test1)-1]=y_ref[99] #2
# y_ref_test1.append([])
# y_ref_test1[len(y_ref_test1)-1]=y_ref[98]#3
# y_ref_test1.append([])
# y_ref_test1[len(y_ref_test1)-1]=y_ref[105]#4
# y_ref_test1.append([])
# y_ref_test1[len(y_ref_test1)-1]=y_ref[130] #5
# y_ref_test1.append([])
# y_ref_test1[len(y_ref_test1)-1]=y_ref[109] #6
# y_ref_test1.append([])
# y_ref_test1[len(y_ref_test1)-1]=y_ref[129]#7
# y_ref_test1.append([])
# y_ref_test1[len(y_ref_test1)-1]=y_ref[108]#8
# y_ref_test1.append([])
# y_ref_test1[len(y_ref_test1)-1]=y_ref[92]#9
# y_ref_test1.append([])
# y_ref_test1[len(y_ref_test1)-1]=y_ref[91]#10
#
#
#
# for i in  range(len(y_ref)):
#     if y_ref[i][4]==222:
#         u=i
#         break

i=0
ii=0
# for jjj in range(train_data_nn_group-346,train_data_nn_group): #
#     test_data_nn.append([])
#     y_ref_test.append([])
#     for j in range(number_input):
#
#         test_data_nn[i].append(train_data_nn1[jjj*number_of_each_group+j])
#     i = i + 1
#     for k in range(5):#两个点坐标＋一个模式
#         y_ref_test[ii].append(train_data_nn1[jjj*number_of_each_group+number_input+k])
#     ii=ii+1
#
# for i in  range(len(y_ref_test)):
#     if y_ref_test[i][4]==222:
#         u=i
#         break

#
# test_data_nn.remove(test_data_nn[n])  #u这一行数据有问题，需要删去
# y_ref_test.remove(y_ref_test[u])


y_ref_len=len(y_ref_test1)
train_data_nn_len=len(train_data_nn_test1)
aaa_max=0


def backward():
    # 在函数开头声明使用全局变量
    global STEPS, BATCH_SIZE, LEARNING_RATE_BASE, LEARNING_RATE_DECAY, REGULARIZER
    
    error = 0
    with tf.name_scope('inputs'):
        x_data = tf.placeholder(tf.float32, [None, nngen_forward_2front.INPUT_NODE], name='x_input')
        y_target = tf.placeholder(tf.float32, [None, nngen_forward_2front.OUTPUT_NODE], name='y_input')
    final_output = nngen_forward_2front.forward(x_data, REGULARIZER)# 前向传播计算输出  
    
    #2定义损失函数及反向传播方法。
    global_step = tf.Variable(0, trainable=False)
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,
        global_step,
        (train_data_nn_len-1) / BATCH_SIZE,
        LEARNING_RATE_DECAY,
        staircase=True)

    with tf.name_scope('loss'):
        loss = tf.reduce_mean(tf.square(y_target - final_output))
        tf.summary.scalar('loss', loss)

    with tf.name_scope('train'):
        train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)

    saver = tf.train.Saver()
    with tf.Session() as sess:
        merged = tf.summary.merge_all()
        writer = tf.summary.FileWriter("logs7/", sess.graph)
        init_op = tf.global_variables_initializer()
        sess.run(init_op)

        ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH)
        if ckpt and ckpt.model_checkpoint_path:
            saver.restore(sess, ckpt.model_checkpoint_path)
        if train_flag==0:
            STEPS=len(test_data_nn_test1)
        for i in range(STEPS):
            start = (i*BATCH_SIZE) % y_ref_len
            end = (i*BATCH_SIZE) % y_ref_len + BATCH_SIZE

            pp=train_data_nn_test1[start:end]
            m=i%100
            xm=train_data_nn_test1[start:end]
            ym=y_ref[start:end]
            if train_flag==1:
                _,loss_v,step,output=sess.run([train_step,loss, global_step,final_output ], 
                    feed_dict={x_data: train_data_nn_test1[start:end], y_target: y_ref_test1[start:end]})

                if i % 50 == 0:
                    result = sess.run(merged,
                        feed_dict={x_data: train_data_nn_test1[start:end], y_target: y_ref_test1[start:end]})
                    writer.add_summary(result, i)
                if i % 500 == 0:
                    saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step)
                    print("After %d steps, loss is: %f" % (step, loss_v))
            else:
                output = sess.run(final_output, feed_dict={x_data: test_data_nn_test1[start:end]})
                output2=output[0]
                aaa=output2.tolist()
                aaa_max=aaa.index(max(aaa))
                aaa_max=aaa_max+1 #实际的加1才是真实的
                print("*********************")
                print("input",test_data_nn_test1[start:end])
                print( "daan",y_test[start:end])
                print("act_output",output)
                print("max", aaa_max)
                daan=int(y_test[start:end][0][0])
                if daan!=aaa_max:
                    error=error+1
                    print("error")
                    for j in range(4):  # 每提取一次会出现三条边，一个答案点，通过此循环，每次生成一条边
                        temp_taindata_out_x = []
                        temp_taindata_out_y = []
                        temp_taindata_out_x.append(test_data_nn_test1[start:end][0][2 * j + 0])
                        temp_taindata_out_x.append(test_data_nn_test1[start:end][0][2 * j + 2])
                        temp_taindata_out_y.append(test_data_nn_test1[start:end][0][2 * j + 1])
                        temp_taindata_out_y.append(test_data_nn_test1[start:end][0][2 * j + 3])
                        plt.plot(temp_taindata_out_x, temp_taindata_out_y, 'g-s', linewidth=2, color='b',
                                markerfacecolor='b', marker='o')

                    plt.xlim((-1.5, 3.5))
                    plt.xticks(np.linspace(-2.5, 2.5, 5, endpoint=True))
                    plt.ylim((-1.5, 3.5))
                    plt.yticks(np.linspace(-2.5, 2.5, 5, endpoint=True))
                    plt.show()

        zhunquelv=error/len(y_test)
        print("准确率",1-zhunquelv)



def main():

    backward()

if __name__ == '__main__':
    main()
# direct to the local dir and run this in terminal:
# $ tensorboard --logdir logs


#在本代码#2中尝试其他反向传播方法，看对收敛速度的影响，把体会写到笔记中