def forward(ctx, prediction, target):
if not (type(prediction).__name__ == 'Tensor'
and type(target).__name__ == 'Tensor'):
raise RuntimeError("Expected Tensors, got {} and {}. Please use "
".loss() method for non-Tensor data".format(
type(prediction).__name__,
type(target).__name__))
requires_grad = prediction.requires_grad
batch_size = target.data.shape[0]
out = prediction.data - target.data
if requires_grad:
ctx.derivative_core = out
out = np.sum(np.power(out, 2)) / (2 * batch_size)
output = Tensor(out,
requires_grad=requires_grad,
is_leaf=not requires_grad)
return output
def get_loss(self):
"""
Calculates the returns the L2 Regression Loss
"""
reg_loss = Tensor(0., requires_grad=True)
for param in self.params:
reg_loss += (param**2).sum()
return (reg_loss*self.Lambda)
def test_Exponent():
a = Tensor.randn(8, 10, requires_grad=True)
o = MLlib.exp(a)
o.backward()
if not_close(a.grad.data, o.data):
raise AssertionError
def test_Cos():
a = Tensor.randn(6, 8, requires_grad=True)
o = MLlib.cos(a)
o.backward()
if not_close(a.grad.data, -np.sin(a.data)):
raise AssertionError
def test_ExponentWithMathModule():
a = Tensor.randn(8, 10, requires_grad=True)
o = math.e**a
o.backward()
if not_close(a.grad.data, o.data):
raise AssertionError
def test_Tan():
a = Tensor.randn(6, 8, requires_grad=True)
o = MLlib.tan(a)
o.backward()
if not_close(a.grad.data, 1 / (np.cos(a.data))**2):
raise AssertionError
def test_LogWithNegativeValue():
na = -np.abs(np.random.randn(6, 8))
a = Tensor(na, requires_grad=True)
b = MLlib.log(a)
b.backward()
if not_close(a.grad.data, 1 / a.data):
raise AssertionError
def test_TanAtPiOverTwoWithMathModule():
na = np.ones((8, 12)) * (math.pi) / 2
a = Tensor(na, requires_grad=True)
o = MLlib.tan(a)
o.backward()
if not_close(a.grad.data, 1 / (np.cos(a.data))**2):
raise AssertionError
def backward(ctx, grad_output):
derivative = ctx.derivative_core
grad_prediction = (derivative / derivative.shape[0]) * grad_output.data
return Tensor(unbroadcast(grad_prediction, derivative.shape))
def gen_mT(*args):
# generates Tensor from np.arrays with requires_grad=True
tnsrs = list()
for na in args:
tnsrs.append(Tensor(na, requires_grad=True))
return tuple(tnsrs)
from MLlib import Tensor
from MLlib.functional import Pad2d, im2col, Conv2d
a = Tensor([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]],
requires_grad=True)
kernel = Tensor([[1, 2], [3, 4]], requires_grad=True)
b = Pad2d.apply(a, 0, pad=(1, 1))
c = im2col.apply(b, (kernel.shape[-2], kernel.shape[-1]), 2)
d = Conv2d.apply(c, kernel, b, (kernel.shape[-2], kernel.shape[-1]), 2)
print(d)
d.backward()
print(a.grad)
from MLlib import Tensor
import MLlib.optim as optim
import MLlib.nn as nn
from MLlib.models import Sequential
from MLlib.activations import Relu
from MLlib.loss_func import MSELoss
import numpy as np # for features and target generation
np.random.seed(5322)
model = Sequential(nn.Linear(4, 16, activation_fn=Relu),
nn.Linear(16, 8, activation_fn=Relu), nn.Linear(8, 2))
X = Tensor(np.random.randn(10, 4)) # (batch_size, features)
Y = Tensor(np.random.randn(10, 2)) # (batch_size, output)
nb_epochs = 800 # number of epochs
alpha = 0.001 # learning rate
# SGD optimizer
optimizer = optim.SGDWithMomentum(model.parameters(), alpha, momentum=0.9)
loss_fn = MSELoss() # Mean Squared Error loss
for i in range(nb_epochs):
pred = model(X)
loss = loss_fn(pred, Y)
def __init__(self, in_features, out_features):
self.bias = Tensor(0., requires_grad=True)
self.weight = Tensor.randn(out_features, in_features)
self.weight.requires_grad = True
from MLlib import Tensor
from MLlib.regularizer import LinearRegWith_Regularization
from MLlib.regularizer import L1_Regularizer
from MLlib.optim import SGDWithMomentum
from MLlib.utils.misc_utils import printmat
import numpy as np
np.random.seed(5322)
x = Tensor.randn(10, 8) # (batch_size, features)
y = Tensor.randn(10, 1)
reg = LinearRegWith_Regularization(8,
L1_Regularizer,
optimizer=SGDWithMomentum,
Lambda=7)
# Regularizer,optimizer and Lambda as per user's choice
printmat("Total Loss", reg.fit(x, y, 800))
