DEV Community: Michael Learns

What Would You Use When Starting a New Company/Project?

Michael Learns — Mon, 16 Mar 2020 09:04:08 +0000

Hello everyone! I want to start a discussion about technologies that you would use if you're starting a new project or building up a new tech company.

If you're starting a new tech company what languages, technologies, platforms, etc. would you use and why? Say your tech company is doing some web and app development and you're developing to setup a new e-commerce site or a social networking site.

Hey, it's been awhile

Michael Learns — Thu, 20 Feb 2020 11:03:45 +0000

Hey everyone! It's been awhile since I last posted here. But I'm back! Hooray! 🎉🎉🎉

I've been busy with quite a few things lately. But lately I've been itching to get back into some coding. I want to stretch my mind a bit and refresh my hands to get used to coding again.

So here I am! I wanted to ask for some ideas from you guys of what you might want me to code! Here are 2 things that I do know:

Django
React

That's it. Pretty limited I guess. But I'm willing to learn new things! So shoot 'em at me and I'll give it a shot! 😄✨

Most Memorable Moment in Your Job

Michael Learns — Sat, 23 Feb 2019 15:07:12 +0000

Let's walk down through memory lane and remember our most memorable moment in our jobs. Good or bad, we have learned and grown, we laughed and cried.

My Most Memorable Moment

My most memorable moment would be that time when I wrote a code for a function that I knew I would need in the future. I left that project after a while and was assigned to another one.

The code was like a function that did some cleaning on the data queried from a database. It was pretty complex (not the best well-written code).

A few months later, I was brought back into the project to continue my unfinished tasks. I later encountered a problem that was quite complex. Reading my code from a few months back (with no proper documentation!! how dare me to myself?? 😭) I was already lost.

Luckily, that function that I knew I would need was documented. I had forgotten I had written a code for myself in the future, and when I read the short doc about the function, I then recalled that it was the very solution I needed for my problem. I laughed so hard (internally ofc 😅) because past self predicted how well my future self would forget and need the very same solution.

So the lesson is, always right proper documentation and write clean and readable code. 🤔

What's yours? Can't wait to hear them!

Flask vs. Django?

Michael Learns — Sat, 16 Feb 2019 15:11:43 +0000

So I was going to do a Flask tutorial this week after learning it in a week, but I decided to do a comparison with Flask and Django since I've had hands-on-experience with both python web frameworks. The reason is so that I can help you choose which framework to learn as learning a framework can be very time consuming —- but very fun of course!

CAUTION: I only spent a week with Flask whereas I've used Django for the past 3 years. Take this with a grain of salt 😅

Similarities

Let's start with similarities.

1) Flask and Django are both python web frameworks.

They enable you to create web applications using python for backend logic and html and css as front, or whatever front-end framework you'd prefer.

2) Can use ORM or object-relational-mapping.

This basically means, you can use SQLITE, MYSQL, PostgreSQL, and other databases that utilizes ORM.

-Django by default uses ORM.
-Flask does not come with ORM capabilities by default. You need to manually add it if you want.

3) Templating.

-Django uses a template engine similar to Jinja (actually Jinja was inspired by Django's own templating system)

Daniel Moch • Feb 16 '19

Small comment: Django doesn’t use Jinja, but it’s own templating engine. They look similar because, as Jinja’s website says, “It is inspired by Django's templating system.”

-Flask uses Jinja as its template engine.

Jinja is basically like python for html (python + html = Jinja) that enables you to add logic to your html such us if/else, for-loops, and extension of templates which I really really love!

There are many more similarities between Flask and Django, but for me those are three the main ones.

Differences

The differences are quite big when you put Flask and Django side by side.

With Flask you get incredible flexibility.

You create the app.py (which is like the main logic for your app), the models.py (which is where you store your models that creates the tables for your database), the templating and etc. You have ABSOLUTE control on how you want to build the structure for you app.

With Django, it's all built for you!

The settings.py (which is like the config file for your app) the models.py, the urls.py (which is where all the routings are stored), the templating, etc.

Which is why Django's tag is, "The web framework for perfectionist with a deadline." Because everything is built in, you don't need to bother yourself with creating the files and thinking about how you should structure your app. It's all ready for you and you can immediately get started with building your app.

Conclusion

Flask and Django both have their strengths and weaknesses.
Each one has their own uses and purposes.

If you're making an app that's simple that doesn't anything too complex, then Flask is the way to go.

But if you're a beginner and want to get into web development with python, I'd suggest you start with Flask. The things you learn in Flask can be applied to Django. It's just easier with Flask.

Congratulations 🎉🎉! You made it! I hoped it helped you out!
Also, tell me if you'd like to see me do
a tutorial of Flask or Django on Youtube.
Thanks ya'll! Have a break, take a kitkat 🍫.

Thanks for all those who gave their feedback and added stuff to my knowledge on Flask and Django! Keep 'em coming ✌🏽

Follow me on Twitter and Instagram @heyimprax.
Subscribe to my channel in Coding Prax.

Explain What is DOM like I'm 🖐

Michael Learns — Sat, 09 Feb 2019 15:58:52 +0000

Hopefully I can explain this easily and accurately 😅

I've been puzzled as to what DOM meant. I've seen DOM being used especially in Polymer and ReactJS documentations.

DOM means, "Document Object Model"

Basically, a web page is an html document. This document is actually an object. Under this object we have our element tags like the body, h1, div, etc. All these elements in a page have some sort of object structure.

Something like this:

"document" : {
        "head" : { "name": "head" },
        "body" : { "name": "body" },
        "h1" : { "name": "h1", 
                 "style": { "backgroundColor": "black" } 
               }
    }

In my html file it would look something like this:

<html>
    <head>
    </head>
    <body>
        <h1>Hello World</h1>
    </body>
</html

All the elements of the DOM is an object model (or structure). Meaning that an element like h1 would have a object structure like in the sample above. Yeah! Insane right? You can access these properties just like you would when accessing an object with Javascript!

Let's have an example.
I have a html element here:

<h1> Hello World </h1>

Using javascript I can actually change the properties of h1 by accessing it's object model like so:

let h1 = document.querySelector('h1');

// say we want to change it's background color to blue
h1.style.backgroundColor = 'blue'

And this works! Why? h1 actually has an object or property called style and under style it has a property called backgroundColor (or background-color in css) which allows us to modify that backgroundColor of h1! Cool!

Notice I did 'document.', right? This means that the HTML document is parsed into an object model which is the 'document' object and all the elements that are in the DOM are all found under this document object.

There are different ways in accessing the DOM:


let h1 = document.querySelector('h1'); //gets all elements that are h1
let h1 = document.getElementsByTagName('h1'); //similar to query selector except that it takes the tags of the element
let navHeader = document.getElementById('nav-header'); //gets elements by its id 
let btn = document.getElementsByClassName('btn'); //gets elements by its class

There you go! I hope I was able to briefly and easily explain what DOM is.
Please do let me know if I missed anything.

Congratulations you made it! 🎉 Have a break and have a kitkat 🍫
Cheers ya'll! Follow me on Twitter and Instagram on @heyimprax.

Aim for Perfection, Don't Expect a Bullseye

Michael Learns — Sat, 02 Feb 2019 15:35:05 +0000

I’m a planned out sort of guy. I love it when things are perfect. My stuff are organised like a library. All my stuff is strategically placed. Even the files in my laptop. I hate clutter and chaos.

In all my projects I want it to be the very best. I feel like if I'm giving it my all, if I’m not giving enough, and if it’s not the best then never mind. When it came to group projects, when my group mates can’t follow what I said to the T then in the next time around I’d rather do it myself. I became this person who would rather do things on his own and make it exactly as he had in mind rather than to work with people that would have a higher risk of making the idea imperfect. It became lonely. I was incredibly stressed. I aimed for my expectations only to fail at it time and time again.

I started reevaluating my point of view on perfectionism. I took a closer look at how this world works around perfectionism. Then it hit me. NOTHING IS PERFECT.

So I had to change my mind. I still wanted things to be the best they could be. I wanted my projects to be done in excellence. I wanted myself to be excellent. But how?

Four things I learned:

Strive for perfection, but don’t expect the results to be perfect.
Things will never be perfect, live with it.
Imperfection makes you grow.
Aiming for perfection forces you to be even better than before.

So aim for perfection, but don’t expect to hit that bullseye.

What are your thoughts on perfection?

Monkey Recognition with Tensorflow Keras

Michael Learns — Sat, 26 Jan 2019 15:28:15 +0000

It’s amazing how easy machine learning has become. It’s no longer a hinderance if you don’t have any mathematical background knowledge or any academia background on machine learning. I certainly belong to the category.

One of my goals in using machine learning is when recognising something. I wanted to build a model that could do facial recognition, identify animal species, name of things, etc. Learning the math to this was horrendous and quite difficult for someone with little knowledge on math. I almost gave up on this seemingly unattainable goal until I discovered “pre-trained models”.

Pre-trained models are basically (based on my understanding), models that have been trained on different datasets to solve a similar problem. There are different kinds of pre-trained models, each one for their own specific purposes for different problems.

Today, I’ll be showing you how I built a monkey recognition model using the pre-trained model ResNet50. ResNet50 is great for specifying species (based on what I’ve seen). I’ve seen this being used for dogs as well. Sooo let’s go with monkeys 🙈

Setup

I'm doing this project in a jupyter notebook. You can check my setup post if you haven't yet setup your machine for machine learning. I'm using the 10-monkey-species from Kaggle.

We must also have a JSON file with all the indexes of the species. You can download it in this Github gist. It's gonna be important for later.

Lastly, download the pre-trained models of ResNet50. Here's a link from Kaggle.

Structuring our Data Directory

My directory folder looks like this:

We have images for training and validation. *remember data splitting
Inside the training/validation folder we have the directories for each species and their images.

Transforming the Images

First hurdle is taking the images and changing it into something that our machine learning model can understand.


from tensorflow.python.keras.preprocessing.image import ImageDataGenerator
from tensorflow.python.keras.applications.resnet50 import preprocess_input

image_size = 224
data_generator_with_aug = ImageDataGenerator(preprocessing_function=preprocess_input, 
                                             horizontal_flip=True,
                                             width_shift_range=0.2,
                                             height_shift_range=0.2)
train_path='10-monkey-species/training'
train_generator = data_generator_with_aug.flow_from_directory(train_path, 
                                                     target_size=(image_size, image_size), 
                                                     batch_size=24,
                                                     class_mode='categorical')

data_generator_with_no_aug = ImageDataGenerator(preprocessing_function=preprocess_input)

validation_path='10-monkey-species/validation'
validation_generator = data_generator_with_no_aug.flow_from_directory(validation_path,
                                                          target_size=(image_size, image_size),
                                                          batch_size=24,
                                                          class_mode='categorical')

Let’s break this down. ImageDataGenerator is a function that takes the image and preprocess the image and spits out data that the model can understand. The preprocessing_function argument takes in another function, in this case the preprocess_input from ResNet50 which translates the image that RestNet50 can understand. The other arguments allows for data augmentation.

Data augmentation basically allows you to augment your data. Meaning that it allows you to increase your data samples without actually increasing the number of data you have. In this example flipping the image or slightly changing the width and height of the image allows us to have more samples of the image without actually using the same exact image.

flow_from_directory takes in all the images you’ve placed in the directory.

Building Our Model

Now, let’s build our model!!


from tensorflow.python.keras.applications import ResNet50
from tensorflow.python.keras.models import Sequential
from tensorflow.python.keras.layers import Dense, Flatten, Conv2D, Dropout

resnet_weights_path = 'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5'
model = Sequential()
model.add(ResNet50(include_top=False, pooling='avg', weights=resnet_weights_path))

num_classes = 10
model.add(Dense(num_classes, activation='softmax'))

# Say not to train first layer (ResNet) model. It is already trained
model.layers[0].trainable = False

model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])

model.fit_generator(train_generator, 
steps_per_epoch=3, 
epochs=20, 
validation_data=validation_generator, 
validation_steps=1)

Break down:

So we used a Sequential convolutional network. Then we added a ResNet50 layer with the pre-trained weights.
Then we added a Dense layer with the number of classes we have which is 10. Number of classes means the number of species (in this case) that we're trying to identify.
We also said that for the first layer of our model we don’t want to re-train it.
Then we compiled everything that we did with model.compile() and finally fitted everything in the model.fit_generator()

Remember the generators we’ve made when we transformed our images? We placed them all in here.

Epochs is basically the number of times the model will cycle through the images.
steps_per_epoch is the number of images we would take in for each epoch.

Testing Our Model

import numpy as np
from os.path import join
from tensorflow.python.keras.preprocessing.image import load_img, img_to_array

image_dir = '10-monkey-species/validation'
img_paths = [join(image_dir, filename) for filename in 
               ['n0/n000.jpg',
                'n5/n502.jpg',
                'n9/n9031.jpg',
                'n2/n2014.jpg']]

image_size = 224
def read_prep_images(img_paths, img_height=image_size, img_width=image_size):
    imgs = [load_img(img_path, target_size=(img_height, img_width)) for img_path in img_paths]
    img_array = np.array([img_to_array(img) for img in imgs])
    output = preprocess_input(img_array)

    return output


