def tensor(self, initial_value=None, op=None): """ The `tensor` method defines a new tensor with the given initial value and operation. """ return Tensor(initial_value=initial_value, graph=self, op=op)
def one_hot_encoding(x: int, classes: int) -> Tensor: assert x < classes encoded = np.zeros((classes, 1)) encoded[x, 0] = 1 return Tensor(encoded)
from tensor import Tensor from PIL import Image from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart import os import smtplib import random if __name__ == '__main__': url = '' t = Tensor(url) folder = "/home/mahima/images" while (true): for filename in os.listdir("/home/mahima/images"): numberoffiles = len(folder) img = random.choice(os.listdir("/home/mahima/images")) image = folder + '/' + img print(numberoffiles) res = t.classify(image) os.remove(image) #sending response as an email fromaddr = "" toaddr = "" msg = MIMEMultipart() msg['From'] = "Tensorflow" msg['To'] = "Mahima" msg['Subject'] = "TENSORFLOW CLASSIFICATION RESULT" body = '/n' + res msg.attach(MIMEText(body, 'plain')) filename = image attachment = open(image, "rb")
def test_tt_layer_time(): weights = np.random.rand(4096, 4096).astype(np.float32) input = torch.Tensor((1, 4096)) data = np.random.rand(1, 4096).astype(np.float32) input.data = torch.from_numpy(data) times_4 = [] times_8 = [] ds = [4, 6, 8, 10] rs1 = [[1, 8, 8, 8, 1], [1, 8, 8, 8, 8, 8, 1], [1, 8, 8, 8, 8, 8, 8, 8, 1], [1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 1]] rs2 = [[1, 4, 4, 4, 1], [1, 4, 4, 4, 4, 4, 1], [1, 4, 4, 4, 4, 4, 4, 4, 1], [1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1]] rss = [rs2, rs1] times = [times_4, times_8] print('linear') layer = LinearLayer(4096, 4096) layer.weight.data = torch.from_numpy(weights) res = layer.forward(input) res = layer.forward(input) start = time.time() res = layer.forward(input) or_t = time.time() - start print('===========') rs3 = [or_t * 1000] * 4 for j in range(2): rs = rss[j] for i in range(4): weight_tensor = Tensor(weights, from_matrix=True, d=ds[i]) # [4, 32, 256, 1494, 4096, 512, 64, 16, 4] tt_ranks = rs[i] print('d=', ds[i]) print('tt_ranks', tt_ranks) t_tensor = torch.Tensor((4096, 4096)) t_tensor.data = torch.from_numpy(weights) Gs = weight_tensor.tt_with_ranks(tt_ranks) sum = 1 for s in weight_tensor.T.shape: sum *= s logger.info(f'tt parameters: {len(Gs)}') np.save('../CNNs/data/tt_fc_4_alexnet_cores.npy', Gs) tt_layer = TTLayer(in_features=weight_tensor.ns, out_features=weight_tensor.ms, tt_ranks=tt_ranks) #start = time.time() tt_layer.forward(input) #logger.info(f'tt_layer {time.time() - start}') #start = time.time() tt_layer.forward(input) #logger.info(f'tt_layer {time.time() - start}') start = time.time() tt_layer.forward(input) t = time.time() - start times[j].append(t * 1000) #logger.info(f'tt_layer {time.time() - start}') print('===========') plt.plot(ds, times_4, sns.xkcd_rgb["amber"], label='ap', linewidth=3) for p in range(len(ds)): plt.plot([ds[p]], [times_4[p]], 'o', color=sns.xkcd_rgb["amber"]) plt.plot(ds, times_8, sns.xkcd_rgb["dusty red"], label='ap', linewidth=3) for p in range(len(ds)): plt.plot([ds[p]], [times_8[p]], 'o', color=sns.xkcd_rgb["dusty red"]) plt.plot(ds, rs3, sns.xkcd_rgb["medium green"], label='ap', linewidth=3) for p in range(len(ds)): plt.plot([ds[p]], [rs3[p]], 'o', color=sns.xkcd_rgb["medium green"]) p1 = mpatches.Patch(color=sns.xkcd_rgb["amber"], label='rk = 4') p2 = mpatches.Patch(color=sns.xkcd_rgb["dusty red"], label='rk = 8') p3 = mpatches.Patch(color=sns.xkcd_rgb["medium green"], label='Исходный слой') plt.xlabel('TT-ранг') plt.ylabel('Время работы, мс') plt.legend(handles=[p1, p2, p3]) plt.show()
def __init__(self, input_size: int, hidden_size: int, output_size: int): super().__init__() self.hidden_unit = RNNHiddenUnit(input_size, hidden_size) self.W_hy = Tensor(np.random.normal(loc=0, scale=0.1, size=(output_size, hidden_size))) self.b_y = Tensor(np.random.normal(loc=0, scale=0.1, size=(output_size, 1))) self.register_parameters([self.hidden_unit, self.W_hy, self.b_y])
X, y = skd.load_diabetes(return_X_y=True) partition = len(X) // 10 X_train = X[:-partition] y_train = y[:-partition] X_test = X[-partition:] y_test = y[-partition:] # y_out = matmul( (batch, 13), (13, 1) ) + (1) = (batch, 1) W = Tensor(np.random.rand(10, 1) - 0.5) b = Tensor(np.random.rand(1) - 0.5) Wt = torch.tensor(W.value, requires_grad=True) bt = torch.tensor(b.value, requires_grad=True) batch_size = 16 learning_rate = 0.025 optimizer = Optimizer([W, b], lr=learning_rate) optimizer_t = optim.SGD([Wt, bt], lr=learning_rate, momentum=0.0) print("GOING TO START") losses = [] losses_t = []
import numpy as np from tensor import Tensor from layers import Sequential, Linear from activations import Tanh, Sigmoid from optimizers import SGD from losses import MSELoss np.random.seed(0) data = Tensor(np.array([[0, 0], [0, 1], [1, 0], [1, 1]]), autograd=True) target = Tensor(np.array([[0], [1], [0], [1]]), autograd=True) model = Sequential([Linear(2, 3), Tanh(), Linear(3, 1), Sigmoid()]) criterion = MSELoss() optim = SGD(parameters=model.get_parameters(), alpha=1) for i in range(10): pred = model.forward(data) loss = criterion.forward(pred, target) loss.backward() optim.step() print(loss)
def __call__(self, input: Tensor) -> Tensor: n_samples = input.data.shape[0] return input.mm(self.weight) + self.bias.expand(repeat = n_samples, axis = 0)
def compute_body(name, lambda_ivs, fcompute, shape=(), dtype=None, tensor=None, attrs=OrderedDict()): """Create a stage and perform the computation. If `tensor` is `None`, no tensor is returned. Parameters ---------- name : str The name of the stage lambda_ivs : list of IterVar A list contains the iteration variables in the lambda function if exists fcompute : callable The computation rule shape : tuple, optional The output shape or the iteration domain dtype : Type, optional The data type of the output/updated tensor tensor : Tensor, optional The tensor to be updated. Create a new one if it is `None` Returns ------- Tensor or None """ var_list = [i.var for i in lambda_ivs] return_tensor = True if tensor is None else False with Stage(name, dtype, shape) as stage: if not return_tensor: stage.input_stages.add(tensor.last_update) else: tensor = Tensor(shape, stage._dtype, name, stage._buf) buffer_var = tensor._buf.data dtype = tensor.dtype shape = tensor.shape stage.stmt_stack.append([]) ret = fcompute(*var_list) print(dir(ret)) print(dir(ret.a)) print(dir(ret.b)) stage.lhs_tensors.add(tensor) for t in stage.lhs_tensors: t.last_update = stage stmt = None if ret is None: # replace all hcl.return_ with Store stmt indices = lambda_ivs index, _, _ = get_index(shape, indices, 0) stmt = stage.pop_stmt() stmt = ReplaceReturn(buffer_var, dtype, index).mutate(stmt) stmt = make_for(indices, stmt, 0) elif isinstance(ret, (TensorSlice, Scalar, _expr.Expr, numbers.Number)): indices = lambda_ivs index, _, _ = get_index(shape, indices, 0) stage.emit(_make.Store(buffer_var, _make.Cast(dtype, ret), index)) stmt = make_for(indices, stage.pop_stmt(), 0) elif isinstance(ret, Tensor): # reduction ret_ivs = [ _IterVar((0, ret.shape[i]), ret.name + "_i" + str(i), 0) for i in range(0, len(ret.shape)) ] non_reduce_ivs = [] indices = [] rid = 0 for iv in lambda_ivs: if iv.var.name[0] == "_": indices.append(ret_ivs[rid]) rid += 1 else: indices.append(iv) non_reduce_ivs.append(iv) if rid != len(ret.shape): raise APIError( "Incorrect number of reduction axes in lambda arguments") index, _, _ = get_index(shape, indices, 0) st = _make.Store(buffer_var, _make.Cast(dtype, ret[tuple(ret_ivs)]), index) stage.emit(make_for(ret_ivs, st, 0)) stmt = stage.pop_stmt() stage.input_stages.remove(stage) if non_reduce_ivs: stmt = make_for(non_reduce_ivs, stmt, 0) else: raise APIError("Unknown return type of the computation rule") # add attributes to the loop if isinstance(stmt, _stmt.For): stmt = _make.For(stmt.loop_var, stmt.min, stmt.extent, 0, 0, stmt.body, list(attrs.keys()), list(attrs.values())) stage.emit(stmt) stage.axis_list = indices + stage.axis_list if return_tensor: tensor._tensor = stage._op return tensor return None