Learning Path: Step-by-Step Programming with Python and R

Install Python 3.4.

• Go to the Python.org website
• Download Python
• Install Python

Set up a programming environment for the user.

• Review the difference between an IDE and text editor
• Show the user different IDEs and text editors that they can choose from
• Learn how to use a text editor in action

Introduce the user to Python variables.

• Create basic variables, such as integers and strings
• Explain naming conventions
• Explain some of the shortcuts to create variables

Introduce the user to various Python data types, such as strings, integers, and floats.

• Introduce standard types and terminology
• Give examples of strings, ints, longs, and floats

Explain what the basic Python operators are.

• Introduce examples with the +, -, /, and * operators
• Do more examples with advanced operators, such as **, //, and %
• Mention that operators of different types have different effects

In this video, you will be introduced to single-quote and double-quote strings. Also, we will take a look at the usage of triple quotes.

• Do A demo of what a string is
• Explain difference between single quotes and double quotes
• Take a look at an example of how to use triple quotes

Introduce basic string functions.

• Do a demo of how to use a simple method, such as upper and lower
• Have an example of how to use another method, such as capitalize
• Learn what the Python string API is

Demonstrate advanced string manipulation methods.

• Do a demo of how to use the count function
• Have an example of how to use the replace function

Demonstrate how to use the .format method.

• Take a look at a demo of basic formatting (using integer/floats as examples)
• Learn more advanced formatting using strings and padding
• Know how to format with named arguments

Print and display someone’s name in a particular format.

• Get user input
• Capitalize input names
• Format the strings using the .format method from the previous video

In this video, we want to introduce the user to lists.

• Create a simple list with names and another with numbers
• Explain the concept of indexing
• Access and delete elements with indexing

In this video, get introduced to basic list methods.

• Do a demo of what the .append method is and how it works
• Take a look at the Python API and know that there are many list functions that can be used.
• Finish off with an example of using the .index and del commands to implement the .remove list method

Get introduced to more advanced list functions.

• Set up a scenario whereby we have a bunch of lists and want to form the alphabet using list methods
• Use the .sort method and the .insert method
• Pull the example together using the .join method to finish the alphabet

In this video, we will get introduced to Python’s built-in functions.

• Explain how the min/max functions work
• Learn how the sum function works and how it’s not meant to be used for strings
• Explore how the len() function works

Take a look at 2D arrays and array referencing.

• Do a demo of what a 2D array is
• Take a look at how to query from a 2D array
• Have an example of how array referencing works

Learn the Python range function and array slicing

• Take a look at a demo of what the range function is and how it works
• Explore array slicing examples
• Learn how to use negative indexing

We aim to introduce to what control flow and branching is.

• Explain how the computer can make a decision with an “if” statement
• Take a look at a simple example of how to use an if statement by writing a program to identify a given name

The aim of this video is to introduce the fundamental comparison operators.

• Give a demo of using the “==” operator and why it differs from “=”
• Show the difference between >, >= and <, <= and give a demo

The aim of this video is to introduce the else and elif keywords.

• Know what “else” is with the help of a demo
• Explore what elif is and how it differs from if with a demo
• Use both keywords in an if statement

Introduction to the “and”, “or”, and “not” keywords.

• Explain what the “and”, “or”, and “not” keywords are for and when you would use them
• Explain what the concept and True and False is
• Give a few examples of how “and”, “or”, and ”not” work with True and False. In the next video, give more detailed examples

In this video, we want to show the user the “and”, “or”, and “not” statements.

• See a demo of how to use an “and” clause
• Take a look at a demo of how to use an “or” clause
• Do a demo of how to use a “not” clause

Create a mini program that uses conditionals.

• Write a program to evaluate simple mathematical expressions in a file
• Make the program extract out the largest value in the file

In this video we want to introduce for loops

• Introduce the “in” keyword used in the for loop structure
• Do a demo of how to use a for loop with a list
• Loop over a list with a for loop displaying the index of each element

In this video, we will get introduced to the while loop.

• See a demo of how to use a while loop
• Talk about the advantage of using a while loop and when you would want one
• Know what an infinite loop is and why while loops are prone to infinite loops

In this video, we will know more about iterables.

• See a demo of what an iterable is by checking for the __iter__ property
• Learn how to use a for loop to iterate over an iterable
• Explore how a for loop works behind the scenes using an iterator