test_data = read_prep_images(img_paths)

Here we take in several test images from our validation dataset and changing them into a np.array using the read_prep function.

Then we predict them with our model.

preds = model.predict(test_data)
print(preds)

Translating Our Predictions

We need to translate our predictions into indexes so that:

we can use that index on our JSON file
Return the appropriate data for that index

I copied this from Kaggle with a few slight adjustments.

import json
from IPython.display import Image, display

def decode_predictions(preds, top=5, class_list_path=None):
  if len(preds.shape) != 2 or preds.shape[1] != 10:
    raise ValueError('`decode_predictions` expects '
                     'a batch of predictions '
                     '(i.e. a 2D array of shape (samples, 1000)). '
                     'Found array with shape: ' + str(preds.shape))
  index_list = json.load(open(class_list_path))
  results = []
  for pred in preds:
    top_indices = pred.argsort()[-top:][::-1]
    result = [tuple(index_list[str(i)]) + (pred[i],) for i in top_indices]
    result.sort(key=lambda x: x[2], reverse=True)
    results.append(result)
  return results


most_likely_labels = decode_predictions(preds, top=5, class_list_path='10-monkey-species/class_monkey_species.json')

for i, img_path in enumerate(img_paths):
    display(Image(img_path))
    print(most_likely_labels[i])

So the decode_predictions process takes in the preds which is a 2D array and indexes the corresponding object from the json file. So for example if preds was [0, 1, 8] then it would index that from the json and return [[‘index_0’, ‘folder_name’], ['index_1', 'folder_name'], ['index_8', 'folder_name']].

The for loop basically takes in the images and displays them with the decoded predictions.

And this is the result:

Conclusion

Machine Learning has become incredibly simple. It’s flabbergasting. Certain terms here like ‘softmax’ and ‘relu’ are all mathematical terms which you don’t really need to dive into their mechanics but would be useful if you had a general idea of what they do and what they’re for. In my journey so far in machine learning, you only need a general understanding and concept of it to really begin.

Hope you learned something from this!
Would love to hear your feedback 😄
See more from me on twitter and instagram @heyimprax.

Thanks for reading! You've made it 🎉 Have a coffee break ☕️

What to do when ideas aren't flowing?

Michael Learns — Sat, 19 Jan 2019 01:36:27 +0000

It's never easy when we face a creativity block. Depending on what you're interested or what you're working on whether it's writing articles, coding, making videos, etc. it's never easy to make something when you simply have no idea what to make. We try to do different things just to let the creativity flowing but sometimes it just never 'clicks' and we end up frustrated on ourselves.

