Index
A
- Action methods, Apache Spark
- actions / Actions
- activation function
- actor ! PoisonPill method / The master Actor
- Actor model
- Actors
- actors
- actorSystem.shutdown method / The master Actor
- adaptive model
- aggregate functions
- aggregation effect
- aggregation operations
- aggregations
- Akka
- Akka, supervision strategies
- one-for-one strategy / Akka
- all-for-one strategy / Akka
- Akka documentation / What we have not talked about
- Akka library / Futures example – stock price fetcher
- Algebird
- AlgeBird 2.10
- algebraic and numerical libraries
- alternative techniques, data preprocessing
- Amazon Web Services (AWS)
- American Association of Individual Investors (AAII) / Test case
- AMPLab / UC Berkley
- annual dividend yield
- anti-goal state
- Apache Commons Math
- Apache Commons Math library
- Apache Parquet
- Apache Public License 2.0
- Apache Spark
- Apache Spark, performance
- APIs
- application
- applications
- apply method / Constructing a vector from values
- approximate fitness function
- arbitrary transformations
- arrays
- Arrays / A whirlwind tour of JSON
- artificial neural networks
- ATLAS
- attributes
- authentication
- autonomous systems
- autoregressive integrated moving average (ARIMA)
- autoregressive models
- autoregressive moving average (ARMA)
- Avro data model
B
- backend
- Bank of America (BAC)
- batch EM / Online EM
- batch training
- Baum-Welch estimator (EM)
- Bayesian network
- behavioral hidden Markov models
- Bellman optimality equations
- benchmark framework
- Berkeley Data Analytics Stack (BDAS)
- Bernoulli mixture model
- Bernoulli model
- BGFS method
- bias
- bias-variance decomposition
- bias input
- binary classification
- binary classification, with LogisticRegression and SVM
- BinaryClassificationMetrics instance
- binary SVC
- binomial classification, logistic regression
- BLAS
- BLAS library / Basic Breeze data types
- blocking, futures
- bloom filters
- Body Mass Index (BMI) / DataFrames – a whirlwind introduction
- Bokeh-Scala
- BooleanColumnExtensionMethods class
- Bootstrap layouts
- Breeze
- Breeze-viz
- breeze-viz / Creating scatter plots with Bokeh-Scala
- Breeze 0.8
- Breeze Scala
C
- C-penalty, binary SVC
- C-SVM
- cake pattern
- callbacks, futures
- Casbah
- Casbah query DSL
- case classes
- cash per share
- centroid
- characteristics, Kalman filter
- Chicago Board Options Exchange (CBOE)
- chill library
- chromosomes
- class constructor template
- classes
- classification model, evaluation factors
- classification model, terminology
- class prior
- class prior probability
- client-server applications
- client-side program
- cluster, K-means
- clustering
- clustering algorithms
- code snippets
- collision / Transformers
- Colt 1.2.0
- common discriminative kernels
- companion objects
- complex queries / Complex queries
- component, reinforcement learning
- components, parallel collections
- components, XCS
- computational workflow
- compute method
- conditional dependency / Training
- conditional independence
- configuration, GA
- configuration options
- configuration parameters, SVM
- conjugate gradient method
- Connection class
- connectionism
- considerations, EM
- considerations, K-means
- considerations, PCA
- constrained state-transition
- constructive tuning
- consumer price index (CPI)
- Consumer Price Index (CPI)
- context.stop(childActorRef) method / The master Actor
- context.stop(self) method / The master Actor
- context bound / Coding against type classes
- continuation-passing style (CPS)
- continuous values
- convex minimization
- convolution / DFT-based filtering
- Cooley-Tukey algorithm
- core parking
- correction, recursive algorithm
- cost/unfitness function
- count method / Scoring of terms
- CRF
- CRF, tests
- cross-validation
- crossover
- CSV
- CSV files
- csvread function / How it works...
- curve-fitting algorithms
- custom supervisor strategies / Custom supervisor strategies
- custom type serialization
D
- Darwinian process
- data
- data, XCS
- data access layer
- database metadata
- data chunks
- data elements
- data extraction
- DataFrame
- creating, from CSV / Creating a DataFrame from CSV, How to do it..., There's more…
- URL / Creating a DataFrame from CSV, Manipulating DataFrames, Creating a DataFrame from Scala case classes
- manipulating / Manipulating DataFrames, How to do it...
- schema, printing / Printing the schema of the DataFrame
- data, sampling / Sampling the data in the DataFrame
- columns, selecting / Selecting DataFrame columns
- data by condition, filtering / Filtering data by condition
- data, sorting in frame / Sorting data in the frame
- columns, renaming / Renaming columns
- treating, as relational table / Treating the DataFrame as a relational table
- two DataFrame, joining / Joining two DataFrames
- inner join / Inner join
- right outer join / Right outer join
- left outer join / Left outer join
- saving, as file / Saving the DataFrame as a file
- creating, from Scala case classes / Creating a DataFrame from Scala case classes, How to do it..., How it works...
- JSON, loading / Loading JSON into DataFrames, How to do it…
- JSON file, reading with SQLContext.jsonFile / Reading a JSON file using SQLContext.jsonFile
- text file, converting to JSON RDD / Reading a text file and converting it to JSON RDD
- text file, reading / Reading a text file and converting it to JSON RDD
- schema, explicitly specifying / Explicitly specifying your schema, There's more…
- data, preparing / Preparing data in Dataframes, How to do it...
- DataFrames
- data frames
- data mapper pattern
- data preprocessing
- data science
- data scientist
- dataset
- data shuffling
- DataSource class
- data sources
- data types
- data types, Breeze
- about / Basic Breeze data types
- vectors / Vectors
- matrices / Matrices
- vectors, building / Building vectors and matrices
- matrices, building / Building vectors and matrices
- indexing / Advanced indexing and slicing
- slicing / Advanced indexing and slicing
- vectors, mutating / Mutating vectors and matrices
- matrices, mutating / Mutating vectors and matrices
- matrix multiplication / Matrix multiplication, transposition, and the orientation of vectors
- matrix transposition / Matrix multiplication, transposition, and the orientation of vectors
- vectors, orientation / Matrix multiplication, transposition, and the orientation of vectors
- data preprocessing / Data preprocessing and feature engineering
- feature engineering / Data preprocessing and feature engineering
- function optimization / Breeze – function optimization
- numerical derivatives / Numerical derivatives
- regularization / Regularization
- DBpedia / Basics of information retrieval
- decision-making agent
- decoding (CF-3), HMM
- DenseVector or DenseMatrix
- dependency injection
- descriptive model
- design
- designing
- design principles, Apache Spark
- design template, for classifiers
- destructive tuning
- DFT
- DFT-based filtering
- DFT convolution / DFT-based filtering
- dimension reduction
- Directed Acyclic Graph (DAG) / Submitting jobs to the Spark cluster (local)
- directed acyclic graph (DAG) / Lifting the hood
- directed graphical models
- Disambiguate / Basics of information retrieval
- discount coefficient for future rewards
- discrete Fourier transform (DFT)
- discrete Markov chain
- discrete model parameters
- discretization
- discriminative models
- dispatcher
- dividend coverage ratio
- DNA
- documents
- DocumentsSource class
- domain
- Domain Specific Languages (DSL)
- Dow Jones Index Data Set
- Driver program / There's more…
- drivers
- drop method / Labeling
- DStreams
- dynamic programming
- dynamic routing
E
- earnings per share (EPS)
- EC2
- eigenvalue
- Eigenvalue decomposition
- ElasticSearch
- Elasticsearch
- element-wise operators
- EM
- encapsulation
- ensemble learning
- enumerations
- Erlang
- error backpropagation, MLP training cycle
- error insensitive zone
- estimators
- ETL tool
- evaluation
- evaluation (CF-1), HMM
- event bus / The event bus
- evidence
- evolution
- evolutionary computing
- evolutionary fitness function
- example data
- exception handling
- exchange-traded funds (ETF)
- exchange-traded funds (ETFs)
- execution contexts
- execution state, HMM
- experimentation, recursive algorithm
- exploitation phase, XCS
- exploration, temporal difference
- exploration phase, XCS
- exponential moving average
- extended Kalman filter (EKF)
- extended Kalman filters (EKF)
- extended learning classifiers (XCS)
- extraction
- extractor function / Labeling
F
- fast Fourier transform (FFT)
- feature reduction
- features, model
- features, Scala
- features extraction
- features selection
- Federal Election Commission (FEC)
- Federal Election Commission (FEC) data
- Federal Fund rate
- Federal fund rate (FDF)
- FFNN
- filtering
- final val
- finances 101
- first-order discrete Markov chain
- first-order predicate logic
- fitness
- fixed fitness function
- flat encoding
- floating point format
- follower network crawler / Follower network crawler, Fault tolerance
- fork-join pool
- Fourier analysis
- Fourier transform
- frameworks
- frequency domain
- fully connected neural network
- function approximation
- function optimization / Breeze – function optimization
- fundamental analysis
- futures
G
- GA
- GA, applications
- GA, components
- GARCH
- Gauss-Newton technique
- Gaussian mixture / Classification
- Gaussian noise
- Gaussian probability density / Classification
- Gene class
- generative models
- generic message handler
- genes
- genetic decoding
- genetic encoding
- genetic fitness function
- genetic operations
- genetic operators
- GitHub
- GitHub API
- GitHub servers
- GitHub user data
- GMM
- GNU Lesser General Public License (LGPL)
- gradient descent
- gradient descent methods
- graph structured CRF
- Graphviz
- GraphX
- gross domestic product (GDP)
- Group by
- Growth Domestic Product (GDP)
H
- Hadoop cluster
- Hadoop distributed file system (HDFS)
- Hadoop Distributed File System (HDFS) / Loading the dataset
- hard margin, separable case of linear SVM
- HashingTF / Transformers
- HDFS
- headers
- head function / Using the tools to inspect the Parquet file
- Hello world
- Hessian matrix
- hidden layers
- Hidden Naïve Bayes (HNB) / Training
- hierarchical encoding
- hinge loss
- Hive table
- HMM
- HTML templates
- HTTP
- HTTP headers
- hyperplane
I
- I/O blocking operations
- identity potential functions
- IEEE-732 encoding
- implementation, CRF
- implementation, crossover
- implementation, GA
- implementation, mutation
- implicit conversion, Scala
- incremental EM / Online EM
- indexing / Advanced indexing and slicing
- information retrieval and text mining
- input forward propagation, MLP training cycle
- insensitive error
- installation, Apache Commons Math
- installation, JFreeChart
- instance-type
- invokers
- iris data
J
- Jacobian matrix
- Java
- java.sql.Types package
- Java Native Interface (JNI)
- Java packages
- JavaScipt dependencies
- jBlas 1.2.3
- JDBC
- JFreeChart
- JFreeChart documentation
- Joda-Time API / Preparing our data
- JSON
- JSON4S types / JSON4S types
- JSON files
- JSON in Scala
K
- k-fold cross-validation / Cross-validation and model selection
- K-fold cross-validation
- K-means
- used, for clustering / Clustering using K-means
- about / Clustering using K-means, How to do it..., K-means clustering
- KMeans.RANDOM / KMeans.RANDOM
- KMeans.PARALLEL / KMeans.PARALLEL
- max iterations / Max iterations
- epsilon / Epsilon
- data, importing / Importing the data and converting it into a vector
- data, converting into vector / Importing the data and converting it into a vector
- data, feature scaling / Feature scaling the data
- number of clusters, deriving / Deriving the number of clusters
- model, constructing / Constructing the model
- model, evaluating / Evaluating the model
- similarity, measuring / Measuring similarity
- overview / Overview of the K-means algorithm
- advantage / Overview of the K-means algorithm
- cluster configuration / Step 1 – cluster configuration
- cluster assignment / Step 2 – cluster assignment
- iterative reconstruction / Step 3 – iterative reconstruction
- exit condition / Step 3 – iterative reconstruction
- dimensionality issue, of models / Curse of dimensionality
- experiment / Experiment
- clusters, tuning / Tuning the number of clusters
- validation / Validation
- relating, with EM / Testing
- performance considerations / K-means
- using / K-means using Spark
- Kafka
- Kafka server
- Kafka topic
- Kafka version 0.8.2.1, for Spark 2.10
- Kalman filter
- Kalman filters
- Kalman smoothing, recursive algorithm
- kernel functions
- kernel functions, types
- kernel trick
- KMeans.PARALLEL
- Kryo / Saving RDD[StudentAvro] in a Parquet file
- Kryo serialization
- KryoSerializer
L
- L-BFGS method / Breeze – function optimization
- L1 regularization
- L2 regularization
- labeled data
- Lagrange multipliers
- lambda model
- LAPACK
- LAPACK library / Basic Breeze data types
- laplacian kernel
- Lasso regularization
- latent Dirichlet allocation (LDA)
- lazy computation
- LCS
- LCS, categories
- LCS, terminology
- LDL decomposition
- learning vector quantization (LVQ)
- least squares problem
- legends property / Adding a legend to the plot
- lemmatization / Basics of information retrieval
- Lempel-Ziv-Oberhumer (LZO) / Enable compression for the Parquet file
- LET IT CRASH blog
- Levenberg-Marquardt algorithm
- Levenberg-Marquardt parameters
- Levenstein distance / Basics of information retrieval
- lexicon function / Scoring of terms
- libraries
- libraries directory
- LIBSVM
- LIBSVM, Java classes
- life-cycle hooks
- likelihood
- linear algebra
- linear chain CRF
- linear Kalman filter
- linear kernel
- linear regression
- used, for predicting continuous values / Predicting continuous values using linear regression, How to do it...
- data. importing / Importing the data
- each instance, converting into LabeledPoint / Converting each instance into a LabeledPoint
- training, preparing / Preparing the training and test data
- test data, preparing / Preparing the training and test data
- features, scaling / Scaling the features
- model, training / Training the model
- test data, predicting against / Predicting against test data
- model, evaluating / Evaluating the model
- parameters, regularizing / Regularizing the parameters
- mini batching / Mini batching
- about / Linear regression
- one-variate linear regression / One-variate linear regression
- OLS regression / Ordinary least squares (OLS) regression
- versus SVR / SVR versus linear regression
- linear SVM
- line type
- Ling-Spam dataset
- Ling-Spam email dataset
- Ln roughness penalty
- loan pattern / Reading data
- logistic regression
- LogisticRegression
- logistic regression, training workflow
- logit function
- log kernel
- looser coupling
- Lotka-Volterra equation
- Lp-norm
- LU factorization
M
- += method / Extraction of terms
- machine learning
- machine learning, problems
- machine learning algorithms
- Machine Learning course
- maps
- margin, binary SVC
- Markov decision process
- Markov models (HMM)
- Markov property
- Markov random fields
- master-workers
- Master class
- mathematical concepts
- mathematical notation
- matrices
- about / Matrices
- building / Building vectors and matrices
- mutating / Mutating vectors and matrices
- working with / Working with matrices, How to do it...
- creating / Creating matrices
- creating, from values / Creating a matrix from values
- zero matrix, creating / Creating a zero matrix
- creating, out of function / Creating a matrix out of a function
- identity matrix, creating / Creating an identity matrix
- creating, from random numbers / Creating a matrix from random numbers
- Scala collection, creating / Creating from a Scala collection
- appending / Appending and conversion
- concatenating / Concatenating matrices – vertically
- concatenating, hvertcat function / Concatenating matrices – vertically
- concatenating, horzcat function / Concatenating matrices – horizontally
- data manipulation operations / Data manipulation operations
- basic statistics, computing / Computing basic statistics
- mean and variance / Mean and variance
- standard deviation / Standard deviation
- working / How it works...
- with randomly distributed values / Vectors and matrices with randomly distributed values, How it works...
- matrix
- column vectors, obtaining / Getting column vectors out of the matrix
- row vectors, obtaining / Getting row vectors out of the matrix
- inside values, obtaining / Getting values inside the matrix
- inverse, obtaining / Getting the inverse and transpose of a matrix
- transpose, obtaining / Getting the inverse and transpose of a matrix
- largest value, finding / Finding the largest value in a matrix
- sum, finding / Finding the sum, square root and log of all the values in the matrix
- square root, finding / Finding the sum, square root and log of all the values in the matrix
- log of all values, finding / Finding the sum, square root and log of all the values in the matrix
- sqrt function / Finding the sum, square root and log of all the values in the matrix
- log function / Calculating the eigenvectors and eigenvalues of a matrix
- eigenvectors, calculating / Calculating the eigenvectors and eigenvalues of a matrix
- eigenvalues, calculating / Calculating the eigenvectors and eigenvalues of a matrix
- with uniformly random values, creating / Creating a matrix with uniformly random values
- with normally distributed random values, creating / Creating a matrix with normally distributed random values
- with random values with Poisson distribution, creating / Creating a matrix with random values that has a Poisson distribution
- matrix arithmetic
- Matrix class
- matrix of Int
- max-margin classification
- mean
- mean squared error (MSE) / One-variate linear regression
- mean square error (MSE)
- measurement equation
- Mesos
- message
- message-passing mechanisms, Actor model
- message sender
- metaphor for graphical models / Probabilistic graphical models
- Michigan approach
- micro-batching
- MLlib / Breeze – function optimization
- MLP
- MLP, evaluation
- MLP algorithm, parameters
- MLPConfig configuration, parameters
- model
- model, forms
- model, MLP
- Model-View-Controller (MVC)
- modelling
- models, K-means
- modular JavaScript
- monadic data transformation
- monads
- MongoDB
- monoids
- Monte Carlo EM / Online EM
- moveCenter() method
- moving averages
- MTable instances
- multinomial Naïve Bayes model
- Multivariate Bernoulli classification
- mutation
- Mutual Information (MI) / Spam filtering
N
- N-fold cross-validation
- n-grams / Basics of information retrieval
- natural language processing (NLP)
- natural selection
- Naïve Bayes
- Naïve Bayes classification
- Naïve Bayes classifiers
- Naïve Bayes classifiers, implementing
- Naïve Bayes models
- net profit margin
- net sales
- network architecture, MLP
- neural network architecture
- neural networks
- NewsArticles class
- newState method
- nonlinear least squares minimization
- nonlinear SVM
- notation, HMM
- NP problems
- numerical optimization
- NumericColumnExtensionMethods class
- NumPy
- NVD3
O
- object-oriented design patterns
- object creation
- objective, neural networks
- Objects / A whirlwind tour of JSON
- objects
- observation
- offspring
- OLS regression
- one-class SVC
- one-variate linear regression
- online courses
- online training
- OpenBLAS
- operating income
- operating profit margin
- operations
- operators, Scala
- optimal substructures
- optimization techniques
- OptionModel class
- OptionProperty class
- options trading
- option trading, with Q-learning
- Ordering
- Ordering[T] class / Scoring of terms
- output unit activation function
- overfitting / The frequentist perspective
- overlapping substructures
- overload operators
- |> operator
P
- package.scala source file
- padding
- PaintScale.scala source file
- PairRDD
- parallel collections
- parallel collections, Scala
- parallel execution
- parent chromosomes
- Parquet
- Parquet-MR project
- Parquet files
- Parquet tools
- parsers
- partially connected neural networks
- pattern matchin
- Pattern matching
- pay-out ratio
- PCA
- used, for feature reduction / Feature reduction using principal component analysis, How to do it...
- about / Feature reduction using principal component analysis
- dimensionality reduction, of data for supervised learning / Dimensionality reduction of data for supervised learning
- training data, mean-normalizing / Mean-normalizing the training data, Mean-normalizing the training data
- principal components, extracting / Extracting the principal components, Extracting the principal components
- labeled data, preparing / Preparing the labeled data
- test data, preparing / Preparing the test data
- metrics, classifying / Classify and evaluate the metrics
- metrics, evaluating / Classify and evaluate the metrics, Evaluating the metrics
- data, dimensionality reduction / Dimensionality reduction of data for unsupervised learning
- number of components / Arriving at the number of components
- purpose / Principal components analysis (PCA)
- algorithm / Algorithm
- implementation / Implementation
- test case / Test case
- evaluation / Evaluation
- cross-validation / Evaluation
- performance considerations / PCA
- pem key
- permanence spectrum / Programming in data science
- persistence level
- Pimp my Library pattern
- pimp my library pattern
- pimp my library pattern
- pipeline
- pipeline API
- Pipeline API, used for solving binary classification
- data, importing as test / Importing and splitting data as test and training sets
- data, importing as training sets / Importing and splitting data as test and training sets
- data, splitting as training sets / Importing and splitting data as test and training sets
- data, splitting as test / Importing and splitting data as test and training sets
- participants, constructing / Construct the participants of the Pipeline
- pipeline, preparing / Preparing a pipeline and training a model
- model, training / Preparing a pipeline and training a model
- test data, predicting against / Predicting against test data
- mode, evaluating without cross-validation / Evaluating a model without cross-validation
- parameters for cross-validation, constructing / Constructing parameters for cross-validation
- cross-validator, constructing / Constructing cross-validator and fit the best model
- model, evaluating with cross-validation / Evaluating the model with cross-validation
- Pipeline API, used for solving binary classification problem
- Pittsburgh approach
- Play framework / Futures example – stock price fetcher
- plots
- polynomial kernel
- Population class
- population growth
- portfolio management
- posterior probability
- postStop method
- potential functions (fi)
- predicate encoding
- predicates
- prediction, recursive algorithm
- predictive model
- PreparedStatement API documentation
- PreparedStatement class
- prerequisite, for running ElasticSearch instance on machine
- prestart method
- price/book value ratio (PB)
- price/earnings ratio (PE)
- price/sales ratio (PS)
- price patterns
- Price to Earnings/Growth (PEG)
- primal problem
- primitive types, Scala
- Principal Component Analysis (PCA) / Gradient descent
- Privacy Enhanced Mail (PEM) / How to do it...
- private
- private[this]
- probabilistic graphical models
- probabilistic kernels
- probabilistic reasoning
- Product
- propositional logic
- proteins
- protein sequence annotation
- pseudo-clustered mode
Q
- Q-learning
- QR decomposition
- Quasi-Newton algorithms
- queue control
R
- r2 statistics
- rank method / Scoring of terms
- RBF
- RDBMS
- RDD
- RDD, operations
- real-world Bayesian network
- receive method
- receiver operating characteristic (ROC) curve / Evaluation
- recombination
- recursive algorithm
- reduceByKey function / How to do it...
- regression weights
- regularization / Regularization
- reinforcement learning
- reinforcement learning, terminology
- reproducible Kernel Hilbert Spaces
- reproduction cycle
- reproduction cycle, convergence criteria
- request
- RequireJS
- residual sum of squares (RSS)
- resilient applications
- Resilient Distributed Dataset (RDD) / How it works...
- Resilient distributed datasets (RDD)
- Resilient Distributed Datasets (RDD)
- response
- response views / Response views
- Rest APIs
- results
- ResultSet interface
- Ridge regression
- ridge regression
- risk analysis, binary SVC
- router
- routing
- RowGroups / Storing data as Parquet files
- rules, XCS
- rules discovery module
S
- 2-step lag smoothing algorithm
- @specialized annotation / Discrete Fourier transform (DFT)
- save method / Save it as a Parquet file
- sbt-avro plugin
- sbt-dependency-graph plugin
- SBT assembly plugin
- sbteclipse plugin
- Scala
- Scala bindings
- Scala Build Tool (SBT) / Getting Breeze – the linear algebra library
- Scala case classes
- Scala constructs
- ScalaNLP
- ScalaNLP suite
- Scala plugin, for Eclipse
- URL, for installation / Scala
- Scala plugin, for Intellj IDEA
- URL, for downloading / Scala
- Scala programming
- Scala reactive library
- Scala traits
- scatter plot matrix plots
- scatter plots
- scatter plots, creating with Bokeh-Scala
- schema
- scheme, genetic encoding
- score method / Scoring of terms
- selection
- semantic URLs / Dynamic routing, References
- Sense plugin
- sequences
- Sequential Minimal Optimization (SMO)
- shared variables
- short interest
- short interest ratio
- shrinkage
- shuffling / Data shuffling and partitions
- sigmoid kernel
- signal encoding
- Simple Build Tool (SBT)
- simple build tool (sbt)
- simple moving average
- single page applications
- singular value decomposition (SVD)
- skip lists
- slicing / Advanced indexing and slicing
- Slick
- smoothing
- smoothing factor for counters
- smoothing kernels
- Snappy
- Snappy compression / Enable compression for the Parquet file
- softmax
- software design, MLP
- software developer
- solution encoding
- source build tool (SBT) / Getting Apache Spark
- source code, Scala
- Source Forge
- spam filtering
- Spark
- spark.driver.extraClassPath property
- Spark/MLlib 1.0
- Spark 14
- Spark application
- Spark applications
- Spark cluster
- Spark job
- Spark job, installing on YARN
- Spark master and slave
- Spark notebooks
- Spark shell
- SparkSQL
- Spark Standalone cluster
- running, on EC2 / Running the Spark Standalone cluster on EC2
- AccessKey, creating / Creating the AccessKey and pem file
- pem file, creating / Creating the AccessKey and pem file
- environment variables, setting / Setting the environment variables
- launch script, running / Running the launch script
- installation, verifying / Verifying installation
- changes, making to code / Making changes to the code
- data, transferring / Transferring the data and job files
- job files, transferring / Transferring the data and job files
- dataset, loading into HDFS / Loading the dataset into HDFS
- job, running / Running the job
- destroying / Destroying the cluster
- Spark Streaming
- spectral analysis
- spectral density estimation
- spreadsheets
- SQL statements
- stand-alone programs
- standalone programs
- Stanford NLP toolkit
- state, dynamic systems
- stateful actors / Stateful actors
- state space estimation
- stdDev() method
- steepest descent method
- stemming / Basics of information retrieval
- stepwise EM / Online EM
- stimuli
- Stochastic Gradient Descent (SGD) / Gradient descent
- stochastic gradient method
- Stream classes
- StreamingLogisticRegression, used for classifying Twitter stream
- StringColumnExtensionMethods class
- structs
- Student dataset
- subject-matter expert
- subordinates
- substructures
- sum of squared errors (SSE) / One-variate linear regression
- supervised learning / Supervised and unsupervised learning
- Support Vector Machine (SVM)
- SVC
- SVC origin
- SVM
- SVM dual problem
- SVMLight
- SVR
- synapse/weights adjustment, MLP training cycle
- υ-SVM
T
- tagging model / Basics of information retrieval
- technical analysis
- technical analysis, terminology
- temporal difference
- TermsScore.score method
- TermsScore class
- test case, MLP
- test case, trading strategies
- testing, Naïve Bayes
- text mining
- text mining methodology
- theory of evolution
- time series
- time series analysis
- time series MultiPlot, creating with Bokeh-Scala
- about / Creating a time series MultiPlot with Bokeh-Scala, How to do it...
- data, preparing / Preparing our data
- Plot, creating / Creating a plot
- line joining to all data points, creating / Creating a line that joins all the data points
- and y axes data ranges for plot, setting / Setting the x and y axes' data range for the plot
- axes, drawing / Drawing the axes and the grids
- grids, drawing / Drawing the axes and the grids
- tools, adding / Adding tools
- legend, adding to plot / Adding a legend to the plot
- multiple plots, creating in document / Multiple plots in the document
- URL / Multiple plots in the document
- toDate function / Scoring of terms
- toDate method
- toDF() function / How to do it...
- tokenization
- tokens
- tools
- toOrderedArray method / Extraction of terms
- toWords function / Scoring of terms
- toWords method
- trading operators
- trading signal
- trading signals
- trading strategies, GA
- training (CF-2), HMM
- training cycle, MLP
- training strategies, MLP
- train method / Training
- transformation methods, Apache Spark
- transformations
- transformers
- transform method
- transition equation
- transition feature functions
- transposition operator
- try/catch statements
- Try type
- tuning, GA
- tuning memory usage
- twitter-chill project
- twitter4j library
- Twitter app
- Twitter data
- Twitter stream
- type classes
- typed actors
- versus untyped actors / Akka
- Typesafe Activator
- Typesafe activators
U
V
- val
- validate method / Training
- validation, K-means
- validation, model
- value encoding
- value of policy
- variables
- variables, HMM execution state
- variance
- vector concatenation
- vector quantization
- vectors
- about / Vectors
- dense / Dense and sparse vectors and the vector trait
- sparse / Dense and sparse vectors and the vector trait
- trait / Dense and sparse vectors and the vector trait
- building / Building vectors and matrices
- mutating / Mutating vectors and matrices
- working with / Working with vectors, Getting ready
- creating / Creating vectors
- constructing, from values / Constructing a vector from values
- zero vector, creating / Creating a zero vector
- creating, out of function / Creating a vector out of a function
- vector of linearly spaced values, creating / Creating a vector of linearly spaced values
- vector with values, creating in specific range / Creating a vector with values in a specific range
- entire vector with single value, creating / Creating an entire vector with a single value
- sub-vector, slicing from bigger vector / Slicing a sub-vector from a bigger vector
- Breeze vector, creating from Scala vector / Creating a Breeze Vector from a Scala Vector
- arithmetic / Vector arithmetic
- scalar operations / Scalar operations
- dot product of two vectors, creating / Calculating the dot product of two vectors
- creating, by adding two vectors / Creating a new vector by adding two vectors together
- appending / Appending vectors and converting a vector of one type to another
- converting from one type to another / Appending vectors and converting a vector of one type to another
- concatenating / Concatenating two vectors
- standard deviation / Standard deviation
- largest value, finding / Find the largest value in a vector
- sum, finding / Finding the sum, square root and log of all the values in the vector
- log, finding / Finding the sum, square root and log of all the values in the vector
- square root, finding / Finding the sum, square root and log of all the values in the vector
- Sqrt function / Finding the sum, square root and log of all the values in the vector
- Log function / Finding the sum, square root and log of all the values in the vector
- with randomly distributed values / Vectors and matrices with randomly distributed values, How it works...
- with uniformly distributed random values, creating / Creating vectors with uniformly distributed random values
- with normally distributed random values, creating / Creating vectors with normally distributed random values
- with random values with Poisson distribution, creating / Creating vectors with random values that have a Poisson distribution
- view bound
- Viterbi algorithm
W
X
Y
- 1-year Treasury bill (1yTB)
- YARN
Z
- Zeppelin
- zero-frequency problem
- zip method
- Zookeeper
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.