Get introduced to combining conditional with loops.

• See a demo of how to extract the consonants from a string
• Take a look at another demo of how to add up only the even numbers in a list

Get introduced to problem solving using loops, conditionals, and other things that were learned.

• Creating a prime number checker incorporates all these things
• Learn how to create a prime number checker using a loop
• Patch the bugs created in the first prime number checker with if statements

Get introduced to functions.

• Know what a function is and why you would want to use one
• Learn about condensed code, which is code that is clearer, reusable, and with fewer bugs
• Take a look at a small example function to calculate the area of a circle for instance

Get introduced to the idea of parameters and arguments.

• Explore the difference between arguments and parameters and then go on to learning examples
• Create a function that uses default parameter
• Explain what a variadic function is and how to make one

This video aims to introduce the functions that return a value and those that do not.

• Explanation with slides of what a void function is and what a function that returns a value looks like
• Learn when to use one instead of the other and compare and contrast with functions that are built into Python

Expose the writing functions.

• The first example will be a function that can reverse a string
• The next function will be a void function that checks whether a number is a palindrome
• Take a look at additional examples

Learn to create slightly more complex functions.

• Implement a generalized shift cipher
• Code the encryption function
• Code the decryption function

Introduce function recursion.

• Explore the basics of recursion (a function that calls itself and the base case)
• Take a look at the advantages of using recursion
• Give simple examples including doubling a number recursively and computing an exponential recursively

Get introduced how to write recursive functions.

• See a demo of how to sum up the digits of a number recursively
• Make another recursive function to count the number of vowels in a string

Get introduced to the “import”, “from”, and “as” keywords.

• See a demo of importing the math module
• Take a look at the difference between importing and importing with from
• Know when to use the “as” keyword while importing something

Get introduced to the Python API and reading docs.

• Showcase the Python standard library modules on the Python.org website
• See a demo of how to import something from a Python standard module and use it
• Learn to copy a file using the shutil module

Create your own modules.

• Walk the viewer through how to create a simple module to compute the volume of simple solids
• Import the new created module
• Have an example of how to use a function in the new module

Take advantage of the module structure to test code.

• Take a look at a demo of what if __name__ == ‘__main__’ is and why it is used
• See how to test code in a module using if __name__ == ‘__main__’

Get introduced to installing third-party libraries.

• Begin by introducing pip, a Python command-line utility
• Learn how to install PIL/Pillow for picture manipulation
• Run a small program with the new library just to make sure it works

In this video, we want to introduce working with PIL/Pillow.

• Take a look at a simple example of how to open and display an image
• Create a function that will resize multiple images to a certain size
• Have a demo on how to crop an image

Get introduced to picture color manipulations.

• See a demo of how to do edge detection
• Grayscale an image
• Learn to increase the contrast and brightness of an image

Introduce picture manipulation at the pixel level.

• Begin by introducing what the color channels in an image are
• Access the pixels in the picture and transform the channel to produce a negative image

In this video, we will wrap up the entire series.

• Where to go next
• Review sections 1 to 8

This video provides an overview of the entire course.

The goal of this video is to provide a basic understanding of the Python language constructs.

• Understand basic grammar elements
• Understand functions and classes
• Explain the reasoning behind Python's differences from other languages

The goal of this video is to ensure we have the basic ability to operate with Python's most common data structures.

• Learn to create data structures
• Learn how the structures organize data
• Learn to use comprehensions to operate on all members of a data structure

People used to lower-level languages are unfamiliar with First-class functions and classes; we'll take a look at them in this video.

• Define first-class objects
• Explain the implications of first-class functions
• Explain the implications of first-class classes

Python comes with a lot of tools. We need to be familiar with them in order to make the best use of the language. That's the topic we will be covering in this video.

• Take a look at data structures and data storage
• Understand encoding and decoding formats
• Interact with low-level operating system services

The goal of this video is to look at the overview of recent language changes in Python.

• Look at the syntax changes
• Understand the library additions
• Take a tour of the other changes

In this video, we are going to download and install the correct version of Python and make sure it's functional.

• Select the proper installer to download
• Install the Python runtime and libraries
• Test that everything is working correctly

The fastest way to get rolling is to use a textual interface, so we need to make sure we know how to use it. That's the goal in this video