As creators (programmers are creators) we love making things happen. We love to make things with our own hands and see it with our eyes and have it shared to others. And one of the best parts of being a creator is seeing people enjoy the product you've made, or even you enjoying the product you've made for yourself!

So I wanted to open up this discussion so that can share those times you faced creativity block and what you did to get yourself out of that situation and allow the creativity to flow again.

Let's write...✏️✏️✏️

Building our First Machine Learning Model (Pt. 4)

Michael Learns — Sat, 12 Jan 2019 05:25:22 +0000

In this post I’ll be showing you a quick and easy example applying machine learning to a dataset and doing predictions with our model.

We’ll be using:

Python
Pandas, which is helps us in data structure and data analysis or visualisation
Scikit-Learn, and
Iris Dataset.

I won’t be diving too deep on how to use these tools. But for what I’ll cover in this post should be enough to get you through most datasets.

Let’s begin!

Get the Data

First let’s download the iris dataset. You can download the iris dataset here and save it as CSV.

Let’s import pandas and read our csv file.:

import pandas as pd
dataset = pd.read_csv("./iris.csv")
# let’s see a sample of our data
dataset.head()

The .head() functions shows us the top few rows in our dataset.
You can see the columns and the rows which contain our data.

Looking at our dataset we could see the columns which are

["sepal_length", "sepal_width", "petal_length", "petal_width", "species"]

We want to make our target (the thing we’re trying to predict, also called y) to be the species column and the rest of the columns [sepal_length, sepal_width, petal_length, petal_width] to be our features (also called X).

y = dataset["species"]

features = ["sepal_length", "sepal_width", "petal_length", "petal_width"]
X = dataset[features]

Splitting the Data

Next, we need to split our data. Typically we’d need to split our data into 3 parts. One for training, second for validation, and third for testing.

Training data for training our model
Validation data to validate our model and
Test data to test our model

We need a validation dataset because the lifecycle of our training data wears off in every training. Essentially our model gets too familiar with our training dataset that it might form biases and affects the performance of our model to new, unseen data. Validation data makes sure that our model performs well on even unseen data.

Testing dataset is when we want to see the ‘final’ performance of our model after testing with our validation data. Nothing is "final" though. Machine Learning is a continuous improvement, but just so we can make sure our model still performs well even on unseen data, which is our testing data.

Scikit-Learn uses the train_test_split function which splits our data to training and validation*.

**I'm not currently sure if it can also split for test 😅✌🏽but this is enough for our small project.*

from sklearn.model_selection import train_test_split

#splitting our dataset for training and validation
#random_state to shuffle our data
train_X, val_X, train_y, val_y = train_test_split(X, y, random_state=1)

Transforming the Data

Excellent! However, machine learning doesn’t understand letters. Machine Learning is composed of a bunch of mathematical formulas and operations under the hood. In math we don’t say, One+One=Two. It must be 1+1=2.

Our y (target variable) are currently in characters or letters. [‘Versicolor’, ’Setosoa’, ‘Verginica’]. We need to somehow convert this into a meaningful number that the machine learning can understand.

It could be easier to do [0, 1, 2] right?
But the problem with this approach is that the machine learning might think there’s a correlation in the order of the labels and might form a bias due to that order.

The recommended approach would be to use one-hot encoding. Fortunately, pandas has a built in one-hot-encoder function that we can conveniently use.

train_y = pd.get_dummies(train_y)
val_y = pd.get_dummies(val_y)

Excellent! Let’s begin training our model. We’ll be using the Scikit-Learn's RandomForestClassifier since we’re trying to classify plants.

from sklearn.ensemble import RandomForestClassifier

random_forest = RandomForestClassifier(random_state=1)
random_forest.fit(train_X, train_y)

That random_state is basically shuffles our data to avoid any seeming order in our data. This makes sure that our model isn’t biased to the order of our given training data.

Testing our Model

Let’s now validate our model using our validation data.

from sklearn.metrics import mean_absolute_error

preds = random_forest.predict(val_X)
mae = mean_absolute_error(val_y, preds)

