python artificial intelligence tensorflow common loss function LOSS summary

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

loss = .sigmoid_cross_entropy_with_logits(labels=y,logits=logits)
# Calculation: for the input logits first through the sigmoid function, then calculate their cross-entropy
# But it optimizes the calculation of cross-entropy in a way that keeps the results from overflowing.
loss = .softmax_cross_entropy_with_logits(labels=y,logits=logits)
# Calculation: for the input logits first by softmax function, and then calculate their cross entropy.
# But it optimizes the calculation of cross-entropy in a way that keeps the results from overflowing.

import numpy as np
import tensorflow as tf
x_data = (100).astype(np.float32) # Getting random x-values
y_data = x_data * 0.1 + 0.3                     # Calculate the corresponding y-value
Weights = (tf.random_uniform([1],-1.0,1.0))  #random_uniform returns a matrix of size [m,n], generated between low and high, which produces uniformly distributed values.
Biaxs = (([1]))                      # Generate 0
y = Weights*x_data + Biaxs      
loss = .mean_squared_error(y_data,y)              #Calculate the squared difference
#loss = tf.reduce_mean((y_data-y))
#loss = tf.reduce_mean(((y_data,y)))
optimizer = (0.6)      #Gradient descent
train = (loss)
init = tf.initialize_all_variables()
sess = ()
(init)
for i in range(200):
    (train)
    if i % 20 == 0:
        print((Weights),(Biaxs))

import tensorflow as tf 
import numpy as np
from  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.random_normal([in_size,out_size]),name = "Weights")
            (layer_name+"/weights",Weights)
        with tf.name_scope("biases"):
            biases = (([1,out_size]) + 0.1,name = "biases")
            (layer_name+"/biases",biases)
        with tf.name_scope("Wx_plus_b"):
            Wx_plus_b = (inputs,Weights) + biases
            (layer_name+"/Wx_plus_b",Wx_plus_b)
        if activation_function == None :
            outputs = Wx_plus_b 
        else:
            outputs = activation_function(Wx_plus_b)
        (layer_name+"/outputs",outputs)
        return outputs
def compute_accuracy(x_data,y_data):
    global prediction
    y_pre = (prediction,feed_dict={xs:x_data})
    correct_prediction = (tf.arg_max(y_data,1),tf.arg_max(y_pre,1))     #Determine if they are equal
    accuracy = tf.reduce_mean((correct_prediction,tf.float32))   # Assign float32 data type to average.
    result = (accuracy,feed_dict = {xs:batch_xs,ys:batch_ys})   #Execute
    return result
xs = (tf.float32,[None,784])
ys = (tf.float32,[None,10])
layer1 = add_layer(xs,784,150,"layer1",activation_function = )
prediction = add_layer(layer1,150,10,"layer2")
# Since the loss function automatically performs softmax or sigmoid function operations, no special excitation function is needed.
with tf.name_scope("loss"):
    loss = tf.reduce_mean(.softmax_cross_entropy_with_logits(labels=ys,logits = prediction),name = 'loss')
    #loss = tf.reduce_mean(.sigmoid_cross_entropy_with_logits(labels=ys,logits = prediction),name = 'loss')
    #label is the label, logits are the predicted values, and cross-entropy.
    ("loss",loss)
train = (4e-3).minimize(loss)
init = tf.initialize_all_variables()
merged = .merge_all()
with () as sess:
    (init)
    write = ("logs/",)
    for i in range(5001):
        batch_xs,batch_ys = .next_batch(100)
        (train,feed_dict = {xs:batch_xs,ys:batch_ys})
        if i % 1000 == 0:
            print("The recognition rate for training %d times is: %f."%((i+1),compute_accuracy(,)))
            result = (merged,feed_dict={xs:batch_xs,ys:batch_ys})
            write.add_summary(result,i)