TensorFlow is a free and open-source software library for artificial intelligence and machine learning. Although it may be applied to many different tasks, its main focus is deep neural network inference and training. Dataflow graphs—structures that depict how data flows through a graph, or a collection of processing nodes—can be created by developers using TensorFlow. It was developed by Google Brain Team.
What is a tensor?
A tensor is a generalization of vectors and matrices. It can be seen as a collection of numbers which has been arranged into a particular shape. A constant is the simplest category of a tensor.
#Importing the necessary libraries import tensorflow as tf import numpy as np #Zero deimensional Tensor d0 = tf.ones((1,)) #One dimensional Tensor d1 = tf.ones((2,)) #Two dimensional Tensor d2 = tf.ones((2, 2)) #Three dimensional Tensor d3 = tf.ones((2, 2, 2)) #Printing the initialized tensors print(d0.numpy()) print(d1.numpy()) print(d2.numpy()) print(d3.numpy())
Linear Regression In TensorFlow
A machine learning algorithm built on supervised learning is linear regression. It executes a regression operation. Based on independent variables, regression models forecast a target value. It is primarily used to determine how variables and forecasting relate to one another. Below is an example:
import pandas as pd import tensorflow as tf import numpy as np from google.colab import files files.upload() housing = pd.read_csv('/content/kc_house_data.csv', parse_dates = True) housing.head() price = np.array(housing['price'], np.float32) size = np.array(housing['sqft_living'], np.float32) intercept = tf.Variable(0.1, np.float32) slope = tf.Variable(0.1, np.float32) def linear_func(intercept, slope, features = size): return intercept + features*slope def loss_func(intercept, slope, targets=price, features=size): predictions = linear_func(intercept, slope) return tf.keras.losses.mse(targets, predictions) opt = tf.keras.optimizers.Adam() for j in range(1000): opt.minimize(lambda: loss_func(intercept, slope), \ var_list = [intercept, slope]) print(loss_func(intercept, slope)) print(intercept.numpy(), slope.numpy())
Neural Networks In Tensorflow
Deep learning techniques are built around neural networks, which are a subset of machine learning. In order to mirror the way that organic neurons communicate with one another, their name and structure are both modeled after the human brain. They consist of node levels, with each layer having an input, one or more hidden layers, and an output layer. Below is an example of how neural networks are implemented with Tensorflow:
#Importing the needed libraries import tensorflow as tf from tensorflow import keras import numpy as np import matplotlib.pyplot as plt %matplotlib inline #Splitting dataset into train and test set (X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data() #Checking length of X_train len(X_train) #Checking length of X_test len(X_test) #Checking the shape of the first X train input X_train.shape #Showing the first X input plt.matshow(X_train) #Normalizing the data X_train = X_train/255 X_test = X_test/255 #Flattening the dataset X_train_flattened = X_train.reshape(len(X_train), 28*28) X_test_flattened = X_test.reshape(len(X_test), 28*28) #Displaying the flattened shape X_train_flattened.shape #Creating the neural network model = keras.Sequential([ keras.layers.Dense(10, input_shape=(784,), activation='sigmoid') ]) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit(X_train_flattened, y_train, epochs=5) #Evaluating the model model.evaluate(X_test_flattened, y_test)
loss: 0.2726 - accuracy: 0.9241
Deep learning is a subset of machine learning that uses artificial neural networks as its foundation. It uses numerous layers of processing to gradually extract higher-level features from data. It is a method of teaching computers to learn by doing what comes easily to people: by observation. Driverless cars use deep learning as a vital technology to detect a stop sign or tell a pedestrian from a lamppost.
Deep learning usually deals with deep neural network. Deep neural network (DNN), often known as a "deep net," is a neural network that has some degree of complexity, typically at least two layers. Deep neural networks use advanced mathematical modeling to analyze data in complex ways.
Some types of algorithms used in deep learning include:
Convolutional Neural Networks (CNN)
Long Short Term Memory Networks (LSTMs)
Recurrent Neural Networks (RNNs)
Generative Adversarial Networks (GANs)
Radial Basis Function Networks (RBFNs)
Multilayer Perceptron (MLPs)
Self Organizing Maps (SOMs)
Deep Belief Networks (DBNs)
Restricted Boltzmann Machines (RBMs)
Below is a deep neural sequential network made from TensorFlow Keras:
#Importing needed libraries from tensorflow import keras #Creating a deep neural network with 2 hidden layers ann = keras.Sequential([ keras.layers.Flatten(input_shape=(32,32,3)), keras.layers.Dense(3000, activation='relu'), keras.layers.Dense(1000, activation='relu'), keras.layers.Dense(10, activation='softmax') ])
<keras.engine.sequential.Sequential at 0x7f2f1116f8e0>
The output above shows a deep neural network has been made.
GitHub Link with Jupyter Notebook: