Sync

Tasks/KavyaV/day2.py

@@ -0,0 +1,8 @@
+import torch
+import numpy as np
+
+np_arr1 = np.arange(15).reshape(5,3)
+np_arr2 = np.arange(12).reshape(3,4)
+tensor1 = torch.from_numpy(np_arr1)
+tensor2 = torch.from_numpy(np_arr2)
+print(torch.matmul(tensor1,tensor2))

Tasks/daily tasks/Abhijeet/task1.py

@@ -0,0 +1,19 @@
+#Day2
+# Playing around with tensors
+
+# 1. Create two numpy arrays of size 5x3 and 3x4.
+# 2. Convert them into torch tensors.
+# 3. Multiply the two tensors and print the result.
+
+
+import numpy as np
+import torch as tp
+
+a= np.random.rand(5, 3) 
+b=np.random.rand(3, 4) 
+a=tp.tensor(a)
+b=tp.tensor(b) 
+print(a.size())
+print(b.size())
+Multipli_tensor=tp.mm(a,b)
+print("Multipli_tensor\n",Multipli_tensor)

Tasks/daily tasks/Abhijeet/task2.py

@@ -0,0 +1,26 @@
+import torch.nn as nn
+
+import torch
+
+class Network(nn.Module):
+    def __init__(self,N_in,N_out):
+        super(Network, self).__init__()
+        self.input = nn.Linear(N_in, 500)
+        self.fc1 = nn.Linear(500, 120)
+        self.fc2 = nn.Linear(120, 84)
+        self.Output = nn.Linear(84, N_out)
+        self.sigmoid = nn.Sigmoid()
+
+
+    def forward(self, x):
+    	x=self.input(x)
+    	x= self.fc1(x)
+    	x = self.sigmoid(x)
+    	x=self.fc2(x)
+    	x = self.Output(x)
+    	return x
+
+
+net = Network(600,10)
+print(net)
+

Tasks/daily tasks/Abhinav K/day2_task.py

@@ -0,0 +1,10 @@
+import numpy as np
+import torch
+
+a=np.random.rand(5,3)
+b=np.random.rand(3,4)
+a2=torch.from_numpy(a)
+b2=torch.from_numpy(b)
+
+c=torch.mm(a2,b2)
+print(c)

Tasks/daily tasks/Abhinav M Hari/day_2_task.py

@@ -0,0 +1,14 @@
+import numpy as np
+import torch
+
+#creating numpy arrays
+x = np.zeros([5, 3])
+y = np.ones([3, 4])
+
+#converting to tensors
+x_ = torch.from_numpy(x)
+y = torch.from_numpy(y)
+
+#Multiplying the tensors
+z = torch.matmul(x_, y_)
+print(z)

Tasks/daily tasks/Abhinav M Hari/task 2.py

@@ -0,0 +1,18 @@
+import torch
+import torch.nn as nn
+
+class Net(nn.Module):
+  def __init__(self):
+  super(Net, self). __init__()
+  self.layer1 = nn.Linear(120, 84)
+  self.layer2 = nn.Linear(84, 10)
+
+  def forward(self, x):
+    x = self.layer1(x)
+    x = torch.sigmoid(self.layer2(x))
+
+net = Net()
+input = torch.randn(120)
+output = net(input)
+print(output)
+

Tasks/daily tasks/Abhinav T B/day2.py

@@ -0,0 +1,15 @@
+import numpy as np
+import torch
+
+
+a = np.empty((5, 3))
+b = np.empty((3, 4))
+
+
+a = torch.from_numpy(a)
+b = torch.from_numpy(b)
+
+
+c = torch.mm(a, b)
+
+print(c)

Tasks/daily tasks/Akhil G Krishnan/task2.py

@@ -0,0 +1,10 @@
+import numpy as np
+import torch
+
+
+a = np.empty((5, 3))
+b = np.empty((3, 4))
+a = torch.from_numpy(a)
+b = torch.from_numpy(b)
+c = torch.mm(a, b)
+print(c)

