DEV Community: Tanveer Shahriar Arnob

Azure Virtual Machine

Tanveer Shahriar Arnob — Thu, 16 Mar 2023 14:05:25 +0000

Microsoft Azure is a cloud computing platform that provides a wide variety of services.

Create Azure Virtual Machine

Search for Virtual Machines

Clink on create and select Azure virtual machine

Select resource group, give virtual machine a name and select region, availability option, image etc. as your need. Then click review + create.

Finally this page will show if everything is ok for the virtual machine and also the cost per hour for using that virtual machine. After that press create.

Then like the below picture you have to download private key for SSH connection. So press download private key and create resource.

Finally your virtual machine will be created and you will get the dashboard. From here you can configure, stop or delete the virtual machine.

Then if you want to connect via SSH with client search for connect and something like the image below will appear. There you will find commands for connecting. You have to run those commands in the cloud shell.

After that to update your software or install anything (for demo let's install nginx) run below command.

sudo su
apt-get -y update
apt-get -y install nginx

Also if you know that what you will install before creating virtual machine, then you can configure a cloud init while creating the VM which will automatically run all your commands. For configuring cloud init you have to go to advance tab and write the commands in the custom data and cloud init section like the image below.

And that's how you create a VM. But you have to know two things --

While creating VM it automatically creates a disk which is the storage for the image or operating system.
People may think that, if we stop the VM then it will not cost anything. But the truth is, as it has a default disk connected with it, even if we don't have to pay for the VM, we have to pay for the disk. So simply stopping the VM will cost less but it's not going to be 0.

Thank you everyone. That's it for today. Feel free to ask any question in the comment.

NumPy Arrays

Tanveer Shahriar Arnob — Sat, 19 Nov 2022 20:26:32 +0000

NumPy is a Python library used for working with arrays. It also has functions for working in domain of linear algebra, fourier transform, and matrices. NumPy was created in 2005 by Travis Oliphant. It is an open source project and you can use it freely. This module is mainly used for Data Science and Machine Learning.

Installation

We can install NumPy using pip [pip is a python package manager]. Go to your terminal and type:

pip install numpy

Using NumPy

To use the built in function from NumPy we have to import it first.

import numpy

But after that if we want to use any function we have to write numpy every time to use that. That's why it is convention to import numpy as np.

import numpy as np

NumPy Arrays

NumPy arrays essentially come in two flavors: vectors and matrices. Vectors are strictly 1-d arrays and matrices are 2-d (but you should note a matrix can still have only one row or one column).

Creating Numpy Arrays

We can create an array by directly converting a list or list of lists:

There are also some built in functions to generate arrays.

arange

numpy.arange([start, ]stop, [step, ])
arange is like the range function of python. It returns evenly spaced values within a given interval. Here start and step is optional if we need it but stop is mandatory.

arange can be called with a varying number of positional arguments:

arange(stop): Values are generated within the half-open interval [0, stop) (in other words, the interval including start but excluding stop).

arange(start, stop): Values are generated within the half-open interval [start, stop).

arange(start, stop, step) Values are generated within the half-open interval [start, stop), with spacing between values given by step.

zeros

numpy.zeros(shape, dtype=float)
It generates a array of given shape and type, filled with zeroes. Here shape can be a int which will generate 1D array or a tuple of ints which will generate matrices. Instead of tuple we can use list of ints also. And dtype is by default float but we can change it into int.

ones

numpy.ones(shape, dtype=float)
It is same as the zeros function but instead of zeroes all of the elements are one.

linspace

numpy.linspace(start, stop, num=50)
Returns num evenly spaced samples, calculated over the interval [start, stop]. And num is by default 50.

eye

numpy.eye(n)
Return a 2-D array with ones on the diagonal and zeros elsewhere. Simply it generates a nxn identity matrix.

Random

NumPy also has lots of ways to create arrays with random numbers.

rand

numpy.random.rand(d0, d1, ..., dn)
Create an array of the given shape and populate it with random samples from a uniform distribution over [0, 1).

randn

numpy.random.randn(d0, d1, ..., dn)
Return a sample (or samples) from the "standard normal" distribution. Unlike rand which is uniform. Also rand cannot generate negative values but randn can.

randint

random.randint(low, high=None, size=None)
Return random integers from low (inclusive) to high (exclusive). If we don't mention size then it will return one value. For size we can pass an int or a tuple of ints or a list of ints.

Array Attributes and Methods

reshape

Returns an array containing the same data with a new shape. But we have to declare the shape such that we have the proper amount of elements. Suppose we have a array of 25 elements. We can transform it into a 5x5 matrix but we can not reshape into a 3x4 matrix as it can not contain 25 element.

max

It will return the max value of the array.

argmax

It will return the index of the max value of the array.

min

It will return the min value of the array.

argmin

It will return the index of the min value of the array.

Shape

Shape is an attribute that arrays have which returns the shape of the array.

dtype

You can also grab the data type of the object in the array.

That's it for today. Feel free to ask any question in the comment.

Basic Python

Tanveer Shahriar Arnob — Fri, 21 Oct 2022 05:36:09 +0000

Python is a high-level, interpreted, object-oriented, general purpose programming language. It was created by Guido van Rossum, and released in 1991.Python has a simple syntax similar to the English language. Python runs on an interpreter system, meaning that code can be executed as soon as it is written. This means that prototyping can be very quick.

Python was designed for readability, and has some similarities to the English language with influence from mathematics.

Python uses new lines to complete a command, as opposed to other programming languages which often use semicolons or parentheses.

Python relies on indentation, using whitespace, to define scope; such as the scope of loops, functions and classes. Other programming languages often use curly-brackets for this purpose.

Data Types
Python mainly has 4 data types --

Integer -- All the whole number is integer
Float -- The numbers with the decimal part is float
String -- String is a series of character
Boolean -- For this data type we only have two values - True and False.

Variable Assignment
Variables in programming means a memory location where we can store our data. For python syntax for variable assignment is
var_name = data. Here var_name will be the label of that memory location and by using that we will be able to retrieve the data from the memory location.

Variable Naming Convention
There are some rules for naming variable. Some of them are mandatory otherwise it will give error and some of them are for readability.

A variable must start with a letter or the underscore (_) character. It cannot start with a number.
Variable names are case sensitive. Means "age", "Age", "aGe" are not the same variable.
If the name has more than one word than to separate those words we have to use underscore, we cannot use space

Let's print "HELLO WORLD"
Printing means showing something in the console. For that python has a built-in function print().

So print function literally takes anything you want to show in the console and shows it.

It can take variables also which will print the value of the variables.

Here we can see if we use comma to print two variables then it prints a space between the variables. We can change that using the "sep" argument of print.

Again if you notice, every print function creates a new line. Means after the first print, the next one will be in the new line. We can change that also with "end" argument.

Comments
Sometimes we have to write some notes on our code, so that we can figure out later for which purpose we wrote this piece of code. There are two types of comment:

Single Line Comment
Multi-line Comment

For single line comment we just need write "#" before the note.

For multi-line comments we use triple quotes (""" """ or ''' '''). But one thing to remember, by convention triple quotes are used as a docstring in python. That is why this is not recommended. So if we have to comment multiple lines, we should comment every line with Single Line Comment. To do so, just select every line and press ctrl + /.

Feel free to ask anything if you don't understand.

Univariate Linear Regression

Tanveer Shahriar Arnob — Sat, 24 Sep 2022 18:28:41 +0000

Regression
A regression is a statistical technique that relates a dependent variable to one or more independent (explanatory) variables. A regression model is able to show whether changes observed in the dependent variable are associated with changes in one or more of the explanatory variables.

Linear Regression
In general, the computer try to draw a graph in regression from where it can predict the result. The graph can be any one but when it is an linear equation it is called Linear Regression.

Univariate Linear Regression
Univariate linear regression focuses on determining relationship between one independent variable and one dependent variable.

Formula:

The w and b are called the parameters of the model. In machine learning parameters of the model are the variables which can be adjusted during training in order to improve the model.

Basically the model will try to find the best w and b for the model while training.

Cost Function
This is literally an "Standard Deviation" which helps the model to measure if it is efficient enough.

There are other formula of cost function. But we will be using this one.
Cost function helps us to find the difference of the predicted result and real result from the dataset. Target of the model will be reducing the cost function which will reduce the difference and gives us more accurate result.

Gradient Descent
It is an algorithm which is used to minimize any function and we will use that to minimize the cost function. At first start off with some initial guesses for w and b which generally 0. Then it will keep on changing the parameters w and b a bit every time to to reduce the cost function. Normally there might be more than one local minima but in linear regression there will be only one minima. So, for now we don't have to think about that.

Here alpha is the learning rate which is a small positive number between 0 to 1. We can consider it as how big steps we are taking to reach the minimum.

If the learning rate is too small, gradient descent will work but it will be slow.

If the learning rate is too big, it may always skip the minimum because of the big steps. So it may fail to converge and may even diverge.

#Importing modules
import numpy as np

#Function for computing cost
def compute_cost(x_train, y_train, w, b):
  m = len(x_train)
  cost = 0
  for i in range(m):
    f_wb = w * x_train[i] + b
    cost += (f_wb - y_train[i]) ** 2
  return cost / (2 * m)

#Function for computing gradient
def compute_gradient(x_train, y_train, w, b):
  m = len(x_train)
  dj_dw = 0
  dj_db = 0
  for i in range(m):
    f_wb = w * x_train[i] + b
    dj_dw += (f_wb - y_train[i]) * x_train[i]
    dj_db += (f_wb - y_train[i])
  return dj_dw/m, dj_db/m

#Function for gradient descent
def gradient_descent(x_train, y_train, w_init, b_init, alpha, num_iters):
  w = w_init
  b = b_init
  for i in range(num_iters):
    dj_dw, dj_db = compute_gradient(x_train, y_train, w, b)
    w -= alpha * dj_dw
    b -= alpha * dj_db
  return w, b

#Data sets
x_train = np.array([1.0, 2.0])
y_train = np.array([300.0, 500.0])

#Initial w and b
w_init = 0
b_init = 0

#Some values for gradient descents
alpha = 0.01
num_iters = 100000

print(gradient_descent(x_train, y_train, w_init, b_init, alpha, num_iters))

Above is the python implementation of gradient descent for univariate linear regression where we have only 2 data in the dataset. But larger dataset are always better for training.

Machine Learning Basic

Tanveer Shahriar Arnob — Fri, 23 Sep 2022 18:25:54 +0000

Machine Learning
Machine Learning is the field of study that gives computers the ability to learn and adapt without following explicit instructions, by using algorithms and statistical models.

The two main types of machine learning are

Supervised Learning.
Unsupervised Learning.

(1) Supervised Learning
In supervised learning, we provide a dataset where we have the result for certain inputs. Then the computer analyze and train itself to predict the result for any given inputs.

The two major types of supervised learning are

a. Regression
b. Classification

(a) Regression
A regression is a statistical technique that relates a dependent variable to one or more independent (explanatory) variables. A regression model is able to show whether changes observed in the dependent variable are associated with changes in one or more of the explanatory variables.

Basically, from the dataset, the computer tries to draw a graph which helps to predict the result.

Predicting house prices depending on the location and size is the example of regression.

(b) Classification
Classification refers to a predictive modeling problem where a class label is predicted for a given example of input data.

Basically, from the dataset, the computer tries to find some class and differentiate them. Then it tries to predict the class from the given inputs.

Predicting if a email is spam or not is the example of classification.

Difference Between Regression and Classification
In regression, the model has to predict result from infinitely many possible output numbers. On the other hand, classification has to the category which has a small set of possible outputs.

(2) Unsupervised Learning
In unsupervised learning, the dataset only has some values without any result. Then the model tries to group them or find some pattern. Based on the pattern the model tries to give result for any given inputs.

Anomaly detection, which is used to detect unusual events is done by unsupervised learning.

Difference Between Supervised and Unsupervised Learning
In supervised learning, the data comes with both inputs x and input labels y, and the algorithm tries to find a graph from where it can predict result. On the other hand, in unsupervised learning, the data comes only with inputs x but not output labels y, and the algorithm has to find some structure or some pattern or something interesting in the data.