• Open a command window
• Run the Python iterative shell
• Practice evaluating Python expressions

Python has good support for installing and managing third-party code packages; let's take a look at them in this video.

• Install packages
• Manage installed packages
• Search available packages

There's a lot of good code available. How do we find it? Let's take a look in this video.

• Understand keyword searches
• Know browsing categories
• Look at searching through Pip

The goal of this video is to know how to create the structure of a Python program.

• Explore the relationship with filesystem directories
• Learn about __init__.py
• Try importing our new package

A package containing no code isn't of much use. How do we make it do something? Let's take a look at it in this video.

• Explore valid filenames for code modules
• Take a look at the contents of a code module
• Build up a programming interface from module parts

The goal in this video is to understand how we can make code in separate modules of the package interact.

• Understand absolute imports
• Learn relative imports
• Check out how to avoid dependency cycles

A complete program usually involves static data files along with the code. How do we integrate non-python files in a package? Let's find out!

• Understand where to put data files
• Use pkgutil.get_data
• Load text data

The computer can read our code as long as the syntax is correct, but humans require more care. Let's see how we can write readable code in Python.

• Understand why tabs and spaces should not be mixed, and spaces are preferred
• Explain style conventions
• Explain naming conventions

If more than one programmer is working on a project, version control is a necessity. Even for a single programmer, version control is useful. We will take a look at it in this video.

• Initialize Git
• Use Git as an undo log
• Branch, merge, and pull

In this video, we will see how writing a program can take a while, and it's best that external changes to the development system do not impact the process.

• Set up a virtual environment
• Activate a virtual environment
• Install packages locally in a virtual environment

Properly formatted docstrings can be automatically used by IDEs and transformed into HTML. Let's take a peek into it in this video.

• Understand basic docstring structure
• Understand reStructuredText for rich formatting
• Take a look at the Sphinx documentation compiler

The goal of this video is to understand why it's important that examples in the documentation stay consistent with the code.

• Understand how to write examples
• Learn how to check examples with doctest
• If the test fails, either the documentation is wrong or the code is; see how to rectify

Writing Python code packages is all well and good, but how to we make a program? We will take a look at it in this video.

• Understand what python-m means
• Take a look at the __main__ module
• Recognize when the program is being run and when it is being imported

It's useful to be able to read data from the program command line. The argparse package makes it easy. Let's see it in action in this video.

• Instantiate an argument parser object
• Configure a argument parser object
• Access the parsed data

What do we do when we need information to flow both ways with the user?

• Get to know the basics of print() and input()
• Get introduced to the special cases: getpass and pprint
• Work on interactive interfaces with the cmd package

Running other programs from within a program is often useful, especially, for system automation. We'll look at how to do it.

• Know more about the subprocess.call function and its variants
• Get to know the subprocess.Popen class
• Communicate with a background process

It's often useful to have a launcher file for a program, which can be double-clicked in a GUI or used a shorthand from the command line. A simple script or batch file does the trick, let's see how.

• Create a shell script for Mac or Unix/Linux
• Create a batch file for Windows
• Use shell scripts or batch files to launch Python programs

Parallel processing has pitfalls, but Python's high-level parallel processing framework makes it easy to dodge them. Let's look at it in this video.

• Learn the map and submit operations
• Understand Futures
• Know what to avoid for efficient data transfer between processes

When our program doesn't fit the conceptual model of concurrent.futures, we can use multiprocessing to define our own model. Let's see how.

• Get to know the Process class
• Learn inter-process communication
• Understand synchronization between processes

At first glance, Python's coroutine scheduling looks a lot like multiprocessing or multithreading. What's the difference? Let's get to know this better.

• See how coroutine scheduling operates in a single process
• Understand why coroutine scheduling has lower overhead per stream of execution
• Explore why coroutine scheduling is good for I/O bound programs, especially servers

The goal of this video is to set up and run the asyncio asyncio coroutine scheduler

• Get the default scheduler
• Add coroutine tasks to the scheduler
• Run the scheduler to execute the tasks

In this video we will see how do we actually use asyncio's Future objects.

• Wait for Future to arrive and retrieve the value
• Check if Future has arrived, then retrieve the value
• Loop over a sequence of Future data

The goal of this video is to understand how to keep coroutines from jamming each other up and locking the program.

• Know the standard synchronization primitives
• Understand why synchronization is not always needed
• Use queues for inter-coroutine communication

