Hector Nevarez

A Simple and Quick Docker Tutorial

2021-04-19T00:00:00+00:00

Prerequisites

All information for this tutorial was tested on Ubuntu 20.04 (Focal Fossa). Having this operating system is not a hard requirement but some information may be different on your personal machine. This information should be consistent for most linux distros but might differ on operating systems such as Mac or Windows.

There are no specific skills needed for this tutorial besides basic familiarity with the command line and text editor

Before we get started we need to make sure we install Docker Engine. Docker Engine is the main product of Docker which we will be using.

Once Docker Engine is installed, try running the following command:

me@mycomputer:~$ docker run hello-world

Like every other hello world program, this is used to make sure our installation is set up correctly. You should see your terminal display the following results:

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Once you are able to see this message, that means everything is set up correctly and we can go ahead and get started!

Getting Started

With your clean installation of Docker Engine, we are ready to get started.

Docker is a way to package your software so it can run on any hardware. In order to achieve this, there are three main components you must understand.

Dockerfile This is a text document that holds all the user commands required in assemble an image. We can think of this as our blueprint
Image A Docker image is a template containing a set of instructions for creating a Docker container
Container The Docker container is a running instance of an Image

Those three concepts are all we need to know to have a simple understanding of Docker. For this tutorial we will be creating our own dockerfile to generate an image and using docker run to start a container from the image we created. Our Docker container will run a simple python script that creates an array using NumPy and prints it to the console.

The python script will be located under /usr/src/docker_example and will be called app.py. The contents inside app.py are the following:

import numpy as np

arr = np.array( [[1, 2, 3], [3, 2, 1]])
print(arr)

The file location, file name, and file contents were all arbitrarily set by me. For your own applications feel free to change any of these parameters for your own specifications. All the example code can be found on my personal gitub.

Dockerfile

We’ll begin by constructing our Dockerfile. As mentioned before, the Dockerfile serves as the blueprint for creating our image. In your working directory, begin by creating a dockerfile. You can do this in the command line by navigating to your working directory and creating the dockerfile.

me@mycomputer:~$ cd /insert-your-dir
me@mycomputer:~/insert-your-dir$ touch dockerfile

Now open up the dockerfile you just created and let’s get started!

When starting the docker image, first you must start by setting a base image for subsequent instructions. To do this we use the FROM instruction. A dockerfile must always begin with this instruction. Typically we would start by using our operating system as our parent image, FROM ubuntu:20.04, however since our application requires python, we can use the offically supported python image. By doing so, we are not required to download python in our dockerfile.

FROM python:3 #Sets our parent image

We then navigate to our working directory and copy all of the files into our container. The WORKDIR instruction sets our working directory to whichever existing location we want. The COPY instruction will copy any specified files into our container.

WORKDIR /usr/src/docker_example
COPY . .

Now that we have all the files we need inside our container, we want to install any python dependencies our program will use. In this case, we need to install NumPy. We use the RUN instruction in order to execute any command inside our Docker image.

RUN pip install numpy

Finally, we run our python file using the CMD instruction

CMD ["python", "./app.py"]

Building and loading the container

Now that our docker file is complete we can build our docker image. In the same directory that your docker image lives, run the build command:

docker build -t python-docker-image .

Here we use docker build to build the dockerfile. the -t flag allows us to tag our docker image. This is just the name that we will give our docker image everytime we want to use it. Here we are calling in python-docker-image. Finally we specify where our dockerfile lives, since we are in the directory where our dockerfile lives, we use the . to indicate that the dockerfile lives in our current working directory.

We can verify our image has built by using the grep tool after listing our current docker images:

docker image ls | grep python-docker-image

output:

python-docker-image      latest    ad47ffb98ac2   About a minute ago   995MB

Now that we’ve confirmed that our docker image is built and ready to be used, let’s go ahead and run it!

docker run python-docker-image

We simply use docker run and specify our docker image name in order to run it, you should see the following output:

[[1 2 3]
 [3 2 1]]

This is exactly what we expected to run since that’s what our app.py application is expected to print out!

Conclusion

And just like that, you now know the basics of docker. Don’t stop there! Docker has so much more to offer. Our example application only ran a python file for us but you can do so much more. Docker provides interactive modes where you can mount a filesystem and use docker as an emulator based on whatever parent image you provide it. Docker can run in the background and you can give it commands for it to whatever you want. There is so much more to learn about docker, we are barely touching the surface. I hope you learned something new about docker today.

Happy Learning!

A Beginners Guide to Neural Networks

2021-03-05T00:00:00+00:00

A foundational piece to learning artificial intelligence is understanding the architecture of neural networks. Many are frightened by the “complexity” of this topic but in fact, neural networks aren’t that complicated. This post aims to demystify neural networks by providing an intuitive and comprehensive tutorial on the inner workings of neural networks.

This post is intended for beginners with no previous experience in artificial intelligence but should also provide value to even those who already have a solid background in this field. We’ll be going over the inner workings of neural networks by explaining its structure step by step.

