Question

通过阅读关于Tensorflow的教程并阅读有关神经网络的一些基本知识，我使用python和Tensorflow库建模神经网络。

截至目前，我的“.csv”文件数据如下：

AT  V   AP  RH  PE
14.96   41.76   1024.07 73.17   463.26
25.18   62.96   1020.04 59.08   444.37
5.11    39.4    1012.16 92.14   488.56
20.86   57.32   1010.24 76.64   446.48
10.82   37.5    1009.23 96.62   473.9
26.27   59.44   1012.23 58.77   443.67
15.89   43.96   1014.02 75.24   467.35
9.48    44.71   1019.12 66.43   478.42
14.64   45  1021.78 41.25   475.98
.....................................

截至目前，我已将神经网络设计为多输入和多输出。在上面的数据中，我考虑前三列作为我的输入，接下来的两列作为我的输出。所以，一旦我训练数据，如果我通过输入14.64,45,1021.78，我希望我的神经网络预测输出值41.25和475.98。这是我目前的代码：

import tensorflow as tf
import numpy as np
import pandas as pd
#import matplotlib.pyplot as plt
rng = np.random

# Parameters
learning_rate = 0.01
training_epochs = 5000
display_step = 1000
batch_size = 100

# Read data from CSV

df = pd.read_csv("H:\MiniThessis\Sample.csv")


# In[173]:

# Seperating out dependent & independent variable

train_x = df[['AT','V','AP']]
train_y = df[['RH','PE']]
trainx = train_x.as_matrix().astype(np.float32)
trainy = train_y.as_matrix().astype(np.float32)

n_input = 3
n_classes = 2
n_hidden_1 = 20
n_hidden_2 = 20
n_samples = len(trainx)

# tf Graph Input
#Inserts a placeholder for a tensor that will be always fed.
x = tf.placeholder(tf.float32, [None, n_input])
y = tf.placeholder(tf.float32, [None, n_classes])

# Set model weights
W_h1 = tf.Variable(tf.random_normal([n_input, n_hidden_1]))
W_h2 = tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2]))
W_out = tf.Variable(tf.random_normal([n_hidden_2, n_classes]))
b_h1 = tf.Variable(tf.zeros([n_hidden_1]))
b_h2 = tf.Variable(tf.zeros([n_hidden_2]))
b_out = tf.Variable(tf.zeros([n_classes]))


# In[175]:

# Construct a linear model
layer_1 = tf.add(tf.matmul(x, W_h1), b_h1)
layer_1 = tf.nn.relu(layer_1)
layer_2 = tf.add(tf.matmul(layer_1, W_h2), b_h2)
layer_2 = tf.nn.relu(layer_2)
out_layer = tf.matmul(layer_2, W_out) + b_out


# In[176]:

# Mean squared error
#cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=out_layer, labels=y))
cost = tf.reduce_mean(tf.pow(out_layer-y, 2))/(2*n_samples)
#cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=out_layer, labels=y))
# Gradient descent
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)


# In[177]:

# Initializing the variables
init = tf.global_variables_initializer()


# In[181]:
initialval = 0
finalval = 100
batchcount = int(n_samples/100)
remainder = n_samples%100
print(remainder)

if remainder!=0:
    batchcount = batchcount +1

# Launch the graph
with tf.Session() as sess:
    sess.run(init)

    # Fit all training data
    for epoch in range(training_epochs):
        avg_cost = 0.
        for batchIdx in range(batchcount):
            if remainder != 0 and batchIdx==batchcount-1:
                finalval = finalval-(100-remainder)
            subtrainx = trainx[initialval:finalval]
            subtrainy = trainy[initialval:finalval]
            _, c = sess.run([optimizer, cost], feed_dict={x: subtrainx,y: subtrainy})
            initialval = initialval+100
            finalval = finalval+100

            avg_cost += c/batchcount

        # Display logs per epoch step
        if epoch % display_step == 0:
            print("Epoch:", '%04d' % (epoch+1), "cost=", \
                "{:.9f}".format(avg_cost))

    #print("Optimization Finished!")
    #training_cost = sess.run(cost, feed_dict={x: trainx,y: trainy})
    #print(training_cost)

    best = sess.run([out_layer], feed_dict={x: np.array([[14.96,41.76,1024.07]])})
    print(best)

我的神经网络架构如下： 1）输入节点（n_inputs）和输出（n_classes）节点的数量分别为3和2 2）截至目前，我正在考虑两个隐藏层，每个层有20个节点

我需要以下几点提供帮助：

1）如何选择参数“training_epoch”; “learning_rate”; “batch_size”在这里，以便我可以获得更好的准确度？

2）我仍然不确定神经网络的架构。建议使用多少个隐藏层？还有，每个隐藏层中的节点数量？

3）如果假设，在我的数据中，我想使用前两列作为输入，接下来的三列作为输出，那么我可以做出哪些更改？我是否还需要更改完整的架构？

4）另外，我不确定我的成本函数。哪个更好用于更好的准确性？

5）另外，如果我遗漏了一些值得考虑的重要参数，请告诉我！

提前致谢！

Answer 1

您提出的问题非常普遍，如果能够找到对这些问题的通用答案，那么数据科学家将不复存在，因为机器学习系统构建过程将会自动化。

1,2,4。学习率和时代数相应地：“越少越好”和“越多越好”。然而，在实践中，你还需要你的机器在宇宙热死之前完成教育。

通常，您会查看错误函数的值，该函数是您在其上训练的数据集上的网络分数。起初，网络正在从数据中学习，每个时代的得分都会变得更好。过了一会儿，网络会从数据集中学到所有可能，并且分数会停止改善。在此之后，没有必要继续下去。如果错误足够小，您也可以提前退出。

学习率也可以根据误差的演变来选择。速率越高，网络完成学习的速度就越快，但如果网络太高，网络可能会超出参数的最佳值，随着时间的推移越来越差。因此，您需要在学习速度和准确性之间找到折衷方案。随着纪元计数器的增加，降低学习率并不罕见。

您还使用了“准确度”一词，但您需要首先根据问题定义它的含义。（实际上，它与成本函数密切相关。）您所描述的问题属于线性\非线性回归类（与逻辑回归相反），对于这些问题，均方误差（在代码中使用）是惯用的。那些交叉熵标准通常更适合分类问题。如果您对数据有一些领域专业知识，那么您当然可以为您的网络设计专门的成本函数。

关于网络的最佳结构没有单一的答案。它的复杂性取决于您尝试近似的功能。如果输入和输出数据之间的连接是线性的，那么除了单个神经元之外，您不需要任何其他东西。通常，决定网络结构的任务本身就是优化问题。因此，您首先将一些测试数据与答案分开，然后在剩余数据上训练您的网络，然后查看它对测试数据的执行情况，这是以前没有见过的。您测试网络，修改它，训练它并再次测试。根据网络在训练和测试集上的表现，您可以决定如何改变它。

3。您需要更改输入和输出的数量。你必须重新训练网络。

此外，互联网上的许多课程都涵盖了这些以及更多基本问题，请考虑采取这些问题。其中一门课程可以找到here。

为回归数据设计高效的神经网络

1 个答案: