Breaking News: Grepper is joining You.com. Read the official announcement!

deep learning in tensorflow

Innocent Iguana answered on November 2, 2021 Popularity 9/10 Helpfulness 4/10

answer deep learning in tensorflow

related what is tensor in deep learning

deep learning in tensorflow

Comment

### Using Tensorflow for regression
import tensorflow as tf
# Define the intercept and slope
intercept = tf.Variable(0.1, np.float32)  # Initial guess, it will be the target of optimization
slope = tf.Variable(0.1, np.float32) # Initial guess, it will be the target of optimization
opt = tf.keras.optimizers.Adam(learning_rate=0.01) # Optimizer algorithm that reduces loss function
# Define a linear regression model
def linear_regression(intercept, slope, features = X):
    return intercept + features*slope # y' = m*X + c
# Compute the predicted values and loss
def loss_function(intercept, slope, targets, features): 
    predictions = linear_regression(intercept, slope)  # y' = m*X + c
    return tf.keras.losses.mse(targets, predictions) # the error between y and y' 
for j in range(1000):       # Do for 1000 iterations (Can be considered epochs)
    for batch in pd.read_csv('dataset.csv', chunksize=100): # Load the data in batches
        y = np.array(batch['target'], np.float32) 
        X = np.array(batch['feature'], np.float32)
        opt.minimize(lambda: loss_function(intercept, slope, y, X), var_list=[intercept, slope]) # Run optimization algorithm to minimize loss function
        print(loss_function(intercept, slope)) # Verbose that will print reduced error after each iteration
print(intercept.numpy(), slope.numpy())  # Print the trained parameters

### Note: the opt.minimize() code can also be broken as
# with tf.GradientTape() as tape:
        # loss = loss_function(intercept, slope, price_batch, size_batch)
    # 
    # gradients = tape.gradient(loss, [intercept, slope])
    # opt.apply_gradients(zip(gradients, [intercept, slope]))

### Using tensorflow for simple example of deep learning
features = tf.Variable(tf.random.normal([50, 10])) # A dataset with 50 rows and 10 columns
weights = tf.Variable(tf.random.normal([10, 30])) # weights should be in shape so that can be matrix multiplied (format = col X choice) 10 inout neuron comes to your choice of hidden layer neurons
bias = tf.Variable(tf.zeros([30]))  # The bias should have same number of rows as the column of matrix multiplication of features and weights
opt = tf.keras.optimizers.RMSprop(learning_rate=0.01, momentum=0.9) # Optimizer algorithm that reduces loss function

def model(bias, weights, features ):
    product = tf.matmul(features, weights)
    return tf.keras.activations.sigmoid(product+bias) # Forward propagation with activation function that returns y'

def loss_function(bias, weights, targets, features):
    predictions = model(bias, weights) # Calculating y'
    return tf.keras.losses.binary_crossentropy(targets, predictions) # Calculating error between y and y'

for j in range(1000):       # Do for 1000 iterations (Can be considered epochs)
    for batch in pd.read_csv('dataset.csv', chunksize=100): # Load the data in batches
        y = np.array(batch['target'], np.float32) 
        X = np.array(batch['feature'], np.float32)
        opt.minimize(lambda: loss_function(bias, weights), var_list=[bias, weights]) # Run optimization algorithm to minimize loss function
        print(loss_function(intercept, slope)) # Verbose that will print reduced error after each iteration
print(intercept.numpy(), slope.numpy())  # Print the trained parameters

### Example of creating multiple Dense layers sequentially
features = np.array([[2., 2., 43.]], dtype=np.float32) # should be constants, also: tf.constant(features). This is the inputs
bias1 = tf.Variable(1.0) # Initialize bias1, should have same number of rows as feature cols, can also be used by: tf.Variable(tf.ones([cols]))
weights1 = tf.ones((3, 2)) # Initialize weights1 as 3x2 variable of ones (incoming 3 columns as input neurons, hidden layer 2 neurons)
product1 = tf.matmul(features, weights1) # Perform matrix multiplication of borrower_features and weights1
dense1 = tf.keras.activations.sigmoid(product1 + bias1) # Apply sigmoid activation function to product1 + bias1
print("\n dense1's output shape: {}".format(dense1.shape)) # Print shape of dense1
bias2 = tf.Variable(1.0)  # Initialize bias2
weights2 = tf.ones((2, 1)) # Initialize weights2 as 2x1 variable of ones (previous layer 2 neurons, final layer 1 neuron)
product2 = tf.matmul(dense1,weights2)  # Perform matrix multiplication of dense1 and weights2
prediction = tf.keras.activations.sigmoid(product2 + bias2) # Apply activation to product2 + bias2 and print the prediction
print('\n prediction: {}'.format(prediction.numpy()[0,0]))
print('\n actual: 1')
# Print error for first five examples
actual = df["target"].values
error = actual[:5] - prediction.numpy()[:5]

## NOTE: Also see CUSTOM TENSORFLOW MODEL and TENSORFLOW BASICS

Popularity 9/10 Helpfulness 4/10 Language python

Source: Grepper

Tags: deep-learning python tensorflow

Link to this answer
Share Copy Link

Contributed on Apr 25 2024

Innocent Iguana

0 Answers Avg Quality 2/10

Closely Related Answers

what is tensor in deep learning

Comment

tensor is multidimensional array

Popularity 9/10 Helpfulness 3/10 Language python

Source: Grepper

Tags: deep-learning de

Link to this answer
Share Copy Link

Contributed on Nov 02 2021

coder

0 Answers Avg Quality 2/10

deep learning in tensorflow

Contents

More Related Answers

deep learning in tensorflow

Closely Related Answers

what is tensor in deep learning

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.