Tasks/daily tasks/Akshay Narayanan/Day_2.py

@@ -0,0 +1,12 @@
+from __future__ import print_function
+import numpy as np
+
+import torch
+
+p=np.random.random((5,3))
+q=np.random.random((3,4))
+x=torch.from_numpy(p)
+y=torch.from_numpy(q)
+
+product=torch.matmul(x,y)
+print("The product of 5x3 and 3x4 tensor are  >>  \n ......\n",product)

Tasks/daily tasks/Ananthu Ajay/day2.py

@@ -0,0 +1,14 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import torch
+
+import numpy as np
+x = np.random.random((5,3))
+y = np.random.random((3,4))
+a= torch.from_numpy(x)
+b = torch.from_numpy(y)
+
+t=torch.mm(a,b)
+
+print(t)

Tasks/daily tasks/Ananthu Ajay/day4.py

@@ -0,0 +1,32 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class Net(nn.Module):
+
+    def __init__(self):
+        super(Net, self).__init__()
+        self.conv1 = nn.Conv2d(1, 4, 4)
+        self.conv2 = nn.Conv2d(4, 16, 4)
+        self.fc1 = nn.Linear(16 * 4 * 4, 120)
+        self.fc2 = nn.Linear(120, 10)
+
+    def forward(self, x):
+        x = F.max_pool2d(F.sigmoid(self.conv1(x)), (2, 2))
+        x = F.max_pool2d(F.sigmoid(self.conv2(x)), 2)
+        x = x.view(-1, self.num_flat_features(x))
+        x = F.sigmoid(self.fc1(x))
+        x = self.fc2(x)
+        return x
+
+    def num_flat_features(self, x):
+        size = x.size()[1:]
+        num_features = 1
+        for s in size:
+            num_features *= s
+        return num_features
+
+
+net = Net()
+print(net)

Tasks/daily tasks/Ashwin-Rajesh/Day2.py

@@ -0,0 +1,14 @@
+#!/usr/bin/python3.7
+
+import numpy as np
+import torch
+
+np.random.seed(0)
+
+array_a = np.random.randn(5,3)
+array_b = np.random.randn(3,4)
+
+tensor_a = torch.tensor(array_a)
+tensor_b = torch.tensor(array_b)
+
+print(tensor_a.matmul(tensor_b))

Tasks/daily tasks/Bharath.T.U/Day2_task.ipynb

