running simple regression in base tensorflow 2.0

# Use seaborn
for pairplot.
pip install - q seaborn

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns

# Make NumPy printouts easier to read.
np.set_printoptions(precision = 3, suppress = True)

import tensorflow as tf

from tensorflow
import keras
from tensorflow.keras
import layers

print(tf.__version__)

url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data'
column_names = ['MPG', 'Cylinders', 'Displacement', 'Horsepower', 'Weight',
   'Acceleration', 'Model Year', 'Origin'
]

raw_dataset = pd.read_csv(url, names = column_names,
   na_values = '?', comment = '\t',
   sep = ' ', skipinitialspace = True)

dataset = raw_dataset.copy()
dataset.tail()

import tensorflow as tf # 2.0 .0 - alpha0
import numpy as np

x_data = np.random.randn(5, 2)

w_real = 0.7 # coefficients
b_real = -0.2 # global bias
noise = np.random.randn(5, 2) * 0.01 # level of noise
y_data = w_real * x_data + b_real + noise

class SimpleRegressionNN(tf.keras.Model):

   def __init__(self):
   super(SimpleRegressionNN, self).__init__()

self.output_layer = tf.keras.layers.Dense(1, input_shape = (2, ))

def call(self, data_input):
   result = self.output_layer(data_input)
return result

reg_loss = tf.keras.losses.MeanSquaredError()
reg_optimiser = tf.keras.optimizers.SGD(0.1)

nn_regressor = SimpleRegressionNN()

@tf.function
def train_step(x_sample, y_sample):
   with tf.GradientTape() as tape:
   predictions = nn_regressor(x_sample)
loss = reg_loss(y_sample, predictions)
gradients = tape.gradient(loss, nn_regressor.trainable_variables) # had to indent this!
   reg_optimiser.apply_gradients(zip(gradients, nn_regressor.trainable_variables))

return loss

for x_point, y_point in zip(x_data, y_data): # batch of 1
x_point, y_point = tf.convert_to_tensor([x_point]), tf.convert_to_tensor([y_point])
mse = train_step(x_sample = x_point, y_sample = y_point)
print("MSE: {}".format(mse.numpy()))

import tensorflow as tf # 2.0 .0 - alpha0
import numpy as np

x_data = np.random.randn(2000, 1)

w_real = [0.7] # coefficients
b_real = -0.2 # global bias
noise = np.random.randn(1, 2000) * 0.5 # level of noise
y_data = np.matmul(w_real, x_data.T) + b_real + noise

# modelling this data with tensorflow(manually!)
class SimpleRegressionNN(tf.keras.Model):

   def __init__(self):
   super(SimpleRegressionNN, self).__init__()
self.input_layer = tf.keras.layers.Input
self.output_layer = tf.keras.layers.Dense(1)

def call(self, data_input):
   model = self.input_layer(data_input)
model = self.output_layer(model)
# open question: how to account
for the intercept / bias term ?
   # Ideally, we 'd want to generate preds as matmult(X,W) + b
return model

nn_regressor = SimpleRegressionNN()

reg_loss = tf.keras.losses.MeanSquaredError()
reg_optimiser = tf.keras.optimizers.SGD(0.1)
metric_accuracy = tf.keras.metrics.mean_squared_error

# define forward step
@tf.function
def train_step(x_sample, y_sample):
   with tf.GradientTape() as tape:
   predictions = nn_regressor(x_sample)
loss = reg_loss(y_sample, predictions)
gradients = tape.gradient(loss, nn_regressor.trainable_variables) # had to indent this!
   reg_optimiser.apply_gradients(zip(gradients, nn_regressor.trainable_variables))
metric_accuracy(y_sample, predictions)

# % %
   # run the model
for epoch in range(10):
   for x_point, y_point in zip(x_data.T[0], y_data[0]): # batch of 1
train_step(x_sample = x_point, y_sample = y_point)
print("MSE: {}".format(metric_accuracy.result()))

TypeError: You are attempting to use Python control flow in a layer that was not declared to be dynamic.Pass `dynamic=True`
to the class constructor.
Encountered error:
   ""
"
Tensor objects are only iterable when eager execution is enabled.To iterate over this tensor use tf.map_fn.
""
"

import tensorflow as tf # 2.0 .0 - alpha0
import numpy as np

x_data = np.random.randn(5, 2)

w_real = 0.7 # coefficients
b_real = -0.2 # global bias
noise = np.random.randn(5, 2) * 0.01 # level of noise
y_data = w_real * x_data + b_real + noise

class SimpleRegressionNN(tf.keras.Model):

   def __init__(self):
   super(SimpleRegressionNN, self).__init__()

