DEV Community: alexc957

Five tensor operations in PyTorch

alexc957 — Thu, 26 Nov 2020 02:14:15 +0000

Introduction

PyTorch is an amazing deep learning library for tensor operations and deep learning, here is a list of 5 amazing functions available in the torch module. This post is part of an assignment from a deep learning course available in jovian in collaboration with freecodecamp for free, and part of the assignment was to write a post about tensor operations with PyTorch and I decided to post it here.

Content

torch.complex
torch.polar
torch.heaviside
torch.chunk
torch.where

1. torch.complex

parameters:

real: a tensor of datatype float or double.
imag: a tensor of datatype float

Given a tensor real that represents the real part of a complex number, and imag that represents the imaginary part, this function will return a new tensor that represents complex number that following rule:

Example:

Example 
real = torch.tensor([1,2], dtype=torch.float32)
print(real)
imag = torch.tensor([3,4], dtype=torch.float32)
print(imag)
z = torch.complex(real,imag)
print(z)

Output

tensor([1., 2.])
tensor([3., 4.])
tensor([1.+3.j, 2.+4.j])

Giving two tensor of size 2 each, we can create a new complex tensor tensor that follows the following rule: real[i] + (img[i])j

2. torch.polar

Parameters:

abs: the absolute value of the complex tensor, must be a tensor of datatype float. This is calculated by using the following formula:
angle: the angle of the complex tensor.

Giving a tensor that represents the absolute value of a complex tensor and a tensor that represents the angle, this function will return the tensor representation in polar coordinates according to the following rule:

Example:

import numpy as np
abs = torch.tensor([1,2], dtype=torch.float64)
print(abs)
angle = torch.tensor([np.pi/2,5*np.pi/4], dtype=torch.float64)
print(angle)
z = torch.polar(abs, angle)
print(z)

Output

tensor([1., 2.], dtype=torch.float64)
tensor([1.5708, 3.9270], dtype=torch.float64)
tensor([ 6.1232e-17+1.0000j, -1.4142e+00-1.4142j], dtype=torch.complex128)

this will return a tensor that represents a complex tensor in polar coordinates.

3.torch.heaviside

Parameters:

input:an input tensor.
values: a tensor that will be used when input[i] are zeros.

for each value in input computes the heaviside step function that is define by the following formula:

Example:

input = torch.tensor([-1.5,0,2.0])
print(input)
values = torch.tensor([0.5])
print(values)
heaviside = torch.heaviside(input,values)
print(heaviside)

Output

tensor([-1.5000,  0.0000,  2.0000])
tensor([0.5000])
tensor([0.0000, 0.5000, 1.0000])

As you can see the values are replaced by following the heaviside formula of above.

4. torch.chunk

Parameters:

input: the tensor to split
chunks: number of chunks to return
dim: dimension along which to split the tensor

Giving a tensor and a number of chunks this function return tensors according to the number of chunks over the specified dimension.
Example:

my_tensor = torch.tensor([
                          [5,5,6.,6],
                          [6,5,3.,7], 
                          [6,8,9,0]
                          ])
chunk = torch.chunk(my_tensor, 2,dim=0)
print(chunk)

Output

(tensor([[5., 5., 6., 6.],
        [6., 5., 3., 7.]]), tensor([[6., 8., 9., 0.]]))

as you can see the function returns two new tensors based on the number of chunks and the specified dimension. In this case was dimension 0 so the split will be row-wise, the first chunk will be the two first rows and the second the last row.

5. torch.where

Parameters:

condition: a tensor where each value is a boolean.
x: x[i] will be selected if condition[i] is true.
y: y[i] will be selected if condition[i] is false.

Given two tensor x and y and a condition, returns a tensor where x[i] will be selected if condition[i] is true, otherwise y[i] will be selected.

Example

x = torch.randn(3,2)
print(x)
y = torch.ones(3,2)
print(y)
result =torch.where(x>0,x,y)
print(result)

Output

tensor([[ 0.1014, -1.7573],
        [-1.0143, -0.5330],
        [-1.1203,  1.3897]])
