Python3.7 線性迴歸

# -*- coding: UTF-8 -*-
import tensorflow as tf
import numpy as np
import os
import matplotlib.pyplot as plt
import time
os.environ['TF_CPP_MIN_LOG_LEVEL']='1'

print ("GPU",tf.test.is_gpu_available())

a=tf.constant(2.)
b=tf.constant(4.)

print (a*b)

def comput_error_for_line_given_points(b,w,points):
    total_error=0
    for i in range(0,len(points[0])):
        x=points[0][i]
        y=points[1][i]

        total_error+= ((w*x+b)-y)**2

    return total_error/float(len(points))


def step_gradient(b_current,w_current,points,learningRate):
    b_gradient=0
    w_gradient=0
    N=float(len(points[0]))

    for i in range(0,len(points[0])):
        x=points[0][i]
        y=points[1][i]
        b_gradient+=(2/N)*((w_current*x+b_current)-y)
        w_gradient+=(2/N)*x*((w_current*x+b_current)-y)
    new_b=b_current-(learningRate*b_gradient)
    new_w=w_current-(learningRate*w_gradient)
    return [new_b,new_w]
def gradient_descent_runner(points,starting_b,starting_w,learning_rate,num_iterations):
    b=starting_b
    w=starting_w
    for i in range(num_iterations):
        b,w=step_gradient(b,w,np.array(points),learning_rate)
    return [b,w]

def gradient_value(b,w,X):
    Y=w*X+b
    return Y
def display_vaule(points):
    for i in range(0,len(points[0])):
        x=points[0][i]
        y=points[1][i]
        print ("x = {},y = {}".format(x,y))
    
num_iterations=2500

x = 4* np.random.rand(num_iterations, 1)
#y = 4 + 3 * x + 4*np.random.rand(num_iterations, 1)
y = 4 + 3 * x + np.random.randn(num_iterations, 1)

points=[x,y]

#display_vaule(points)


learning_rate=0.0001
initial_b=0
initial_w=0

error_value=comput_error_for_line_given_points(initial_b,initial_w,points)
print ("Starting gradient at b={},w={},error={}\n".format(initial_b,initial_w,error_value))
t1=time.process_time()
print ("running......\n")
[b,w]=gradient_descent_runner(points,initial_b,initial_w,learning_rate,num_iterations)
error_value=comput_error_for_line_given_points(b,w,points)
print ("After gradient at iterations={},b={},w={},error={}\n".format(num_iterations,b,w,error_value))
t2=time.process_time()
print ("time --> %ds"% (t2-t1))
X=5
value=gradient_value(b,w,X)

print ("if X={},gradient Y={}".format(X,value))
X_new = np.array([[0], [4]])
y_predict = gradient_value(b,w,X_new)

plt.plot(X_new, y_predict, 'r-')
plt.plot(x, y, 'g.')
plt.axis([0, 4, 0, 18])
plt.show()

說明：tensorflow2.0