Test Tensor flow with the below python codes at colab.

import tensorflow as tf

from keras.layers import Input, Dense

from keras.models import Model

import matplotlib.pyplot as plt

$2.$ Test Tensor flow with linear regressions

import numpy as np

#Linear Regression with TensorFlow

from sklearn.datasets import fetch$\_$california$\_$housing

housing $=$ fetch$\_$california$\_$housing$()$

m$,$ n $=$ housing.data.shape

housing$\_$data$\_$plus$\_$bias $=$ np$.$c$\_[$np$.$ones$(($m$,1)),$ housing.data$]$

X $=$ tf$.$constant$($housing$\_$data$\_$plus$\_$bias, dtype$=$tf$.$float$32,$ name$="$X$")$

y $=$ tf$.$constant$($housing$.$target.reshape$(-1,1),$ dtype$=$tf$.$float$32,$ name$="$y$")$

XT $=$ tf$.$transpose$($X$)$

theta $=$ tf$.$matmul$($tf$.$matmul$($tf$.$linalg.inv$($tf$.$matmul$($XT$,$ X$)),$ XT$),$ y$)$

print$($theta$)$

$3.$ Test Tensor flow with MNIST $($handwriting$)$ data set

# Plot ad hoc mnist instances

from keras.datasets import mnist

import matplotlib.pyplot as plt

# load $($downloaded if needed$)$ the MNIST dataset

$($X$\_$train, y$\_$train$),($X$\_$test, y$\_$test$)=$ mnist.load$\_$data$()$

# plot $4$ images as gray scale

plt$.$subplot$(221)$

plt$.$imshow$($X$\_$train$[0],$ cmap$=$plt$.$get$\_$cmap$(\text{'}$gray$\text{'}))$

plt$.$subplot$(222)$

plt$.$imshow$($X$\_$train$[1],$ cmap$=$plt$.$get$\_$cmap$(\text{'}$gray$\text{'}))$

plt$.$subplot$(223)$

plt$.$imshow$($X$\_$train$[2],$ cmap$=$plt$.$get$\_$cmap$(\text{'}$gray$\text{'}))$

plt$.$subplot$(224)$

plt$.$imshow$($X$\_$train$[3],$ cmap$=$plt$.$get$\_$cmap$(\text{'}$gray$\text{'}))$

# show the plot

plt$.$show$()$

from keras.datasets import mnist

from keras.models import Sequential

from keras.layers import Dense

from keras.layers import Dropout

from keras.utils import to$\_$categorical

# fix random seed for reproducibility

seed $=7$

np$.$random.seed$($seed$)$

# load data

$($X$\_$train, y$\_$train$),($X$\_$test, y$\_$test$)=$ mnist.load$\_$data$()$

# flatten $28*28$ images to a $784$ vector for each image

num$\_$pixels $=$ X$\_$train.shape$[1]*$ X$\_$train.shape$[2]$

X$\_$train $=$ X$\_$train.reshape$($X$\_$train.shape$[0],$ num$\_$pixels$).$astype$(\text{'}$float$32\text{'})$

X$\_$test $=$ X$\_$test.reshape$($X$\_$test.shape$[0],$ num$\_$pixels$).$astype$(\text{'}$float$32\text{'})$

# normalize inputs from $0-255$ to $0-1$

X$\_$train $=$ X$\_$train $/255$

X$\_$test $=$ X$\_$test $/255$

# one hot encode outputs

y$\_$train $=$ to$\_$categorical$($y$\_$train$)$

y$\_$test $=$ to$\_$categorical$($y$\_$test$)$

num$\_$classes $=$ y$\_$test.shape$[1]$

# define baseline model

def baseline$\_$model$()$:

# reate model

model $=$ Sequential$()$

model.add$($Dense$($num$\_$pixels, input$\_$dim$=$num$\_$pixels, kernel$\_$initializer$=$'normal', activation$=$'relu'$))$

model.add$($Dense$($num$\_$classes, kernel$\_$initializer$=$'normal', activation$=$'softmax'$))$

# Compile model

model $.$ compile$($loss$=$'categorical$\_$crossentropy' $,$ optimizer$=$'adam' $,$ metrics$=[\text{'}$accuracy$\text{'}])$

return model

# build the model

model $=$ baseline$\_$model$()$

# Fit the model

model.fit$($X$\_$train, y$\_$train, validation$\_$data$=($X$\_$test, y$\_$test$),$ epochs$=10,$ batch$\_$size$=200,$ verbose$=2)$

# Final evaluation of the model

scores $=$ model.evaluate$($X$\_$test, y$\_$test, verbose$=0)$

print$("$Baseline Error: $\%\mathrm{.}2$f$\%\%"\%(100-$scores$[1]*100))$

TO DO:

Derive the gradients for the below expressions:

vector $x=\left[\begin{array}{c}2\\ 3\end{array}\right],$ matrix $A=\left[\begin{array}{cc}{a}_1& a_2\\ a_3& a_4\end{array}\right]$

for the quadratic function $f(x)=0\mathrm{.}5**x^{T}Ax,$ prove that the gradient of the function gradf$(x)=Ax.$

Note that $A=A^T$ for a symmetric matrix.