print("Mean absolute error is: {:,.5f}".format(mae * 100))
print(random_forest.score(val_X, val_y) * 100)

Mean absolute error is the basically the average error of our model. The lower the mean absolute error the better the performance of our model is.
The .score() function gives us the score of the performance of our model on the validation data.

Currently the mean absolute error is (I think) too low. And the .score() is too high. There’s a possibility of data leakage, even overfitting on our model.

I won’t dive in too much in to it but it’s best to avoid data leakage and overfitting in our models as these can severely affect the performance of our model.

Let’s test our model shall we? I’ve manually placed a test data in our model to see what it would predict.

preds = random_forest.predict([[2.0, 1.9, 3.7, 2]])
print(preds)

It gives us the result:

[[0. 1. 0.]]

Inspecting our y variable with print(y) we could see that it looks like this:

Setosa	Versicolor	Virginica
0	1	0

Looking at our prediction we can conclude that based on our given test data our model returned versicolor.

Inspecting the data we can logically conclude that it is actually quite right!!

Sweet!! We just trained a new model in predicting models. Incredible!! Give yourself a coffee break. ☕️ Congratulations 🎉🎉🎉

Hope you enjoyed the My Machine Learning Journey series. I hope you also learned something 😅 I’m open to any feedbacks you might have or if there’s something that might be wrong, please do comment down below.

For those trying to follow this code, I have a working kaggle notebook for this example.

Thank you!

P.S. I've just uploaded my Hello World video on my Youtube Channel - Coding Prax! Drop by and say hi 😄 like and subscribe if you want to ✌🏽

Setup for Machine Learning (Pt. 3)

Michael Learns — Sat, 05 Jan 2019 00:02:12 +0000

Machine Learning is heavily computational. You'll need to have some tools to be able to work with machine learning in your own computer. I recommend the following specs:

Intel core i5 Gen processor
4GB of RAM.
Not necessary but having a GPU is a great advantage. With GPU computations come way faster compared to CPU.
For storage I’d recommend at least having 250 GB SSD. Having 120 GB is just too little especially when downloading large datasets and installing a plethora of libraries. SSD hard rives allows for faster reads and writes.

I recommend you watch Siraj Raval’s video for a more detailed explanation as to which laptops are good for machine learning.

You should use a Linux based system. It's just so much easier to work with ml especially since you'll be using the terminal aLOT. With Windows, it's not impossible, but it is definitely harder.