In this video, we will see how do asyncio's actual I/O facilities work

• Create a client
• Create a server
• Know when to stop serving a client

Functions are very useful, but it would be nice to be able to tweak them to suit our specific needs. Enter function decorators.

• Understand what is a decorator and what does it does
• Define a wrapper inside a decorator
• Understand parameterized decorators

If we're going to be using functions as data, it would be nice to have metadata for the functions too. Function annotations give us that.

• Add metadata about function parameters
• Add metadata about the function's return value
• Annotations as input to function decorators

Class objects are basically data structures, so it would be useful to be able to rewrite them as they're defined. Class decorators let us do that.

• Know that class decorators work just like function decorators
• Understand that classes are not functions, so the possibilities are different
• Rewrite classes as they're defined

Class decorators take effect after Python has created a class object. If we want our code involved before the class object is created, we need to use a metaclass.

• Understand that classes are objects, and these objects are instances of other classes
• Control class object creation
• Make custom handling inheritable

Pieces of code often come in matched pairs, with one piece needing to run before something happens and the matching piece after. Context managers make sure the pieces match up.

• Context managers plug into the with statement
• Know the two ways to define a synchronous context manager
• Understand that asynchronous context managers are also an option

We can plug code into Python's attribute access mechanism to control what it means to read, write, or delete a member variable.

• Use @property to create simple descriptors
• Write descriptors as classes
• Apply descriptors to simplify a complex I/O task

Testing is critical, but it can feel like a burden. Automated unit testing and test-driven development can solve this problem.

• See how automated testing makes it quick and easy to run tests
• Understand why tests can motivate development rather than the other way around
• Check out that when we reduce the difficulty and increase the frequency, tests are more useful

The unittest package provides a framework for writing automatic tests; let's check it out.

• Learn how we structure a test file
• Know how to compare what happens to what should happen
• Learn we run our tests

We need to separate the code we're testing from everything else. When the code interacts with other objects, we can replace them with mock objects. Let's see how.

• Replace an object with a mock
• Make a mock object imitate the behavior of a real object.
• Check whether a mock object is a user

As a test suite grows, running the tests individually becomes impractical. We need the system to find and run them in large swaths.

• Too many tests in one file becomes a problem, so break it up
• See why running each test individually would be annoying
• Take a look at the test discovery tool that finds all the tests and runs them

Sometimes we want a more flexible test runner than the one built in to unittest. Nose to the rescue.

• Run tests with Nose
• Get a code coverage report
• Run tests in parallel

For the newcomer, it can be difficult to figure out exactly what other people are talking about when they say "reactive programming".

• Publish/subscribe event handling
• Understand stateless functional composition
• Learn asynchronous execution

Many of the discussions of reactive programming are highly theoretical. Building a reactive programming system for ourselves will help show how simple the basic ideas are.

• Wiring Observable
• Write Observer
• Write a demo application

Creating a complete and correct reactive programming framework takes a lot of time and effort. Since somebody's already done it, let's take a look at the result.

• Install RxPY
• Translate our demo
• Learn more RxPY features

We need our web server to scale up and maintain high availability. Let's see how we can do that.

• Add Flexibility
• Add Scalability
• Add Durability

We need a microservice that works well with the web infrastructure or perhaps is even directly accessible to JavaScript running in web browsers.

• Install Flask
• Write our microservice
• Connect to our microservice

Sometimes, we'd rather have all of the protocol-level stuff handled automatically for our microservice.

• Install nameko
• Write our microservice
• Connect to our microservice

Sometimes we need to access or create compiled code and sometimes we don't need it as much as we think. How do we know which is which?

• Know the advantages of compiled code
• Understand the problems that compiled code can cause
• Know the difficulties of working with compiled code

There's a lot of useful code out that wasn't written for Python, but most of it is accessible to C code.

• Link to a dynamic library
• Call library functions
• Add function signatures and other metadata for a more reliable operation

Sometimes we just need to write a code that runs close to the metal. Cython gives us that option.

• Define an extension type
• Define low-level variables
• Define functions

This video provides an overview of the entire course.

The aim of this video is to show how to install R on our system.

• Visit the CRAN website
• Choose the download option based on your operating system
• Follow the standard procedure for installing R

To run and write code in R, we first need to focus on how to get and install the IDE.

