Codeless Time Series Analysis with KNIME: A practical guide to implementing forecasting models for time series analysis applications

Cover
Title Page
Copyright and Credits
Dedication
Contributors
Table of Contents
Preface
Part 1: Time Series Basics and KNIME Analytics Platform
Chapter 1: Introducing Time Series Analysis
	Understanding TSA
	Exploring time series properties and examples
		Continuous and discrete time series
		Independence and serial correlation
		Time series examples
	TSA goals and applications
		Goals of TSA
		Domains of applications and use cases
	Exploring time series forecasting techniques
		Quantitative forecasting properties and techniques
	Summary
	Questions
Chapter 2: Introduction to KNIME Analytics Platform
	Exploring the KNIME software
		Introducing KNIME Analytics Platform for creating data science applications
		Introducing KNIME Server for productionizing data science applications
	Introducing nodes and workflows
		Introducing nodes
		Introducing workflows
		Searching for and sharing resources on the KNIME Hub
	Building your first workflow
		Creating a new workflow (group)
		Reading and transforming data
		Filtering rows
		Visualizing data
		Building a custom interactive view
		Documenting workflows
	Configuring the time series integration
		Introducing the time series components
		Configuring Python in KNIME
	Summary
	Questions
Chapter 3: Preparing Data for Time Series Analysis
	Introducing different sources of time series data
	Time granularity and time aggregation
		Defining time granularity
		Finding the right time granularity
		Aggregating time series data
	Equal spacing and time alignment
		Explaining the concept of equal spacing
	Missing value imputation
		Defining the different types of missing values
		Introducing missing value imputation techniques
	Summary
	Questions
Chapter 4: Time Series Visualization
	Technical requirements
	Introducing an energy consumption time series
		Describing raw energy consumption data
		Clustering energy consumption data
	Introducing line plots
		Displaying simple dynamics with a line plot
		Interpreting the dynamics of a time series based on a line plot
		Building a line plot in KNIME
	Introducing lag plots
		Introducing insights derived from a lag plot
		Building a lag plot in KNIME
	Introducing seasonal plots
		Comparing seasonal patterns in a seasonal plot
		Building a seasonal plot in KNIME
	Introducing box plots
		Inspecting variability of data in a box plot
		Building a box plot in KNIME
	Summary
	Questions
Chapter 5: Time Series Components and Statistical Properties
	Technical requirements
	Trend and seasonality components
		Trend
		Seasonality
		Decomposition
	Autocorrelation
	Stationarity
	Summary
	Questions
Part 2: Building and Deploying a Forecasting Model
Chapter 6: Humidity Forecasting with Classical Methods
	Technical requirements
	The importance of predicting the weather
		Other IoT sensors
		The use case
	Streaming humidity data from an Arduino sensor
		What is an Arduino?
		Moving data to KNIME
		Storing the data to create a training set
	Resampling and granularity
		Aligning data timestamps
		Missing values
		Aggregation techniques
	Training and deployment
		Types of classic models available in KNIME
		Training a model in KNIME
		Available deployment options
		Building the workflow
		Writing model predictions to a database
	Summary
	Questions
Chapter 7: Forecasting the Temperature with ARIMA and SARIMA Models
	Recapping regression
		Defining a regression
	Introducing the (S)ARIMA models
		Requirements of the (S)ARIMA model
		How to configure the ARIMA or SARIMA model
	Fitting the model and generating forecasts
		The data
	Summary
	Further reading
	Questions
Chapter 8: Audio Signal Classification with an FFT and a Gradient-Boosted Forest
	Technical requirements
	Why do we want to classify a signal?
	Windowing your data
		Windowing your data in KNIME
	What is a transform?
	The Fourier transform
		Discrete Fourier Transform (DFT)
		Fast Fourier Transform (FFT)
		Applying the Fourier transform in KNIME
	Preparing data for modeling
		Reducing dimensionality
	Training a Gradient Boosted Forest
		Applying the Fourier transform in KNIME
		Applying the Gradient Boosted Trees Learner
	Deploying a Gradient Boosted Forest
	Summary
	Questions
Chapter 9: Training and Deploying a Neural Network to Predict Glucose Levels
	Technical requirements
	Glucose prediction and the glucose dataset
		Glucose prediction
		The glucose dataset
	A quick introduction to neural networks
		Artificial neurons and artificial neural networks
		The backpropagation algorithm
		Other types of neural networks
	Training a feedforward neural network to predict glucose levels
		KNIME Deep Learning Keras Integration
		Building the network
		Training the network
		Scoring the network and creating the output rule
	Deploying an FFNN-based alarm system
	Summary
	Questions
Chapter 10: Predicting Energy Demand with an LSTM Model
	Technical requirements
	Introducing recurrent neural networks and LSTMs
		Recapping recurrent neural networks
		The architecture of the LSTM unit
		Forget Gate
		Input Gate
		Output Gate
	Encoding and tensors
		Input data
		Reshaping the data
	Training an LSTM-based neural network
		The Keras Network Learner node
		Deploying an LSTM network for future prediction
		Scoring the forecasts
	Summary
		Questions
Chapter 11: Anomaly Detection – Predicting Failure with No Failure Examples
	Technical requirements
	Introducing the problem of anomaly detection in predictive maintenance
		Introducing the anomaly detection problem
		IoT data preprocessing
		Exploring anomalies visually
	Detecting anomalies with a control chart
		Introducing a control chart
		Implementing a control chart
	Predicting the next sample in a correctly working system with an auto-regressive model
		Introducing an auto-regressive model
		Training an auto-regressive model with the linear regression algorithm
		Deploying an auto-regressive model
	Summary
	Questions
Part 3: Forecasting on Mixed Platforms
Chapter 12: Predicting Taxi Demand on the Spark Platform
	Technical requirements
	Predicting taxi demand in NYC
	Connecting to the Spark platform and preparing the data
		Introducing the Hadoop ecosystem
		Accessing the data and loading it into Spark
		Introducing the Spark compatible nodes
	Training a random forest model on Spark
		Exploring seasonalities via line plots and auto-correlation plot
		Preprocessing the data
		Training and testing the random forest model on Spark
	Building the deployment application
		Predicting the trip count in the next hour
		Predicting the trip count in the next 24 hours
	Summary
	Questions
Chapter 13: GPU Accelerated Model for Multivariate Forecasting
	Technical requirements
	From univariate to multivariate – extending the prediction problem
	Building and training the multivariate neural architecture
	Enabling GPU execution for neural networks
		Setting up a new GPU Python environment
		Switching Python environments dynamically
	Building the deployment application
	Summary
	Questions
Chapter 14: Combining KNIME and H2O to Predict Stock Prices
	Technical requirements
	Introducing the stock price prediction problem
	Describing the KNIME H2O Machine Learning Integration
		Starting a workflow running on the H2O platform
		Introducing the H2O nodes for machine learning
	Accessing and preparing data within KNIME
		Accessing stock market data from Yahoo Finance
		Preparing the data for modeling on H2O
	Training an H2O model from within KNIME
		Optimizing the number of predictor columns
		Training, applying, and testing the optimized model
	Consuming the H2O model in the deployment application
	Summary
	Questions
	Final note
Answers
	Chapter 1
	Chapter 2
	Chapter 3
	Chapter 4
	Chapter 5
	Chapter 6
	Chapter 7
	Chapter 8
	Chapter 9
	Chapter 10
	Chapter 11
	Chapter 12
	Chapter 13
	Chapter 14
Index
About Packt
Other Books You May Enjoy