Karlheinzniebuhr · June 8, 2017 13:28
diff --git a/linear_regression.py b/linear_regression.py
 # How to Do Linear Regression using Gradient Descent

 # import Numpy, THE matrix multiplication library for python
 from numpy import *

 # minimize the "sum of squared errors". This is how we calculate and correct our error
 def compute_error_for_line_given_points(b, m, points):
    totalError = 0
    for i in range(0, len(points)):
        x = points[i, 0]
        y = points[i, 1]
        totalError += (y - (m * x + b)) **2
    return totalError / float(len(points))


 def step_gradient(b_current, m_current, points, learning_rate):
    # gradient descent
    b_gradient = 0
    m_gradient = 0
    N = float(len(points))
    for i in range(0, len(points)):
        x = points[i, 0]
        y = points[i, 1]

        # direction with respecto to b and m
        # computing partial derivatives of our error function
        b_gradient += -(2/N) * (y - ((m_current * x) + b_current))
        m_gradient += -(2/N) * x * (y - ((m_current * x) + b_current))
    new_b = b_current - (learning_rate * b_gradient)
    new_m = m_current - (learning_rate * m_gradient)
    return [new_m, new_m]

 def gradient_descent_runner(points, starting_b, starting_m, learning_rate, num_iterations):
    b = starting_b
    m = starting_m

    for i in range(num_iterations):
        b, m = step_gradient(b, m, array(points), learning_rate)
    return [b, m]

 def run():
    # Step 1 - Collect our data
    points = genfromtxt("data.csv", delimiter=",")

    # Step 2 - Define our hyperparameters.
    # The learning rate defines how fast our model learns (converges).
    learning_rate = 0.0001
    # y = mx + b (slope formula)
    initial_b = 0
    initial_m = 0
    num_iterations = 1000 # it depends on the dimensions of the dataset

    # step 3 - train our model
    print("Starting gradient descent at b = {0}, m = {1}, error = {2}".format(initial_b, initial_m, compute_error_for_line_given_points(initial_b, initial_m, points)))
    print("Running...")
    [b, m] = gradient_descent_runner(points, initial_b, initial_m, learning_rate, num_iterations)
    print("After {0} iterations b = {1}, m = {2}, error = {3}".format(num_iterations, b, m, compute_error_for_line_given_points(b, m, points)))


 if __name__ == '__main__':
    run()
	# How to Do Linear Regression using Gradient Descent

	# import Numpy, THE matrix multiplication library for python
	from numpy import *

	# minimize the "sum of squared errors". This is how we calculate and correct our error
	def compute_error_for_line_given_points(b, m, points):
	totalError = 0
	for i in range(0, len(points)):
	x = points[i, 0]
	y = points[i, 1]
	totalError += (y - (m * x + b)) **2
	return totalError / float(len(points))


	def step_gradient(b_current, m_current, points, learning_rate):
	# gradient descent
	b_gradient = 0
	m_gradient = 0
	N = float(len(points))
	for i in range(0, len(points)):
	x = points[i, 0]
	y = points[i, 1]

	# direction with respecto to b and m
	# computing partial derivatives of our error function
	b_gradient += -(2/N) * (y - ((m_current * x) + b_current))
	m_gradient += -(2/N) * x * (y - ((m_current * x) + b_current))
	new_b = b_current - (learning_rate * b_gradient)
	new_m = m_current - (learning_rate * m_gradient)
	return [new_m, new_m]

	def gradient_descent_runner(points, starting_b, starting_m, learning_rate, num_iterations):
	b = starting_b
	m = starting_m

	for i in range(num_iterations):
	b, m = step_gradient(b, m, array(points), learning_rate)
	return [b, m]

	def run():
	# Step 1 - Collect our data
	points = genfromtxt("data.csv", delimiter=",")

	# Step 2 - Define our hyperparameters.
	# The learning rate defines how fast our model learns (converges).
	learning_rate = 0.0001
	# y = mx + b (slope formula)
	initial_b = 0
	initial_m = 0
	num_iterations = 1000 # it depends on the dimensions of the dataset

	# step 3 - train our model
	print("Starting gradient descent at b = {0}, m = {1}, error = {2}".format(initial_b, initial_m, compute_error_for_line_given_points(initial_b, initial_m, points)))
	print("Running...")
	[b, m] = gradient_descent_runner(points, initial_b, initial_m, learning_rate, num_iterations)
	print("After {0} iterations b = {1}, m = {2}, error = {3}".format(num_iterations, b, m, compute_error_for_line_given_points(b, m, points)))


	if __name__ == '__main__':
	run()