• Go to RStudio.com
• Download the correct version of the software
• Install the latest version

We have installed R and RStudio. Now let’s check out how to install the packages.

• Explain what a package contains
• Check out the sources of packages
• Learn how to install them

The aim of this video is to teach you what data types and data structures in R are.

• Explain data types
• Explain data structures
• Show some examples in R

In this video, we will see how to work with vectors in R.

• Explain how to create a vector
• Create different types of vectors
• Access specific items within a vector

The aim of this video is to show how to work with random numbers and do rounding and binning.

• Show how to create random numbers
• How to round
• How to bin numeric vectors

Taking vectors a step ahead, let’s see how we can to handle missing values.

• Explain how to find missing values
• Explain how to omit the missing values

We now know a lot about how vectors work, but how do we get specific items from a vector based on any condition? Let’s check out just that in this video.

• How to write conditions
• How to write complex conditions
• How to use the which() operator to get the required items

This video will introduce a new data structure called list and how to work with it.

• Understand what lists are
• See when lists are used
• Learn how to perform data manipulation with lists

In this video, our goal is to understand how to perform set operations in R.

• Explain the syntax of important set operations such as union, intersect and so on
• Perform the set operations to grasp the usage

What is sampling and sorting and how to do it in R?

• Explain sampling
• Show how to do it in R
• Explain how to sort in R

Checking conditions is often a requirement for a programmer to write maintainable code. Let’s understand how we can check conditions in R.

• Show how to write if and else statements
• Grasp the correct usage of ifelse()

You may have come across several instances whilst coding where you need to perform repetitive operations through loops, right? In this video, we’ll see how to do that in R using for loops.

• Explain the for loop’s syntax
• Show how to skip an iteration
• Check out how to break out from a loop

Let’s explore what data frames are and how to work with them.

• Learn how create a data frame
• Access elements in a data.frame: select, filter, and so on
• Understand the functions related to data frames

In this video, we will check out how to import and export data in R.

• Show the function used to import different forms of data
• Check out the functions used to export various forms of data

The aim of this video is to check out how to work with matrices and frequency tables.

• Learn how to create a matrix
• Access data in a matrix
• Grasp how to generate frequency tables

Our goal in this video is to use W to merge data frames.

• Learn different types of merges
• Understand how to use them in R

How to do aggregation in R?

• Different variations of aggregation
• How to do it in R

In this video, we will look at how to de-aggregate data frames and create cross tabulations.

• Show the melt function
• Show the dcast() function from the reshape2 package

In this video, we will look at how to handle date variables in R.

• Introduce the lubridate package
• Understand the date format
• Learn the Date operations

The goal of this video is to see how to perform string operations in R.

• Introduce the paste function for concatenating
• Introduce the stringr package

Let’s learn how to avoid code replication.

• Introduce functions
• Understand the best practices by writing functions in R

The aim of this video is to understand how to debug and handle errors.

• Learn the 3 ways used to debug in R
• Grasp the 2 ways to handle errors in R

We’ll see in this video how to write fast loops with apply().

• Introduce the syntax
• Explain the difficult part of using apply functions

Sometimes we’d want to iterate through lists. What do we do then? Let’s learn using fast loops with sapply, vapply and lapply to help us achieve this goal.

• Explain sapply
• Explain lapply and how it is different

How to make plots and customize them.

• Show how to use the plot function
• Make a scatterplot
• Explain the arguments and features of the plot function

Sometimes, just a single Y axis is not enough. It becomes difficult to depict the variations for two variables on different scales in the same chart. To solve this, we’ll look at how to make a plot with two Y axes.

• Show the method
• Show the syntax to make two Y axes

In this video, we will learn how to make multiple plots and custom layout to get better at our analyzing skills.

• Show how to make multiple plots
• Show how to customize plot layouts

The aim of this video is to create different types of plots.

• Show how to make a histogram, a bar chart, and a density plot
• Show how to make dot plots and box plots

What are the steps and actions one needs to do as part of data analysis before jumping to predictive modeling? Let’s understand this better.

• Explain the different steps
• Show how to do univariate analysis of numeric variables
• Show how to do univariate analysis of categorical variables

The aim of this video is to teach you what normal distribution, central limit theorem, and confidence intervals are.

• Explain the concept behind normal distribution and CLT
• Show the R code implementation
• Explain confidence intervals and implement them in R

