Learn Jekyll, Loopback and Python

Neural networks, with Keras, bring powerful machine learning to Python applications. They can answer questions like “How much traffic will hit my website tonight?” or answer classification questions like “Will this customer buy our product?” or “Will the stock price go up or down tomorrow?”

In this course, we’ll build a fully connected neural network with Keras. This is the most basic type of neural network you can create, but it’s powerful in application and can jumpstart your exploration of other frameworks. 

We’ll start the course by creating the primary network. Then we’ll:

- build and configure the network, then evaluate and test the accuracy of each
- save the model and learn how to load it and use it to make predictions in the future
- expose the model as part of a tiny web application that can be used to make predictions

You don’t need to know a lot of Python for this course, but some basic Python knowledge will be helpful. Enjoy!

Python is a widely used dynamically typed programming language. It allows for many different programming paradigms including object-oriented, imperative, functional programming, and procedural styles.

python

Fully Connected Neural Networks with Keras

In Introduction to Python, we will start at the beginning: Installing python 3 and using virtual environments. With a working environment, we will learn how to manipulate strings and numbers, and gain working knowledge of data structures and flow control. We will build on that by introducing modules and classes and learn how to interact with our python applications using command line switches, console input and files.

At the end of this course, you’ll have a great working knowledge of Python, fully capable of creating your own Python projects from scratch or jumping into an existing application with the capability to read, understand, and contribute to the application.