Have python (2.7 or 3.5 or newer) installed and add it to your path.
Install pip after installing python. Watch my tutorial here.
(please subscribe if it helped you. i'll be posting more content this year ✌🏽)
Optionally you can to install a virtual environment. I recommend using virtualwrapper.

With a virtual environment you can easily manage different packages that you install with pip.

I recommend you also install jupyter notebook.

python -m pip install jupyter
# do python3 if you installed python 3 or greater

With jupyter notebook you can immediately see the result of your code without having to go into a terminal and running python *.py every single time you change a line of code.

Optionally, you can also use a code editor and a terminal to run your code. I prefer the VSCode editor and the iTerm terminal, though you can also opt in to use the default Terminal in the Mac or Linux or any of your preferred code editors.

Thanks for reading! This is part 3 of a 4 part series. Next we'll talk about getting into the code of machine learning.

Finding the Right Course (Pt. 2)

Michael Learns — Mon, 31 Dec 2018 01:42:11 +0000

Welcome. Let’s begin, shall we?

The What

The first hurdle to my machine learning journey is, WTF is machine learning?

"Machine learning is an application of artificial intelligence (AI) that provides systems the ability to automatically learn and improve from experience without being explicitly programmed.” - Source here

So basically it’s an application of AI that gives the system the ability to learn from experience without the “if/else” conditions.

Why?

Why would we want to learn machine learning? The simple answer would be why not? Having the power of creating something that could potentially make us as a human better that could help us in our daily lives is freaking awesome! Also, you could probably create your own JARVIS (like Tony Stark) which is kinda my goal.

Where To?

So now the question is how do I begin learning ML?

Well, first you’ll need a programming language to use. You can choose from Java, Python, C# and other languages. I’ve grown comfortable with Python and there are already lots of ML communities using python so for the rest of our journey, we’ll be using Python. I recommend the Codecademy course if you haven’t learned Python.

You’ve probably googled how to learn ML and you might have read somewhere that it takes a lot of knowledge of math to get started. That’s not really the case. Yes, learning the math can be very helpful, but sometimes, even the simplest knowledge can be very powerful.

So even with the simplest models and not too much math know-how, you can already do so so much! That’s great news ain't it?

Finding the Map...

Now to find a tutorial.
I’ve searched lots of ML tutorials around the web. I’ve checked out Sentdex, Udacity, Google, and Coursera. But I found that the best tutorial for me is Kaggle.

What is Kaggle? Taking from a notebook by Zeeshan-ul-hassan Usmani:

"Kaggle is an AirBnB for Data Scientists.”

"Kaggle enables data scientists and other developers to engage in running machine learning contests, write and share code, and to host datasets."

Check out Kaggle.

Kaggle hosts hundreds of thousands of datasets for data scientists and developers to use. It also hosts competitions that developers and data scientists can engage in. You could even win prize ($$$) on some of those competitions.

What many don’t know is that Kaggle also has a “Learn” section so that you too can start learning about ML, Deep Learning, Data Visualisation, and tons of other stuff!

Learning at Kaggle is so easy because it has these little “notebooks” which contain the text, the code, and the result from that code. These little notebooks easily explains concepts of the topics and what they do without driving you off to imagination land. Plus, the data used for the code is easily found within the "Data" tab of the notebook which you can download and experiment yourself. HURRAH!💥

Kaggle also has a great community mixed with experts and noobs like me. So you are never left out.

This post isn’t sponsored by Kaggle and I’m not in any way affiliated by it. I just really love learning at Kaggle ❤️

P.S. We all have different styles of learning. I love reading short articles that easily explains stuff in as little code as possible that can work for my particular use, and Kaggle easily does this for me. You should definitely checkout Sentdex, Udacity, Google, and Coursera as they offer great and comprehensive content that might also fit your learning style 😉

My Machine Learning Journey (Pt. 1)

Michael Learns — Thu, 27 Dec 2018 14:46:49 +0000

Hi! How do I even begin?

That’s like the first thing we always seem to ask and it ain’t easy to answer that question. Every new adventure always comes unplanned. You never really know where to begin.

Maybe, a little introduction.
Hey! My Name is Ben Prax, and I’m homeschooled.

I’m no machine learning expert (yet).
I’m not a graduate.
I’m not good at math
(probably something almost everyone can relate too, am I right?).
I barely understand the math under the hood of the machine learning models.
I’m not always focused. I let little things distract me, which is a TERRIBLE habit by the way.

Which is also why I decided to do this post to really push myself to study.

More on that later.

I don’t know many experts in my area who I can find tutor or training specific to machine learning.

I do however have the following:

A laptop
The internet
A brain
Google
Willingness to learn
Determination
Curiosity

I’m also aware of some communities who are into machine learning.
Communities are there to help you, but majority of the time, you’re on your own googling questions.

Curiosity and determination and the willingness to learn are probably the most crucial in the 7 items above. Without these you probably won't even bother reading this post, right? So let your curiosity flow and feed it with knowledge. Be determined and be willing to learn fully aware that you'll make mistakes along the way. Accept it and move on with the new learning.

The purpose of this post (article, diary, blog, whatever) is to encourage all those who want to start their machine learning journey.

Hopefully, you’ll learn a thing or two of the struggles I will be facing, trying to understand this mysterious black box called Machine Learning (ML). 🤔?

Maybe we can also celebrate together when we’ve finally uncovered these mysteries and riddles and puzzle our knowledge together. 🎉🎉

I hope you enjoy as you follow along my journey in studying machine learning.

If you can suggest something that you think might help me and other readers, don’t hesitate to comment.

Thanks for reading. Let’s begin! 😄