In this video, we will understand correlation and Covariance, the concept behind them, and their implementation in R.

• Explain correlation and covariance
• The concept and the difference between them
• Implement them in R

What is the chi-square statistic, when is it used, and how to do the chi-sq test?

• Explain the chi-sq statistic and its purpose
• Explain the meaning behind it
• Show the R implementation

What is ANOVA, its purpose, when to use it, and how to implement it in R?

• Explain the concept and purpose
• When to use it
• How to implement it in R

What are the other commonly used statistical tests in R and how to implement them?

• Explain the one and two sample t-test, parametric versus non-parametric
• Explain the Wilcoxon signed rank test
• Show the R implementation

All knowledge is incomplete without being put to practice. We’ve got a good taste of the core concepts that govern statistical analysis with R. Let’s solve the challenges pertaining to data manipulation in this video.

• Run through the basics of data handling
• Understand the Unique key
• Solve the proposed challenges

What is data if not represented visually! We have solved challenges related to data manipulation. Now it’s time to tackle visualization in this video.

• Create a histogram on the given data
• Create a line chart with multiple lines
• Create a box plot

Practice solving exercises that involve making statistical inferences.

• Test the statistical significance between two continuous variables
• Problem that tests statistical significance between continuous and categorical variable

The aim of this video is to introduce the magrittr package, its significance, and features such as pipe operators.

• Why use magrittr and pipes
• Explain various pipe operators in magrittr
• Show the R code implementation and suitable examples

Understand and use the 7 data manipulation verbs.

• What are the 7 data manipulation verbs?
• Why are they simple and widely adopted?
• Implementation in R for all the verbs

How to group datasets by one or more variables using dplyr.

• Explain the process of grouping
• Explain the group_by and summarize functions
• Show the implementation in R

How to join two tables using the two table verbs of dplyr.

• Explain the two table verbs
• Explain the different types of joins
• Show the implementation in R

How to work with databases with DplyR.

• Create a SQLite DB and upload data
• Pull partial data and do manipulation
• Download full data and see the SQL

Understand the basics of data.table; do filter and select operations.

• Explain the purpose and significance of data.table
• How the syntax differs generally and how to filter and select
• Show the R code implementation

Understand the syntax; create and update columns in a data.table.

• Understand the general syntax in sync with SQL syntax
• Create new columns
• Update the columns

Learn how to aggregate data.tables. Also learn the .N and .I operators.

• The syntax to group data
• The .N and .I operators – using them effectively
• The R code implementation

Understand and implement chaining, keys, functions, and .SD.

• How to set keys and why
• Write apply family functions within data.table
• Show the usage of .SD

How to write for-loops with set, set keys, and join data.tables?

• Explain how to use set() and why it’s great
• How to set keys and filter data.tables
• Show how to do joins using square brackets and merge function

This video gives an overview of the entire course.

In this video, we will take a look at how to perform univariate analysis.

• Learn the use of univariate analysis on continuous variables and what the metrics are
• Understand how to perform univariate analysis on categorical variables
• See how to compute the metrics in R

The goal of this video is to perform bivariate analysis in R using three cases.

• Perform bivariate analysis using correlation analysis
• Perform bivariate analysis using ANOVA
• Perform bivariate analysis using the Chi-Sq statistic

In this video, we will see how to detect and treat outliers.

• Check out how to detect outliers in a continuous variable
• Get to know the ways to treat outliers
• See how to code in R

The goal of this video is to see how to treat missing values in R.

• Understand the different types of missing values
• Look at the ways to treat missing values
• Check out how to code in R

In this video we'll see what is linear regression, its purpose, when to use it, and how to implement in R.

• The purpose of linear regression and the concept
• How to build regression model in R
• How to predict and compute accuracy measures.

We'll see how to interpret regression results and Interaction effects in this video

• Explain the summary of regression results
• Explain the various terms
• Add interaction term to the model

In this video we will discuss what is residual analysis and detect multivariate outliers using Cook's Distance

• Explain the meaning behind residual plots and its interpretation
• Explain Cook's Distance, its meaning and significance
• Implement them in R

The goal of this video is to understand how to do model selection and comparison using best subsets, stepwise regression and ANOVA.

• Explain Best subsets and do it in R
• Stepwise regression
• Compare models using ANOVA