tensor([[1., 1.],
        [1., 1.],
        [1., 1.]])
tensor([[0.1014, 1.0000],
        [1.0000, 1.0000],
        [1.0000, 1.3897]])

As we can see if the value x[i] is greater than 0 we kept the value otherwise will be replaced by y[i]

Conclusion

As we can see we have many functions available in the torch module, specially to work with tensors, we saw in this post 5 of them an I tried to describe each of them. But the torch documentation is the main resource for this post so I think is better to visit it and read it.

References

Official documentation for tensor operation:Pytorch
jovian deeplearning course
some mathematical formulas were written by using Codecogs project
my jupyter notebook that contains the code of this post with other examples.

How to use global components in VueJs

alexc957 — Sun, 19 Apr 2020 04:36:49 +0000

Components are the piece of legos that you can use to structure your Vue app, you can have a parent component who has a lot of child components, as we can see as is shown below:

<template>
  <div> 
     <MyFirstChild />
     <MySecondChild />
  <div> 

</template>

note: I assume you have created a project with the Vue CLI otherwise I think this might not work, specially if is a Vue project made it from scratch with the basic configuration.

but what if you want to shared the same child components in many components? In order to achieve this, you have to import and register your component in the script section of each parent component, like this:

<script>
import MyFirstChild from '@/components/MyFirstChild'
import MySecondChild from '@/components/MySecondChild'
export default {
   components: {
       MyFirstChild,
       MySecondChild,
 }
}
</script>

with this we are registering each component locally and this is pretty repeatedly, right?
In order to avoid this, we can register MyFirstChild and MySecondChild as global components that you will use them in many components of your app.

to do this, go to your src/main.js file, here the vue instance was set up, import the components and register them as follows:

import Vue from "vue";
import App from "./App.vue";
import router from "./router";
import store from "./store";
import MyFirstChild from '@/components/MyFirstChild'
import MySecondChild from '@/components/MySecondChild'

Vue.component('MyFirstChild ',MyFirstChild )
Vue.component('MySecondChild',MySecondChild)

Vue.config.productionTip = false;

new Vue({
  router,
  store,
  render: h => h(App)
}).$mount("#app");

with Vue.component we are registering a component to be used in many other components through your app. The first argument is the name of the component and the second is the component itself. Now both components are global and we can used them in other components without importing and registering them locally in each parent component!

But what happens if we have many components and we need to register them as they were global? well we can programmatically register each components that starst with the word My. For example MyCustomButton.vue, MyCustomCard.vue and in general every component that has the following pattern My**.vue

note: you need to install lodash, which is a popular javascript library with a lot of useful functions: npm install lodash --save

now we can add the following in your src/main.js

import Vue from "vue";
import App from "./App.vue";
import router from "./router";
import store from "./store";
import upperFirst from 'lodash/upperFirst'
import camelCase from 'lodash/camelCase'


const requireComponent = require.context(
  // The relative path of the components folder
  './components',
  // Whether or not to look in subfolders
  false,
  // The regular expression used to match component filenames who starts with "My"
  /My[A-Z]\w+\.(vue|js)$/
)

requireComponent.keys().forEach(fileName => {
  // Get component config
  const componentConfig = requireComponent(fileName)

  // Get PascalCase name of component
  const componentName = upperFirst(
    camelCase(
      // Gets the file name regardless of folder depth
      fileName
        .split('/')
        .pop()
        .replace(/\.\w+$/, '')
    )
  )


  // Register component globally
  Vue.component(
    componentName,
    // Look for the component options on `.default`, which will
    // exist if the component was exported with `export default`,
    // otherwise fall back to module's root.
    componentConfig.default || componentConfig
  )
})
Vue.config.productionTip = false;

new Vue({
  router,
  store,
  render: h => h(App)
}).$mount("#app");

Here we are using require.context to search every component in the src/components directory that start with My and then using some functions from lodash we create a custom name for the component in the pascalCase format

thats all, leave a comment, let me know if one part was unclear, also this is the first time I write a tutorial and in english, which is not my native language XD