Let’s get started!

What is a Neural Network?

Neural Networks(NN) are sets of interconnected neurons that take in a large set of data and aim to discover an underlying pattern. While neural networks don’t exactly emulate our biological neural networks, they are loosely inspired by how our brains learn.

Our brain doesn’t learn concepts instantly, it usually takes different iterations of explanations and even trial and error to solidify our understanding of an idea. Imagine if you had no understanding of what cats and dogs were. If I showed you thousands of different pictures of cats and dogs, you would start to form an understanding and eventually you would become more confident in telling me which pictures were cats and which were dogs. While oversimplified, this is the basis of how neural networks learn.

Now that you have a high level overview of how neural networks learn, let’s dive deeper and take a look at their structure.

Above, we can see an example image. The neural network is composed of 3 types of layers:

Input Layer—This is the input of our network where we pass in our data(This could be text, images, sound, etc.)
Hidden Layer—This layer falls in between the input and output layers. It does the mapping between the input and output layers by performing a series of mathematical operations
Output Layer—This can be seen as the results of our network

The term “deep learning” comes from neural networks with more than 1 hidden layer. These types of neural networks are called deep neural networks. The neural network figure above displays a deep neural network because it contains 2 hidden layers. Neural networks with only 1 hidden layer can be referred to as simple neural networks.

What is the function of the neuron?

Each neuron performs a set of mathematical operations to derive an output.

Above is an example of a randomly selected neuron. Each neuron will have a connection with every neuron in the previous layer. The way each neuron obtains its value is simple. It begins by summing up every input. The input consists of the input value(x) as well as an associated weight(w). When the model is trained, these weights shift around in order to get the optimal model. The weights carry influence as to how strong a connection between two neurons are. The higher the weight the higher influence of the neuron.

\[x\cdot w = (x_1\times w_1) + (x_2\times w_2) + ... + (x_n\times w_n)\]

Above we summed up every input which consisted of the input multiplied by the weight. We can further simplify this summation as the dot product of the vectors x and w.

Furthermore, we also have to add the bias(b) term to transpose the constant value to obtain the output values.

\[x\cdot w + b\]

Finally, to obtain the neurons output value, we pass it through an activation function in order to introduce non-linearity into the neurons output. Without the activation function, our neural network is essentially a linear regression model. With the activation function, our model is able to learn more complex tasks. There are several activation functions, but in this post we will be going over the sigmoid activation function.

To determine the output, the sigmoid activation function looks at the value obtained and the larger the value, the closer it will be to 1. The smaller the value, the closer it will be to 0. This allows us to have output between 0 and 1 with some values carrying more weight than others.

\[\frac{1}{1+e^{-z}}\]

Above we can see the sigmoid activation function equation where z is $x\cdot w + b$.

The steps outlined above occur through every neuron in the neueral network until the network reaches its end. This process of passing data through the neural network is called forward propogation. Once this process is completed we move on to backpropogation.

What is backpropogation?

Backpropagation fine tunes the model based on the results of forward propogation every iteration. After a forward pass, the neural network calculates the loss function and propogates those results backwards to tune the weights and biases. Since the model is updating its weights and biases every iteration, the model should become more optimized. The goal is to lower this error rate.

The loss function is highly related to the cost function however, the loss function refers to the error of one training sample, while the cost function is the average of the entire training set.

an example of a cost function is mean squared error(MSE).

\[\mathrm{MSE}=\frac{1}{n} \sum_{i=1}^{n}\left(Y_{i}-\hat{Y}_{i}\right)^{2}\]

In this case we’re taking the average of the sum of our actual value ($Y_{i}$) subtracted by our predicted value ($\hat{Y}_{i}$) squared. As mentioned above, our cost function is the average of our loss function, so our cost function is the equation above.

The cost function only tells us how wrong our predictions were, we now need to back propagate these results to modify our weights and biases. For this we use an optimizer.

Our optimizer tells use how to change our weights and biases to minimize loss. An example of an optimization algorithm is stochastic gradient descent.

\[w_{1} \leftarrow w_{1}-\eta \frac{\partial L}{\partial w_{1}}\]

In this equation $\eta$ is our learning rate. Our learning rate controls how fast or slow our weights get updated. $\frac{\partial L}{\partial w_{1}}$ is the partial derivative of our loss with respect to weights or biases. subtracting our weight or bias from $\eta \frac{\partial L}{\partial w_{1}}$ yields us our updated weight or bias.

This process is applied to all of our weights and biases slowly updating and optimizing our model.

Now What?

Congrats, you now understand neural networks! Like I said, neural networks are easy to understand. The best way to continue learning about neural networks is to:

Implement your own simple model using a library such as TensorFlow or PyTorch
Look into different types of neural networks and their applications such as Convolutional Neural Networks
Read other posts or watch informative videos to solidify your understanding of neural Networks.

Thanks for reading, happy learning!