There are currently no items in your shopping cart.

User Panel

Forgot your password?.

Learning Path: From Python Programming to Data Science

Video Introducing this tutorial

The Course Overview
Python Basic Syntax and Block Structure
Built-in Data Structures and Comprehensions
First-Class Functions and Classes
Extensive Standard Library
New in Python 3.5
Downloading and Installing Python
Using the Command-Line and the Interactive Shell
Installing Packages with pip
Finding Packages in the Python Package Index
Creating an Empty Package
Adding Modules to the Package
Importing One of the Package's Modules from Another
Adding Static Data Files to the Package
PEP 8 and Writing Readable Code
Using Version Control
Using venv to Create a Stable and Isolated Work Area
Getting the Most Out of docstrings 1: PEP 257 and docutils
Getting the Most Out of docstrings 2: doctest
Making a Package Executable via python -m
Handling Command-Line Arguments with argparse
Interacting with the User
Executing Other Programs with Subprocess
Using Shell Scripts or Batch Files to Run Our Programs
Using concurrent.futures
Using Multiprocessing
Understanding Why This Isn't Like Parallel Processing
Using the asyncio Event Loop and Coroutine Scheduler
Waiting for Data to Become Available
Synchronizing Multiple Tasks
Communicating Across the Network
Using Function Decorators
Function Annotations
Class Decorators
Context Managers
Understanding the Principles of Unit Testing
Using the unittest Package
Using unittest.mock
Using unittest's Test Discovery
Using Nose for Unified Test Discover and Reporting
What Does Reactive Programming Mean?
Building a Simple Reactive Programming Framework
Using the Reactive Extensions for Python (RxPY)
Microservices and the Advantages of Process Isolation
Building a High-Level Microservice with Flask
Building a Low-Level Microservice with nameko
Advantages and Disadvantages of Compiled Code
Accessing a Dynamic Library Using ctypes
Interfacing with C Code Using Cython
The Course Overview
Getting started with Python
Getting Data using the Twitter API
Collecting and Storing Tweets
Database Design
Pandas and Databases
Panda Series, Dataframes, and Columnar Operations
Grouping Operations and Working with Date Columns
Merging Operations and Exporting data to JSON/CSV
Array Features, Bucketting Arrays and Histogram Functions
Simple Aggregations
Linear Algebra
Introducting PyQT and MatplotLib
Creating Charts
Simple XY Plots with Axis Scales
Introduction to the NTLK Package
Bag of Words
Classification of Words
Simple Sentiment Analysis
Grouping By Dimensions and Classification of Data Types
Trend Analysis and Deriving New Metrics
Correlation Analysis
Course Summary
The Course Overview
Importing Data from CSV
Importing Data from Microsoft Excel Files
Importing Data from Fix-Width Files
Importing Data from Tab Delimited Files
Importing Data from a JSON Resource
Importing Data from a Database
Cleaning Up Data from Outliers
Importing Image Data into NumPy Arrays
Generating Controlled Random Datasets
Smoothing Noise in Real-World Data
Defining Plot Types and Drawing Sine and Cosine Plots
Defining Axis Lengths and Limits
Defining Plot Line Styles, Properties, and Format Strings
Setting Ticks, Labels, and Grids
Adding Legends and Annotations
Moving Spines to Center
Making Histograms
Making Bar Charts with Error Bars
Making Pie Charts Count
Plotting with Filled Areas
Drawing Scatter Plots with Colored Markers
Adding a Shadow to the Chart Line
Adding a Data Table to the Figure
Customizing Grids
Creating Contour Plots
Filling an Under-Plot Area
Drawing Polar Plots
Visualizing the filesystem Tree Using a Polar Bar
Creating 3D Bars
Creating 3D Histograms
Animating with OpenGL
Plotting with Images
Displaying Images with Other Plots in the Figure
Plotting Data on a Map Using Basemap
Generating CAPTCHA
Understanding Logarithmic Plots
Creating a Stem Plot
Drawing Streamlines of Vector Flow
Using Colormaps
Using Scatter Plots and Histograms
Plotting the Cross Correlation Between Two Variables
The Importance of Autocorrelation
Drawing Barbs
Making a Box-and-Whisker Plot
Making Gantt Charts
Making Error Bars
Making Use of Text and Font Properties
Understanding the Difference between pyplot and OO API
Preprocessing Data Using Different Techniques
Label Encoding
Building a Linear Regressor
Regression Accuracy and Model Persistence
Building a Ridge Regressor
Building a Polynomial Regressor
Estimating housing prices
Computing relative importance of features
Estimating bicycle demand distribution
Building a Simple Classifier
Building a Logistic Regression Classifier
Building a Naive Bayes’ Classifier
Splitting the Dataset for Training and Testing
Evaluating the Accuracy Using Cross-Validation
Visualizing the Confusion Matrix and Extracting the Performance Report
Evaluating Cars based on Their Characteristics
Extracting Validation Curves
Extracting Learning Curves
Extracting the Income Bracket
Building a Linear Classifier Using Support Vector Machine
Building Nonlinear Classifier Using SVMs
Tackling Class Imbalance
Extracting Confidence Measurements
Finding Optimal Hyper-Parameters
Building an Event Predictor
Estimating Traffic
Clustering Data Using the k-means Algorithm
Compressing an Image Using Vector Quantization
Building a Mean Shift Clustering
Grouping Data Using Agglomerative Clustering
Evaluating the Performance of Clustering Algorithms
Automatically Estimating the Number of Clusters Using DBSCAN
Finding Patterns in Stock Market Data
Building a Customer Segmentation Model
Building Function Composition for Data Processing
Building Machine Learning Pipelines
Finding the Nearest Neighbors
Constructing a k-nearest Neighbors Classifier
Constructing a k-nearest Neighbors Regressor
Computing the Euclidean Distance Score
Computing the Pearson Correlation Score
Finding Similar Users in a Dataset
Generating Movie Recommendations
Preprocessing Data Using Tokenization
Stemming Text Data
Converting Text to Its Base Form Using Lemmatization
Dividing Text Using Chunking
Building a Bag-of-Words Model
Building a Text Classifier
Identifying the Gender
Analyzing the Sentiment of a Sentence
Identifying Patterns in Text Using Topic Modelling
Reading and Plotting Audio Data
Transforming Audio Signals into the Frequency Domain
Generating Audio Signals with Custom Parameters
Synthesizing Music
Extracting Frequency Domain Features
Building Hidden Markov Models
Building a Speech Recognizer
Transforming Data into the Time Series Format
Slicing Time Series Data
Operating on Time Series Data
Extracting Statistics from Time Series
Building Hidden Markov Models for Sequential Data
Building Conditional Random Fields for Sequential Text Data
Analyzing Stock Market Data with Hidden Markov Models
Operating on Images Using OpenCV-Python
Detecting Edges
Histogram Equalization
Detecting Corners and SIFT Feature Points
Building a Star Feature Detector
Creating Features Using Visual Codebook and Vector Quantization
Training an Image Classifier Using Extremely Random Forests
Building an object recognizer
Capturing and Processing Video from a Webcam
Building a Face Detector using Haar Cascades
Building Eye and Nose Detectors
Performing Principal Component Analysis
Performing Kernel Principal Component Analysis
Performing Blind Source Separation
Building a Face Recognizer Using a Local Binary Patterns Histogram
Building a Perceptron
Building a Single-Layer Neural Network
Building a deep neural network
Creating a Vector Quantizer
Building a Recurrent Neural Network for Sequential Data Analysis
Visualizing the Characters in an Optical Character Recognition Database
Building an Optical Character Recognizer Using Neural Networks
Plotting 3D Scatter plots
Plotting Bubble Plots
Animating Bubble Plots
Drawing Pie Charts
Plotting Date-Formatted Time Series Data
Plotting Histograms
Visualizing Heat Maps
Animating Dynamic Signals
The Course Overview
What Is Deep Learning?
Open Source Libraries for Deep Learning
Deep Learning Hello World! Classifying the MNIST Data
Introduction to Backpropagation
Understanding Deep Learning with Theano
Optimizing a Simple Model in Pure Theano
Keras Behind the Scenes
Fully Connected or Dense Layers
Convolutional and Pooling Layers
Large Scale Datasets, ImageNet, and Very Deep Neural Networks
Loading Pre-trained Models with Theano
Reusing Pre-trained Models in New Applications
Theano for Loops – the scan Module
Recurrent Layers
Recurrent Versus Convolutional Layers
Recurrent Networks –Training a Sentiment Analysis Model for Text
Bonus Challenge – Automatic Image Captioning
Captioning TensorFlow – Google's Machine Learning Library
Using Subplots