用tensorflow模式编写前馈神经网络，数据集是Mnist数据集。具体任务： 在相同结构的神经网络下，比较两种初始化参数方法（参数方差设为0.1和Xavier初始化）的实验效果，最后选择一种最好的初始化参数的方法

好的，首先针对你的问题，对于使用tensorflow编写前馈神经网络，需要先定义模型的结构，然后通过不同的参数进行训练以及优化参数。对于数据集Mnist，可以将其下载到本地中，并进行预处理以保证模型的训练效果。

接下来是对于初始化参数方法的比较。一般而言，参数初始化方案对于神经网络的性能改善是有非常大的作用的。在这里，我们将比较参数方差设置为0.1和Xavier初始化两种方法。对于参数方差为0.1的实验，我们需要对网络中的每一个参数都随机生成一个接近0的数，并用0.1作为参数方差进行初始化。对于Xavier初始化，则需要根据每个神经元的输入和输出进行权重初始化。这种方法可以有效地保证网络在训练时能够快速地收敛，并且避免了梯度爆炸或梯度消失问题的出现。

用tensorflow编写前馈神经网络需要先导入库文件：

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)

接着，可以定义网络的结构：

#定义每一层的参数
n_input = 784 # 输入的图像大小是28 * 28
n_hidden_1 = 256 # 第一层隐藏层的神经元个数
n_hidden_2 = 256 # 第二层隐藏层的神经元个数
n_classes = 10 # MNIST一共有10个类别

# 定义所需的输入占位符
x = tf.placeholder(tf.float32, [None, n_input])
y = tf.placeholder(tf.float32, [None, n_classes])

# 定义每一层的权重和偏置
weights = {
    'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1], stddev=0.1)),
    'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2], stddev=0.1)),
    'out': tf.Variable(tf.random_normal([n_hidden_2, n_classes], stddev=0.1))
}
biases = {
    'b1': tf.Variable(tf.random_normal([n_hidden_1])),
    'b2': tf.Variable(tf.random_normal([n_hidden_2])),
    'out': tf.Variable(tf.random_normal([n_classes]))
}

接下来便可以定义模型训练的流程：

# 接下来构建模型，并通过反向传播算法优化参数
def multi_layer_perceptron(x, weights, biases):

    # 第一层隐藏层
    layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'])
    layer_1 = tf.nn.relu(layer_1)

    # 第二层隐藏层
    layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2'])
    layer_2 = tf.nn.relu(layer_2)

    # 输出层
    out_layer = tf.matmul(layer_2, weights['out']) + biases['out']
    return out_layer

# 训练模型
xavier_var = tf.sqrt(3. / (n_input + n_classes))
weights_xavier = {
    'h1': tf.Variable(tf.random_uniform([n_input, n_hidden_1],
                                         minval=-xavier_var, maxval=xavier_var)),
    'h2': tf.Variable(tf.random_uniform([n_hidden_1, n_hidden_2],
                                         minval=-xavier_var, maxval=xavier_var)),
    'out': tf.Variable(tf.random_uniform([n_hidden_2, n_classes],
                                          minval=-xavier_var, maxval=xavier_var))
}

# 训练时的参数
learning_rate = 0.1 # 学习率
training_epochs = 50 # 训练的轮数
batch_size = 100 # 每个批次的大小

# 定义损失函数和优化器
pred = multi_layer_perceptron(x, weights, biases)
pred_xavier = multi_layer_perceptron(x, weights_xavier, biases)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

# 初始化所有变量
init = tf.global_variables_initializer()

# 启动session开始训练
with tf.Session() as sess:
    sess.run(init)

    # 每个批次的训练
    for epoch in range(training_epochs):
        avg_cost = 0.
        total_batch = int(mnist.train.num_examples / batch_size)

        for i in range(total_batch):
            # 获取一个批次的数据集
            batch_x, batch_y = mnist.train.next_batch(batch_size)

            # 运行优化器
            _, c = sess.run([optimizer, cost], feed_dict={x: batch_x, y: batch_y})

            # 计算平均损失
            avg_cost += c / total_batch

        # 打印训练的中间结果
        if epoch % 10 == 0:
            print("Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost))

    # 比较两种参数初始化方式的效果
    correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    print("Accuracy of Normal random initialization:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

    correct_prediction_xavier = tf.equal(tf.argmax(pred_xavier, 1), tf.argmax(y, 1))
    accuracy_xavier = tf.reduce_mean(tf.cast(correct_prediction_xavier, tf.float32))
    print("Accuracy of Xavier initialization:", accuracy_xavier.eval({x: mnist.test.images, y: mnist.test.labels}))

在训练结束后，我们可以得到两种初始化方式的精度，从而选择表现最优的方法。

希望我的回答对于你有所帮助。