@@ -0,0 +1,121 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#importing needed packages\n",
+    "import torch \n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "first numpy array \"a\" with size (5, 3) is :-\n",
+      "[[ 1.62434536 -0.61175641 -0.52817175]\n",
+      " [-1.07296862  0.86540763 -2.3015387 ]\n",
+      " [ 1.74481176 -0.7612069   0.3190391 ]\n",
+      " [-0.24937038  1.46210794 -2.06014071]\n",
+      " [-0.3224172  -0.38405435  1.13376944]]\n",
+      "second numpy array\"b\" with size (3, 4) is :-\n",
+      "[[-1.09989127 -0.17242821 -0.87785842  0.04221375]\n",
+      " [ 0.58281521 -1.10061918  1.14472371  0.90159072]\n",
+      " [ 0.50249434  0.90085595 -0.68372786 -0.12289023]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "#1st part\n",
+    "np.random.seed(1)\n",
+    "a=np.random.randn(5,3)\n",
+    "b=np.random.randn(3,4)\n",
+    "print(\"first numpy array \\\"a\\\" with size {} is :-\\n{}\".format(a.shape,a))\n",
+    "print(\"second numpy array\\\"b\\\" with size {} is :-\\n{}\".format(b.shape,b))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor of a:-\n",
+      "tensor([[ 1.6243, -0.6118, -0.5282],\n",
+      "        [-1.0730,  0.8654, -2.3015],\n",
+      "        [ 1.7448, -0.7612,  0.3190],\n",
+      "        [-0.2494,  1.4621, -2.0601],\n",
+      "        [-0.3224, -0.3841,  1.1338]], dtype=torch.float64)\n",
+      "tensor of b:-\n",
+      "tensor([[-1.0999, -0.1724, -0.8779,  0.0422],\n",
+      "        [ 0.5828, -1.1006,  1.1447,  0.9016],\n",
+      "        [ 0.5025,  0.9009, -0.6837, -0.1229]], dtype=torch.float64)\n"
+     ]
+    }
+   ],
+   "source": [
+    "#2nd part\n",
+    "ta=torch.from_numpy(a)\n",
+    "tb=torch.from_numpy(b)\n",
+    "print(\"tensor of a:-\\n{}\".format(ta))\n",
+    "print(\"tensor of b:-\\n{}\".format(tb))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dot product of ta and tb(ta.tb)\n",
+      " tensor([[-2.4085, -0.0826, -1.7651, -0.4181],\n",
+      "        [ 0.5280, -2.8408,  3.5062,  1.0178],\n",
+      "        [-2.2024,  0.8244, -2.6212, -0.6518],\n",
+      "        [ 0.0912, -3.4221,  3.3012,  1.5609],\n",
+      "        [ 0.7005,  1.4997, -0.9318, -0.4992]], dtype=torch.float64)\n"
+     ]
+    }
+   ],
+   "source": [
+    "#3rd part\n",
+    "mul=torch.matmul(ta,tb)\n",
+    "print(\"Dot product of ta and tb(ta.tb)\\n\",mul)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

Tasks/daily tasks/Bharath.T.U/task2.py

@@ -0,0 +1,21 @@
+import torch
+import torch.nn as nn
+class Net(nn.Module):
+
+    def __init__(self,n_in,n_out):
+        super(Net, self).__init__()
+        self.in_layer   = nn.Linear(n_in, 512) 
+        self.h1_layer   = nn.Linear(512, 256)
+        self.h2_layer   = nn.Linear(256, 128)
+        self.out_layer  = nn.Linear(128, n_out)
+        self.activation = nn.Sigmoid()
+
+    def forward(self, x):
+        x = self.in_layer(x)
+        x = self.h1_layer(x)
+        x = self.activation(x)
+        x = self.h2_layer(x)
+        x = self.out_layer(x)
+        return x
+net = Net(1024,64)
+print(net)

Tasks/daily tasks/Farhan_Najeeb/day_2_task.py

@@ -0,0 +1,11 @@
+import torch
+import numpy as np
+
+
+x = np.ones((5, 3))
+print(x)
+y = np.random.randn(3, 4)
+print(y)
+x = torch.from_numpy(x)
+y = torch.from_numpy(y)
+print(torch.mm(x, y))

Tasks/daily tasks/Farhan_Najeeb/day_4_task.py

@@ -0,0 +1,32 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class Net(nn.Module):
+
+    def __init__(self):
+        super(Net, self).__init__()
+        self.conv1 = nn.Conv2d(1, 6, 5)
+        self.conv2 = nn.Conv2d(6, 16, 5)
+        self.fc1 = nn.Linear(16 * 5 * 5, 120)
+        self.fc2 = nn.Linear(120, 10)
+
+    def forward(self, x):
+        x = F.max_pool2d(F.sigmoid(self.conv1(x)), (2, 2))
+        x = F.max_pool2d(F.sigmoid(self.conv2(x)), 2)
+        x = x.view(-1, self.num_flat_features(x))
+        x = F.sigmoid(self.fc1(x))
+        x = self.fc2(x)
+        return x
+
+    def num_flat_features(self, x):
+        size = x.size()[1:]
+        num_features = 1
+        for s in size:
+            num_features *= s
+        return num_features
+
+
+net = Net()
+print(net)