Learning Computer Vision Week 2

At my high school, I am in a STEM pathway with courses geared toward different STEM fields, and understandably, there are engineering courses. In one of those engineering classes, I get access to a makerspace, and the current project I was working on at the time of this post was to make a laser engraving file to engrave into a piece of wood; it was practice for a new laser cutting software that we has just received licenses for (LightBurn, for those who are curious).

Midway into the project, I wanted to upload a design I found on the internet onto the LightBurn file, which I had to use an svg file (vector image) converter online in order to import the image onto the file. And while the converter was converting, I wondered if the converter used edge detection…

Now, edge detection was a concept that I had skimmed before (in the same course), but I haven’t looked fully into it, so this week, I’ll be investigating that.

Also, last week was a doozy, considering that I had picked up linear algebra in just a matter of a few days, so I’ll be spending this next week cleaning up my understanding of LA and specifically the mechanics of SVD.

Monday, September 16

Today, I just spent most of my programming time visualizing a Sobel and sharpening operator on random made-up images that I made (on paper).

Tuesday, September 17

Downloaded the Pillow and Open CV libraries using pip today!

Now that I learned the concepts of correcting and conducting segmentation for images though filtering, sharpening, and edge detection, I experimented with some images in a Jupyter notebook, using the Pillows and OpenCV library; both of which can get the job done, but in different ways.

Types of common and useful filters (not exhaustive):

1a. Mean Filters (Level Filters, Smoothing Filters)

Also known as mean or smoothing filter, these filters are the most simplest of filters when it comes to image preprocessing. This is there the kernel averages out all the values that are contained in the kernel for the kernel’s center pixel’s value.

No matter which library is being used, a kernel is required.

But, of course, there is a trade-off in the sizes of kernels: the larger the kernel is, the more noise it will be able to filter, but blurs the image more.

1b. Gaussian Blur

Gaussian Blur bases its blurring method by the Gaussian distribution (the 68-95-99.7 rule is based off of it), where the kernel gives more “weight” to the center pixel, and exponentially less “weight” to the surrounding pixels in the style of that of a Gaussian distribution.

When I was trying to display different images in my Jupyter notebook, I had to read into the matplotlib (library) documentation in order to successfully do so; it came in pretty handy! (If you’re curious which website I used, look in the Resources section)

1c. Median Filtering

Median Filtering is similar to Mean Filtering, but instead of taking the mean (average) of all of the pixels in a kernel, Median Filtering takes the median instead, leading to more definite but sometimes more inaccurate/warped images.

2. Edges

3. Sharpening

Notice how both libraries require a sharpening kernel to work! This sharpening kernel/filter can come in many different variations though, with the main gist being the middle pixel(s) being 0 or greater, and the outside pixels having a negative number.

Wednesday, September 18

Took a quiz in my Computer Vision course, and I passed second try 🤷

I also reviewed KNN (K-Nearest Neighbors), but in the concept of computer vision and, more specifically, image classification, which is what it sounds like: classifying images into categories e.g. “cat”, “dog”, “fish”.

When computers try to identify images, remember that they can only see the images as a bunch of intensity values, so this poses a lot of problems when trying to achieve image classification. But KNN is an algorithm that attempts to bridge that gap.

Basically, when looking at a set of images, the computer “plots” them in an area (like a coordinate plane), where the “area” has one dimension for each of their characteristics and attributes; for example, in a dataset where images can vary in their red, green, and blue values, they would be plotted in a 3D space; this is a concept in ML called dimensionality reduction, or in other words, “data visualization in a low-dimensional space”. Then when the computer model is “trained” by the “training” images that it’s given, the model is given an image it has never seen before and is assigned the task of classifying the image using the training data it was given. This unknown image is called “test” data for the computer, and it calculates the distance between that test image and all the otehr images that were in the training data, and takes the “k” amount of nearest images, or “neighbors”, and remembers them. Finally, the computer assigns the test image the class of whatever the majority class is of the “closest k amount” of images.

KNN sounds cool in theory, but in application makes for a relatively inefficient classification algorithm though.

Thursday, September 19

I spent most of today reviewing mainly machine learning/AI theory and starting up my IBM Cloud account (that came with the course, hint hint); I reviewed a new concept today, Linear Classification.

Linear Classifier is basically the concept where you insert the data from an input into a linear function, which is more commonly known as the Decision Function (or Decision Boundary), which outputs a value that will be plotted on a Decision Plane, which in turn will determine what class the input belongs to, based on which Decision Region the image’s plot point is in on the decision plane. In the context of computer vision, that input would be an image, and the classifier equation processes the three color channels of the image as vectors, calculates them though the decision function, and plots the image on a decision plane.

Friday, September 20

After looking over the concepts of Gradient Descent (a concept borrowed from calculus where a ML model will increase/decrease its model parameters in the direction that will decrease the error) and it’s role in Logistic Regression (used for categorical problems compared to Linear Regression), I looked at some sample code (lab) that IBM made that puts those concepts into action.

I was really overwhelmed at first glance.

So to save some trouble, I’ll highlight some of the functions (only functions from PyTorch) that were important in making a Logistic Regression Model, which is a very simple type of Neural Network.

torch.arange() and torch.view() (PyTorch)

torch.arange(-1, 1, 0.1).view(-1, 1)

The .arange(-1, 1, 0.1) creates a 1D tensor with values from -1 to 1 (exclusive) with an increasing interval of 0.1, creating values like [-1.0, -0.9, -0.8, ..., 0.9]. The .view(-1, 1) reshapes the tensor that was created with .arange(-1, 1, 0.1), where the first value determines the number of rows, and the second determines the number of columns that the reshaped tensor will have; the “-1” means “the number of elements in this whole tensor”, effectively reshaping the tensor into having only one column with each element having its own row.

nn.Linear() (PyTorch)

self.linear = nn.Linear(n_inputs, 1)

This code is what’s called a Linear Layer, where the input, n_values, is taken, and all of its values are “plugged” into a linear equation, and the output is all of those computed values (a method known as mapping) added together into a “1” dimensional object; a weighted value.

torch.sigmoid() and torch.linear() (PyTorch)

yhat = torch.sigmoid(self.linear(x))

The torch.sigmoid() puts the parameter though a sigmoid function, which a one kind of an activation function. Activation functions introduce nonlinearity into the model, and outputs the result; this is important because nonlinearity is crucial in machine learning models (like neural networks) because it’s what enables these models to identify complex relationships and patterns. Additionally, activation functions are differentiable (a function whose rate of change can be calculated at any point), which is a requirement for Gradient Descent to work to find the model parameters what would make the model more accurate.

Sources/Resources

The course I followed:

Libraries (specific pages):