python人工智能tensorflow常见损失函数LOSS汇总

loss = tf.reduce_mean(tf.square(logits-labels))
loss = tf.reduce_mean(tf.square(tf.sub(logits, labels)))
loss = tf.losses.mean_squared_error(logits,labels)

loss = tf.nn.sigmoid_cross_entropy_with_logits(labels=y,logits=logits)
#计算方式：对输入的logits先通过sigmoid函数计算，再计算它们的交叉熵
#但是它对交叉熵的计算方式进行了优化，使得结果不至于溢出。
loss = tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=logits)
#计算方式：对输入的logits先通过softmax函数计算，再计算它们的交叉熵，
#但是它对交叉熵的计算方式进行了优化，使得结果不至于溢出。

import numpy as np
import tensorflow as tf
x_data = np.random.rand(100).astype(np.float32) #获取随机X值
y_data = x_data * 0.1 + 0.3                     #计算对应y值
Weights = tf.Variable(tf.random_uniform([1],-1.0,1.0))  #random_uniform返回[m,n]大小的矩阵，产生于low和high之间，产生的值是均匀分布的。
Biaxs = tf.Variable(tf.zeros([1]))                      #生成0
y = Weights*x_data + Biaxs      
loss = tf.losses.mean_squared_error(y_data,y)              #计算平方差
#loss = tf.reduce_mean(tf.square(y_data-y))
#loss = tf.reduce_mean(tf.square(tf.sub(y_data,y)))
optimizer = tf.train.GradientDescentOptimizer(0.6)      #梯度下降法
train = optimizer.minimize(loss)
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
for i in range(200):
    sess.run(train)
    if i % 20 == 0:
        print(sess.run(Weights),sess.run(Biaxs))

import tensorflow as tf 
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets(\"MNIST_data\",one_hot = \"true\")
def add_layer(inputs,in_size,out_size,n_layer,activation_function = None):
    layer_name = \'layer%s\'%n_layer
    with tf.name_scope(layer_name):
        with tf.name_scope(\"Weights\"):
            Weights = tf.Variable(tf.random_normal([in_size,out_size]),name = \"Weights\")
            tf.summary.histogram(layer_name+\"/weights\",Weights)
        with tf.name_scope(\"biases\"):
            biases = tf.Variable(tf.zeros([1,out_size]) + 0.1,name = \"biases\")
            tf.summary.histogram(layer_name+\"/biases\",biases)
        with tf.name_scope(\"Wx_plus_b\"):
            Wx_plus_b = tf.matmul(inputs,Weights) + biases
            tf.summary.histogram(layer_name+\"/Wx_plus_b\",Wx_plus_b)
        if activation_function == None :
            outputs = Wx_plus_b 
        else:
            outputs = activation_function(Wx_plus_b)
        tf.summary.histogram(layer_name+\"/outputs\",outputs)
        return outputs
def compute_accuracy(x_data,y_data):
    global prediction
    y_pre = sess.run(prediction,feed_dict={xs:x_data})
    correct_prediction = tf.equal(tf.arg_max(y_data,1),tf.arg_max(y_pre,1))     #判断是否相等
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))   #赋予float32数据类型，求平均。
    result = sess.run(accuracy,feed_dict = {xs:batch_xs,ys:batch_ys})   #执行
    return result
xs = tf.placeholder(tf.float32,[None,784])
ys = tf.placeholder(tf.float32,[None,10])
layer1 = add_layer(xs,784,150,\"layer1\",activation_function = tf.nn.tanh)
prediction = add_layer(layer1,150,10,\"layer2\")
#由于loss函数在运算的时候会自动进行softmax或者sigmoid函数的运算，所以不需要特殊激励函数。
with tf.name_scope(\"loss\"):
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=ys,logits = prediction),name = \'loss\')
    #loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=ys,logits = prediction),name = \'loss\')
    #label是标签，logits是预测值，交叉熵。
    tf.summary.scalar(\"loss\",loss)
train = tf.train.AdamOptimizer(4e-3).minimize(loss)
init = tf.initialize_all_variables()
merged = tf.summary.merge_all()
with tf.Session() as sess:
    sess.run(init)
    write = tf.summary.FileWriter(\"logs/\",sess.graph)
    for i in range(5001):
        batch_xs,batch_ys = mnist.train.next_batch(100)
        sess.run(train,feed_dict = {xs:batch_xs,ys:batch_ys})
        if i % 1000 == 0:
            print(\"训练%d次的识别率为：%f。\"%((i+1),compute_accuracy(mnist.test.images,mnist.test.labels)))
            result = sess.run(merged,feed_dict={xs:batch_xs,ys:batch_ys})
            write.add_summary(result,i)