In this video we will see how to do k-fold cross validation in R.

• Explain the concept
• Show how to implement it in R

The goal of this video is check out how to build non-linear regression models using Splines and GAMs.

• Explain the concept behind splines
• Implement splines in R
• Explain and implement GAMS

In this video, we will understand the concept and working of naïve Bayes classifier and how to implement the R code.

• Understand the concept and implementation of naïve Bayes by learning conditional probability and Bayes rule
• Solve a mathematical example
• Implement in R

In this video, we will look at what k-nearest neighbors algorithms, how does it works and how to implement it in T.

• Explain the concepts
• Show how it works
• How to implement it in R

The goal of this video is to understand how decision trees work, what they are used for, and how to implement then.

• Explain how decision trees work and their usage
• Show the concepts of cTree, rpart and C5.0
• Implement in R

The goal of this video is know what the various features of the caret package are and how to build predictive models.

• Explain the workflow
• Show preprocessing, model tuning, control parameters, and parallelization
• Implement in R

The goal of this video is to know how to do feature selection before building predictive models.

• Explain the concepts behind RFE, Boruta and variable importance
• Show the references for variable importance
• Implement in R

In this video, we will look at how support vector machines work.

• Explain kernel trick, hyper places, linearly non-separable case
• Show how to tune with various kernels
• Implement in R

In this video, we will look at the concept behind bagging and random forests and how to implement it to solve problems.

• How does bagging work
• How does random forests work
• Understand the implementation in R

Let's understand what boosting is and how stochastic gradient boosting works with GBM.

• Explain boosting and how the algorithm works
• How to tune it
• Show how to implement in R

In this video, we will look at what regularization is, ridge and lasso regression, and how to implement it.

• Learn the concept of regularization and shrinkage methods
• Understand Ridge and Lasso regression, and how are they different
• Implement in R using the glmnet package

Let's look at how XG Boost works and how to implement it in this video.

• Understand the driving principle behind XG Boost
• Understand how to the structure of tuning parameters
• Implement in R

Our goal in this video would be to reduce the dimensionality of data with principal components, and understand the concept and how to implement it in R.

• Understand the purpose and concepts behind principal component analysis
• Plot it and interpret the principal components and Biplot
• Implement in R

In this video, we will understand the k-means clustering algorithm and implement it using the principal components.

• Understand k-means
• Perform clustering with principal components
• Implement in R

In this video, we will analyze the clustering tendency of a dataset and identify the ideal number of clusters or groups.

• Explain the Hopkins statistic for clustering tendency
• Explain silhouette width for optimal number of clusters
• Implement in R

The goal of this video is to understand the logic of hierarchical clustering, types, and how to implement it in R.

• Understand the logic
• Understand the linkage methods
• Implement in R

How to use affinity propagation to cluster data points? How is it different from conventional algorithms?

• Explain the general concept behind the working of affinity propagation algorithm
• Show how it is different from k-means and hierarchical clustering
• Implement in R, plot it, and solve a mini challenge

How to build recommendation engines to recommend products/movies to new and existing users?

• Explore the various approaches to make recommendations
• Explain the collaborative filtering algorithm
• Implement it R and solve coding challenges using POPULAR and association mining methods

The goal of this video is to understand what a time series is, how to create time series of various frequencies, and the enhanced facilities available in the xts package.

• Create a time series and understand its components
• Get an overview of the xts package
• Implement in R

The goal of this video is to understand the characteristics of a time series: stationarity and how to de-trend and de-seasonalize a time series.

• How to make a time series?
• How to de-trend and de-seasonalize
• Implement in R

In this video, we will introduce the characteristics of time series such as ACF, PACF, and CCF; why they matter; and how to interpret them.

• Explain lags, ACF, PACF, and CCF
• Interpret the meaning
• Implement in R

Our goal in this video would be to understand moving average and exponential smoothing and use it to forecast.

• Explain moving average
• Explain exponential smoothing
• Implement in R

In this video, we will understand how double exponential smoothing and holt winter forecasting works, when to use them, and how to implement them in R.

• How double exponential smoothing works and how it is different from holt winters
• Understand the calculations
• Implement in R

Let's look at what ARIMA forecasting is, understand the concepts, and learn how ARIMA modelling works in this video.

• Understand the full form and components of the ARIMA model
• Explain how ARIMA works, its orders and configurations, and how to choose the p,d and q
• Implement auto.arima() in R