Check out these [**community notes for this course on Github**](https://github.com/eggheadio-projects/introduction-to-the-python-3-programming-language-notes).

Introduction to the Python 3 Programming Language

Artificial intelligence. Machine learning. Bots. Computers learning and communicating with us to do our bidding. But, where do you start? How do you get a machine to even begin to understand what you speak or type at it? There are several common machine learning algorithms that will help us begin to answer these questions.

In this course we’ll learn about common machine learning algorithms that don’t require implementing a neural network. We will not be going too much into the math behind them, but instead learn what each algorithm is good for, and how to train them. We'll also learn about a few metrics for evaluating models.

We’ll implement these in Python using `scikit-learn` using `scikit-learn`’s built-in data sets. The focus of this course is on implementation and a high-level understanding of these algorithms. 

We'll look at a few ways to evaluate our models, for both classification and regression models. We'll touch on mean squared error and coefficient of determination (for regression), and accuracy score, logarithmic loss, confusion matrices, and classification reports (for classification). 

Python 2.7 is used in the lesson videos but the code provided has Python 3 available. The only breaking change is the `print` statement API.

For additional information on installation, vocabulary, and common errors visit the `README.md` to the course code attached to each lesson.

Simple and efficient tools for data mining and data analysis

scikit-learn

Introductory Machine Learning Algorithms in Python with scikit-learn

In this course the developer will learn how to create a LoopBack API and build it out to an API that can be used as a backend for apps. We will start by creating a basic LoopBack API project and gradually enhance it to a production ready API. The API we create defines a few models to persist the data and has custom functionality, validation and hooks added to those models. 

After our data structure is defined we will learn how to extend the functionality of LoopBack by using mixins and components. We will also lock our API down using ACL’s and create a mechanism to automatically define the admin and user roles and create our admin user.   

The last part of the course will show how how to filter the data stored in the API. We will make the API production-ready by adding unit tests, connecting it to MongoDB and we will show how to deploy the app to now.sh.   

LoopBack is a highly-extensible, open-source Node.js framework.

loopback

Build a Node.js REST API with LoopBack

AWS Amplify allows developers to create, configure, and deploy Serverless APIs and functions directly from their front-end environment.In this collection, you'll learn how to deploy various types of APIs and functions using the Amplify CLI. You'll also learn how to share code among various functions using Lambda layers and schedule functions to run at an interval to implement Serverless cron jobs.

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

Up and Running with AWS Amplify Functions

Jekyll is a blog-aware static site generator. You can write text in markdown or HTML and Jekyll uses layouts to create a static website. You can tweak how you want the site URLs to look, what data gets displayed on the site, and more.

After watching the collection you'll be able to:

* Install Jeykll and run it locally
* Create a new blog post
* Install plugins to add new features to your blog

Jekyll is a parsing engine bundled as a ruby gem used to build static websites from dynamic components such as templates, partials, liquid code, markdown, etc. Jekyll is known as "a simple, blog aware, static site generator".

jekyll

Create A Blog With Jekyll

Learn how to create tuples in Python. The videos in this collection will also cover more advanced features of tuples

The Ins and Outs of Python Tuples

Sometimes you get strings instead of objects and you have to parse them out. Here's an example where the raw data I got from a Twitch chatbot message wasn't useful to me until I parsed it into a dictionary.

Turning a key/value string into a dictionary in Python

In this lesson, you'll learn how to deploy a serverless function using the Python runtime, connect it to an API endpoint, and interact with it from a React application.

Creating a full stack serverless app with Python, React hooks, and AWS Amplify Functions

Using the `open` function, and the `as` and `with` keywords, we'll open up and read from a file. At the end of this lesson, you will be able to loop through the lines of text in a file, process the text in Python, and then print them to the terminal.

Read from a File in Python

Jekyll is a blog-aware, static site generator written in Ruby. 

Requirements:
* Ruby version 2.5.0 or above
* RubyGems

Install the Jekyll Ruby gem on macOS quickly with just a few terminal commands and have a blog-aware site running locally.

Install Jekyll and Create a New Project

Blogging is built into Jekyll. You write blog posts as markdown or HTML files and Jekyll turns them blog posts. They follow a specific naming convention to be picked up and used by Jekyll

All blog post files require front matter. Front matter is a snippet of YAML at the top of a file. Front matter is used to set your layouts and meta data.

Create New Blog Post with Jekyll

Jekyll has a plugin system that allows you to add custom features to your site. There are many plugins available or you can even write your own. You can view a list of plugins at [Planet Jekyll](https://github.com/planetjekyll/awesome-jekyll-plugins)

Liquid is a templating language written in Ruby to output to the browser 

[Liquid Documentation](https://shopify.github.io/liquid/)

Install a Jekyll Plugin

Learn how to create a tuple in Python. A tuple is an immutable data type that contains several items similar to a list. Items in a tuple can be of any data type.

Create a Tuple in Python

Learn to create a one item tuple. When creating a one item tuple, a comma has to be included after the item. Otherwise, your tuple will not return tuple as its data type. 

Create a One Item Tuple in Python

Tuples are immutable so there is no way to add or replace items in tuples. There is a way to get around this by adding two tuples into one. 

Understand Immutability with Python Tuples

A relation in LoopBack is a way to associate the data from multiple models with each other. LoopBack supports various types of relations each with a different use case.

In this lesson we will create a second model called Category and create a relation between the Category and the Product models. To do this we will first add a property to the Product model called `categoryId`. This will allow us to store for each Product the category it belongs to. We then move on to create the actual relationships. 

Our first relationship defines that a `Category hasMany Products` and the second one that a `Product belongsTo a Category`.

After defining these relations we will use the API Explorer to see how we can interact with this related data.

Create a relation between two LoopBack models

In this lesson we will look at the filters that can be used to retrieve and manipulate the data stored in LoopBack. 

We will use [Postman](https://www.getpostman.com/) to interact with the `/Categories` and `/Products` endpoints. 

Using the URL parameters we will apply at the various filters LoopBack has to offer: `include`, `order`, `where`, `fields`, `limit` and `offset`. 

Filter model data in LoopBack

In this lesson we look at extending the functionality of LoopBack models by defining a remote method. 

A remote method is a method on a model exposed over a custom REST endpoint. 

Using the `lb remote-method` command we will create the remote method meta-data in `product.json`. We will verify that this got created and that we see the new REST endpoint got added. Then we will create the actual method in `product.js` and enhance it so that the API will return an error if we want to buy a negative amount of products.

Define a remote method on a LoopBack model

In this lesson we will create a dynamic datasource in LoopBack. If the API is started with the environment variable `MONGODB_URL` it will use this url and the `loopback-connector-mongodb` package to store the data in MongoDB.

In the course we will use a local MongoDB instance. If you don't have MongoDB running locally you can always create a [free MongoDB Atlas database](https://egghead.io/lessons/create-a-free-database-on-mongodb-atlas).


Create a MongoDB DataSource in LoopBack

In this lesson you will learn how to persist the data from the memory connector. As the name suggests, the memory connector stores the data in memory. This means that if you restart the server, the data is gone. In development mode it can be useful to store this data in a file, so it gets persisted between server restarts, and it can be easily inspected.

Topics

Instructors

Content Type