self.output_layer = tf.keras.layers.Dense(1, input_shape = (2, ))

def call(self, data_input):
   result = self.output_layer(data_input)
return result

reg_loss = tf.keras.losses.MeanSquaredError()
reg_optimiser = tf.keras.optimizers.SGD(0.1)

nn_regressor = SimpleRegressionNN()

@tf.function
def train_step(x_sample, y_sample):
   with tf.GradientTape() as tape:
   predictions = nn_regressor(x_sample)
loss = reg_loss(y_sample, predictions)
gradients = tape.gradient(loss, nn_regressor.trainable_variables) # had to indent this!
   reg_optimiser.apply_gradients(zip(gradients, nn_regressor.trainable_variables))

return loss

for x_point, y_point in zip(x_data, y_data): # batch of 1
x_point, y_point = tf.convert_to_tensor([x_point]), tf.convert_to_tensor([y_point])
mse = train_step(x_sample = x_point, y_sample = y_point)
print("MSE: {}".format(mse.numpy()))

...
# set up variable
for weights
w0 = tf.Variable(0.0, name = "w0")
w1 = tf.Variable(0.0, name = "w1")
   ...
   # Define the operation that will be called on each iteration
train_op = tf.train.GradientDescentOptimizer(learning_rate).minimize(costF)
# set up a session
sess = tf.Session()
# initialize all variables
init = tf.global_variables_initializer()
# execute the session
sess.run(init)
# Loop through the data training
for epoch in range(training_epochs):
   for (x, y) in zip(x_train, y_train):
      # execute the session
sess.run(train_op, feed_dict = {
   X: x,
   Y: y
})
# get values of the final weights by executing the session
w_val_0 = sess.run(w0)
w_val_1 = sess.run(w1)

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

learning_rate = 0.01

# steps of looping through all your data to update the parameters
training_epochs = 100

# the training set
x_train = np.linspace(0, 10, 100)
y_train = x_train + np.random.normal(0, 1, 100)

w0 = tf.Variable(0.)
w1 = tf.Variable(0.)

def h(x):
   y = w1 * x + w0
return y

def squared_error(y_pred, y_true):
   return tf.reduce_mean(tf.square(y_pred - y_true))

# train model
for epoch in range(training_epochs):
   with tf.GradientTape() as tape:
   y_predicted = h(x_train)
costF = squared_error(y_predicted, y_train)
# get gradients
gradients = tape.gradient(costF, [w1, w0])
# compute and adjust weights
w1.assign_sub(gradients[0] * learning_rate)
w0.assign_sub(gradients[1] * learning_rate)

plt.scatter(x_train, y_train)
# plot the best fit line
plt.plot(x_train, h(x_train), 'r')
plt.show()

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

learning_rate = 0.05
training_epochs = 100

#the traning set
x_train = np.linspace(-1, 1, 101)
# Set up raw output data based on a degree 5 polynomial
num_coeffs = 6
trY_coeffs = [1, 2, 3, 4, 5, 6]
y_train = 0
for i in range(num_coeffs):
   y_train += trY_coeffs[i] * np.power(x_train, i)
# Add some noise
y_train += np.random.randn( * x_train.shape) * 1.5

# Set up the weight vector to all zeros
w = tf.Variable([0.] * num_coeffs, name = "parameters")

# our model
function
def h(x):
   # h(x) = w5 * x * x * x * x * x + w4 * x * x * x * x + w3 * x * x * x + w2 * x * x + w1 * x + w0
y = 0
for i in range(num_coeffs):
   y += w[i] * pow(x, i)
return y

# cost
function
def squared_error(y_pred, y_true):
   return tf.reduce_mean(tf.square(y_pred - y_true))

# train model
for epoch in range(training_epochs):
   with tf.GradientTape() as tape:
   y_predicted = h(x_train)
costF = squared_error(y_predicted, y_train)
# get gradients
gradients = tape.gradient(costF, w)
# compute and adjust weights
w.assign_sub(gradients * learning_rate)

plt.scatter(x_train, y_train)
# plot the best fit line
plt.plot(x_train, h(x_train), 'r')
plt.show()

#Import required Libraries
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# Define a Linear model
class LinearModel(object):
   def __init__(self):
   self.W = tf.Variable(12.0)
self.b = tf.Variable(-6.1)

def __call__(self, inputs):
   return self.W * inputs + self.b

#Define Loss Function
def compute_loss(y_true, y_pred):
   return tf.reduce_mean(tf.square(y_true - y_pred))

# Define the weight and bias
weight = 2.5
bias = 1.0

# Generate Data
data = 100
inputs = tf.random.normal(shape = [data])
noise = tf.random.normal(shape = [data])
outputs = inputs * weight + bias + noise