In this video, we'll take a look at how to scrape data from web pages and how to clean and process raw web and other textual data.

• Show a web scraping example with rvest
• Explain the structure of a typical webpage and basics of HTML and extract selector paths
• Process and clean text data

Our goal in this video is to know how to process texts using tm package and understand the significance of TF-IDF and its implementation. Finally, we see how to draw a word cloud in R.

• Explain the features of tm package
• Explain TF-IDF and itsuse
• Draw a word cloud from a text document

Let's see how to use cosine similarity and latent semantic analysis to find and map similar documents.

• Explain the concept behind cosine similarity
• Explain LSA
• Implementation in R with challenge

In this video, we will see how to extract the underlying topics in a document, the keywords related to each topic and the proportion of topics in each document.

• Explain the concept behind LDA
• Show a real application to extract topics from wiki docs
• Show implementation and interpretation in R

Let's check out how to perform sentiment analysis and scoring in R.

• Show facilities in the tidytext package, the workflow and lexicons
• Show a Syuzhet application
• Implement in R

How to classify texts with machine learning algorithms using the RTextTools package?

• Explain the general workflow
• Explain facilities in RTextTools
• Implement in R

The goal of this videos is to understand what is the basic structure of to make charts with ggplot, how to customize the aesthetics, and manipulate the theme elements.

• Explain the structure of ggplot and how it is different from base graphics
• Modify the aesthetics and theme
• Implement in R and solve a challenge

In this video, we will see how to manipulate the legend the way we want and how to add texts and annotation in ggplot.

• Show the syntax to manipulate the legend
• Add texts using geom_text and add annotations using grob
• Implement in R

The goal of this video is to understand how to plot multiple plots in the same chart and how to change the layouts of ggplot.

• Show how to use facet_wrap and facet_grid to make multiple charts for various levels of one or two variables
• Show how to change the layout of a ggplot using the gridExtra package
• Implement in R and solve a challenge on what was covered

How to make various types of plots in ggplot such as bar chart, time series, boxplot, ribbon chart,and so on.

• Explain the syntax for various plots
• Learn Scatterplot, Jitter, Counts plot, Bar chart, Histogram, Box plot, Violin plot, Time series chart, Multiple Time Series, and Ribbon Area
• Implement in R and practice with a mini challenge

In this video, we will understand what the popular ggplot extensions are, and where to find them, and their applications.

• Show where to find the ggplot extensions
• Show the usage of ggfortify, ggthemes, ggrepel and so on
• Show how to implement in R

We will discuss the best practices that should be followed to minimize code runtime in this video.

• Show various practices like vectorization, pre-allocation, and reducing condition checks inside for loops
• Understand the smart usage of the which() function, and also the use of ifelse, apply family, and byte code compilation
• Show how to implement in R with working examples

Let's tackle the implementation of parallel computing in R.

• Show how to register the cores for parallel processing
• Show how to implement parallel loops with foreach
• Show how to implement in R

The goal of this video is understand how to work with DplyR and pipes.

• Explain how pipes work and their applications
• Explain the data manipulation verbs of DplyR
• Implement and demonstrate in R

In this video, we will discuss how to manipulate data with the data.table package, how to achieve maximum speed, and what the various features of data.table are.

• Show the general syntax of the data.table package
• Show how to do basic data manipulation operations, functionality of keys, and dcast.data.table
• Show how to implement in R

Our main focus in this video is to understand how to write C++ code and make it work in R. Also leverage the speed of C++ in R, interface Rcpp with R, and write Rcpp code.

• Show how to interface Rcpp with R
• Show the features of Rcpp and learn by doing easy and hard examples
• Implement in R

We'll take a look at the components of an R package in this video.

• See the mandatory components such as R, Description and Namespace
• See the optional components
• Understand the purpose of each component and what goes inside them

In this video, we will look at how to create an R Package so that it can be submitted to CRAN.

• Understand the steps to build an R package
• Document it
• Check it and host on GitHub

We will understand the mandatory checks and common problems faced by developers when creating R packages in this video.

• Understand the important checks
• Learn the common problems and how to work around them
• Show it in R

The goal of this video is to show how to submit an R package to CRAN.

• See how to submit and how to do resubmissions
• Verify the details and submit the package
• Confirm submission