Introduction
There is no magic formula in data science that can tell us which type of machine learning estimator in combination with which pipeline will perform best for a given raw dataset. Different models are better suited for different types of data and different types of problems. At best, you can follow some rough guide on how to approach problems with regard to which model to try on your data, but these are incomplete at best.
During the exploration phase of a machine learning project, a data scientist tries to find the optimal pipeline for his specific use case. This usually involves applying standard data cleaning steps, creating or selecting useful features, trying out different models, etc. Testing multiple pipelines requires many lines of code, and writing it all in the same notebook often makes it long and cluttered. On the other hand, using multiple notebooks makes it harder to compare the results and to keep an overview. On top of that, refactoring the code for every test can be time-consuming. How many times have you conducted the same action to pre-process a raw dataset? How many times have you copy-and-pasted code from an old repository to re-use it in a new use case?
Although best practices tell us to start with a simple model and build up to more complicated ones, many data scientists just use the model best known to them in order to avoid the aforementioned problems. This can result in poor performance (because the model is just not the right one for the task) or in inefficient management of time and computing resources (because a simpler/faster model could have achieved a similar performance).
ATOM is here to help solve these common issues. The package acts as a wrapper of the whole machine learning pipeline, helping the data scientist to rapidly find a good model for his problem. Avoid endless imports and documentation lookups. Avoid rewriting the same code over and over again. With just a few lines of code, it's now possible to perform basic data cleaning steps, select relevant features and compare the performance of multiple models on a given dataset, providing quick insights on which pipeline performs best for the task at hand.
It is important to realize that ATOM is not here to replace all the work a data scientist has to do before getting his model into production. ATOM doesn't spit out production-ready models just by tuning some parameters in its API. After helping you determine the right pipeline, you will most probably need to fine-tune it using use-case specific features and data cleaning steps in order to achieve maximum performance.
Nomenclature
In this documentation we will consistently use terms to refer to certain concepts related to this package.
- atom: Instance of the ATOMClassifier or ATOMRegressor classes (note that the examples use it as the default variable name).
- ATOM: Refers to this package.
- branch: Collection of estimators in the pipeline fitted to a specific dataset. See the branches section.
- BO: Bayesian optimization algorithm used for hyperparameter optimization.
- categorical columns: Refers to all non-numerical columns.
- class: Unique value in a column, e.g. a binary classifier has 2 classes in the target column.
- estimator: An object which manages the estimation and decoding of an algorithm. The algorithm is estimated as a deterministic function of a set of parameters, a dataset and a random state.
- missing values: Values in the
missing
attribute. - model: Instance of a model in the pipeline.
- outlier: Sample that contains one or more outlier values. Note that the Pruner class can use a different definition for outliers depending on the chosen strategy.
- outlier value: Value that lies further than 3 times the standard_deviation away from the mean of its column (|z-score| > 3).
- pipeline: All the content in atom for a specific branch.
- predictor: An estimator implementing a
predict
method. This encompasses all classifiers and regressors. - scorer: A non-estimator callable object which evaluates an estimator on given test data, returning a number. Unlike evaluation metrics, a greater returned number must correspond with a better score. See sklearn's documentation.
- sequence: A one-dimensional array of variable type
list
,tuple
,np.ndarray
orpd.Series
. - target: Name of the dependent variable, passed as y to an estimator's fit method.
- task: One of the three supervised machine learning approaches that ATOM supports:
- trainer: Instance of a class that train and evaluate the models (implement a
run
method). The following classes are considered trainers: - transformer: An estimator implementing a
transform
method. This encompasses all data cleaning and feature engineering classes.
First steps
You can quickly install atom using pip
or conda
, see the installation guide.
ATOM contains a variety of classes to perform data cleaning, feature
engineering, model training, plotting and much more. The easiest way
to use everything ATOM has to offer is through one of the main classes:
- ATOMClassifier for binary or multiclass classification tasks.
- ATOMRegressor for regression tasks.
These two classes are convenient wrappers for the whole machine learning pipeline. Like a sklearn Pipeline, they assemble several steps that can be cross-validated together while setting different parameters. There are some important differences with sklearn's API:
- atom is initialized with the data you want to manipulate. This data can be accessed at any moment through atom's data attributes.
- The classes in ATOM's API are reached through atom's methods. For example, calling the encode method will initialize an Encoder instance, fit it on the training set and transform the whole dataset.
- The transformations are applied immediately after calling the method (there is no fit method). This approach gives the user a clearer overview and more control over every step in the pipeline.
Let's get started with an example!
First, initialize atom and provide it the data you want to use. You can either input a dataset and let ATOM split the train and test set or provide a train and test set already split. Note that if a dataframe is provided, the indices are reset by atom.
atom = ATOMClassifier(X, y, test_size=0.25)
Apply data cleaning methods through the class. For example, calling the impute method will handle all missing values in the dataset.
atom.impute(strat_num="median", strat_cat="most_frequent", min_frac_rows=0.1)
Select the best hyperparameters and fit a Random Forest and AdaBoost model.
atom.run(["RF", "AdaB"], metric="accuracy", n_calls=25, n_initial_points=10)
Analyze the results:
atom.feature_importances(show=10, filename="feature_importance_plot")
atom.plot_prc(title="Precision-recall curve comparison plot")
Data pipelines
It may happen that you want to compare how a model performs on different datasets. For example, on one dataset balanced with an undersampling strategy and the other with an oversampling strategy. For this, atom has data pipelines.
Branches
Data pipelines manage separate paths atom's dataset can take. The paths
are called branches and can be accessed through the branch
attribute.
Calling it will show the branches in the pipeline. The current branch is
indicated with !
. A branch contains a specific dataset, and the
transformers it took to arrive to that dataset from the one atom
initialized with. Accessing data attributes such as atom.dataset
will
return the data in the current branch. Use the pipeline
attribute to
see the estimators in the branch. All data cleaning, feature engineering
and trainers called will use the dataset in the current branch. This
means that models are trained and validated on the data in that branch.
Don't change the data in a branch after fitting a model, this can cause
unexpected model behaviour. Instead, create a new branch for every unique
model pipeline.
By default, atom starts with one branch called "master". To start a new
branch, set a new name to the property, e.g. atom.branch = "new_branch"
.
This will start a new branch from the current one. To create a branch
from any other branch type "_from_" between the new name and the branch
from which to split, e.g. atom.branch = "branch2_from_branch1"
will
create branch "branch2" from branch "branch1". To switch between existing
branches, just type the name of the desired branch, e.g. atom.branch = "master"
to go back to the main branch. Note that every branch contains a unique copy
of the whole dataset! Creating many branches can cause memory issues for
large datasets.
You can delete a branch either deleting the attribute, e.g. del atom.branch
,
or using the delete method, e.g. atom.branch.delete()
. A branch can only be
deleted if no models were trained on its dataset. Use atom.branch.status()
to print a list of the transformers and models in the branch.
See the Imbalanced datasets or Feature engineering examples for branching use cases.
Warning
Always create a new branch if you want to change the dataset after fitting a model! Not doing so can cause unexpected model behaviour.
Data transformations
Performing data transformations is a common requirement of many datasets before they are ready to be ingested by a model. ATOM provides various classes to apply data cleaning and feature engineering transformations to the data. This tooling should be able to help you apply most of the typically needed transformations to get the data ready for modelling. For further fine-tuning, it is also possible to pre-process the data using custom transformers. They can be added to the pipeline using atom's add method. Remember that all transformations are only applied to the dataset in the current branch.
AutoML
Automated machine learning (AutoML) automates the selection, composition
and parameterization of machine learning pipelines. Automating the machine
learning process makes it more user-friendly and often provides faster, more
accurate outputs than hand-coded algorithms. ATOM uses the TPOT
package for AutoML optimization. TPOT uses a genetic algorithm to intelligently
explore thousands of possible pipelines in order to find the best one for your
data. Such an algorithm can be started through the automl
method. The resulting data transformers and final estimator are merged with atom's
pipeline (check the pipeline
and models
attributes after the method
finishes running).
Warning
AutoML algorithms aren't intended to run for only a few minutes. If left to its default parameters, the method can take a very long time to finish!
Data cleaning
More often than not, you need to do some data cleaning before fitting your dataset to a model. Usually, this involves importing different libraries and writing many lines of code. Since ATOM is all about fast exploration and experimentation, it provides various data cleaning classes to apply the most common transformations fast and easy.
Note
All of atom's data cleaning methods automatically adopt the relevant
transformer attributes (n_jobs
, verbose
, logger
, random_state
) from
atom. A different choice can be added as parameter to the method call,
e.g. atom.scale(verbose=2)
.
Note
Like the add method, the data cleaning
methods accept the columns
parameter to only transform a subset of the
dataset's features, e.g. atom.scale(columns=[0, 1])
.
Scaling the feature set
Standardization of a dataset is a common requirement for many machine learning estimators; they might behave badly if the individual features do not more or less look like standard normally distributed data (e.g. Gaussian with zero mean and unit variance). The Scaler class let you quickly scale atom's dataset using one of sklearn's scalers. It can be accessed from atom through the scale method.
Standard data cleaning
There are many data cleaning steps that are useful to perform on any dataset before modelling. These are general rules that apply almost on every use-case and every task. The Cleaner class is a convenient tool to apply such steps. It can be accessed from atom through the clean method. Use the class' parameters to choose which transformations to perform. The available steps are:
- Drop columns with prohibited data types.
- Drop categorical columns with maximal cardinality.
- Drop columns with minimum cardinality.
- Strip categorical features from white spaces.
- Drop duplicate rows.
- Drop rows with missing values in the target column.
- Encode the target column.
Imputing missing values
For various reasons, many real world datasets contain missing values, often encoded as blanks, NaNs or other placeholders. Such datasets however are incompatible with ATOM's models which assume that all values in an array are numerical, and that all have and hold meaning. The Imputer class handles missing values in the dataset by either dropping or imputing the value. It can be accessed from atom through the impute method.
Tip
Use atom's missing attribute to check the amount of missing values per feature.
Encoding categorical features
Many datasets will contain categorical features. Their variables are typically stored as text values which represent various traits. Some examples include color (“Red”, “Yellow”, “Blue”), size (“Small”, “Medium”, “Large”) or geographic designations (city or country). Regardless of what the value is used for, the challenge is determining how to use this data in the analysis. ATOM's models don't support direct manipulation of this kind of data. Use the Encoder class to encode categorical features to numerical values. It can be accessed from atom through the encode method.
Tip
Use atom's categorical attribute for a list of the categorical features in the dataset.
Handling outliers
When modeling, it is important to clean the data sample to ensure that the observations best represent the problem. Sometimes a dataset can contain extreme values that are outside the range of what is expected and unlike the other data. These are called outliers. Often, machine learning modeling and model skill in general can be improved by understanding and even removing these outlier samples. The Pruner class offers 5 different strategies to detect outliers (described hereunder). It can be accessed from atom through the prune method.
Tip
Use atom's outliers attribute to check the number of outliers per column.
z-score
The z-score of a value in the dataset is defined as the number of standard
deviations by which the value is above or below the mean of the column.
Values above or below a certain threshold (specified with the parameter
max_sigma
) are considered outliers. Note that, contrary to the rest of
the strategies, this approach selects outlier values, not outlier samples!
Because of this, it is possible to replace the outlier value instead of
simply dropping the sample.
Isolation Forest
Uses a tree-based anomaly detection algorithm. It is based
on modeling the normal data in such a way as to isolate anomalies that are
both few and different in the feature space.
Read more in sklearn's documentation.
Elliptic Envelope
If the input variables have a Gaussian distribution, then simple statistical
methods can be used to detect outliers. For example, if the dataset has two
input variables and both are Gaussian, then the feature space forms a
multi-dimensional Gaussian and knowledge of this distribution can be used to
identify values far from the distribution. This approach can be generalized by
defining a hypersphere (ellipsoid) that covers the normal data, and data that
falls outside this shape is considered an outlier.
Read more in sklearn's documentation.
Local Outlier Factor
A simple approach to identifying outliers is to locate those examples that
are far from the other examples in the feature space. This can work well
for feature spaces with low dimensionality (few features) but becomes
less reliable as the number of features is increased. This is referred to
as the curse of dimensionality.
The local outlier factor is a technique that attempts to harness the idea of nearest neighbors for outlier detection. Each example is assigned a scoring of how isolated or how likely it is to be outliers based on the size of its local neighborhood. Those examples with the largest score are more likely to be outliers.
Read more in sklearn's documentation.
One-class SVM
The support vector machine algorithm developed initially for binary
classification can be used for one-class classification. When modeling
one class, the algorithm captures the density of the majority class and
classifies examples on the extremes of the density function as outliers.
This modification of SVM is referred to as One-Class SVM.
Read more in sklearn's documentation.
DBSCAN
The DBSCAN algorithm views clusters as areas of high density separated by
areas of low density. Due to this rather generic view, clusters found by
DBSCAN can be any shape, as opposed to k-means which assumes that clusters
are convex shaped. Samples that lie outside any cluster are considered outliers.
Read more in sklearn's documentation.
OPTICS
The OPTICS algorithm shares many similarities with the DBSCAN algorithm,
and can be considered a generalization of DBSCAN that relaxes the eps
requirement from a single value to a value range. The key difference
between DBSCAN and OPTICS is that the OPTICS algorithm builds a reachability
graph, and a spot within the cluster ordering. These two attributes are
assigned when the model is fitted, and are used to determine cluster membership.
Read more in sklearn's documentation.
Balancing the data
One of the common issues found in datasets that are used for classification is imbalanced classes. Data imbalance usually reflects an unequal distribution of classes within a dataset. For example, in a credit card fraud detection dataset, most of the transactions are non-fraud, and a very few cases are fraud. This leaves us with a very unbalanced ratio of fraud vs non-fraud cases. The Balancer class can oversample the minority class or undersample the majority class using any of the transformers implemented in imblearn. It can be accessed from atom through the balance method.
Feature engineering
Feature engineering is the process of creating new features from the
existing ones, in order to capture relationships with the target
column that the first set of features didn't had on their own. This
process is very important to improve the performance of machine learning
algorithms. Although feature engineering works best when the data
scientist applies use-case specific transformations, there are ways to
do this in an automated manner, without prior domain knowledge. One of
the problems of creating new features without human expert intervention,
is that many of the newly created features can be useless, i.e. they do
not help the algorithm to make better predictions. Even worse, having
useless features can drop your performance. To avoid this, we perform
feature selection, a process in which we select the relevant features
in the dataset. See the Feature engineering example.
Note
All of atom's feature engineering methods automatically adopt the relevant
transformer attributes (n_jobs
, verbose
, logger
, random_state
) from
atom. A different choice can be added as parameter to the method call,
e.g. atom.feature_selection("SFM", solver="LGB", n_features=10, n_jobs=4)
.
Note
Like the add method, the feature engineering
methods accept the columns
parameter to only transform a subset of the
dataset's features, e.g. atom.feature_selection("SFM", solver="LGB", n_features=10, columns=slice(5, 15))
.
Generating new features
The FeatureGenerator class creates new non-linear features based on the original feature set. It can be accessed from atom through the feature_generation method. You can choose between two strategies: Deep Feature Synthesis and Genetic Feature Generation.
Deep Feature Synthesis
Deep feature synthesis (DFS) applies the selected operators on the
features in the dataset. For example, if the operator is "log",
it will create the new feature LOG(old_feature)
and if the
operator is "mul", it will create the new feature old_feature_1 x old_feature_2
.
The operators can be chosen through the operators
parameter.
Available options are:
- add: Sum two features together.
- sub: Subtract two features from each other.
- mul: Multiply two features with each other.
- div: Divide two features with each other.
- srqt: Take the square root of a feature.
- log: Take the logarithm of a feature.
- sin: Calculate the sine of a feature.
- cos: Calculate the cosine of a feature.
- tan: Calculate the tangent of a feature.
ATOM's implementation of DFS uses the featuretools package.
Tip
DFS can create many new features and not all of them will be useful. Use FeatureSelector to reduce the number of features!
Warning
Using the div, log or sqrt operators can return new features with
inf
or NaN
values. Check the warnings that may pop up or use
atom's missing property.
Warning
When using DFS with n_jobs>1
, make sure to protect your code with
if __name__ == "__main__"
. Featuretools uses dask,
which uses python multiprocessing for parallelization. The spawn
method on multiprocessing starts a new python process, which requires
it to import the __main__ module before it can do its task.
Genetic Feature Generation
Genetic feature generation (GFG) uses genetic programming,
a branch of evolutionary programming, to determine which features
are successful and create new ones based on those. Where DFS can be
seen as some kind of "brute force" for feature engineering, GFG tries
to improve its features with every generation of the algorithm. GFG
uses the same operators as DFS, but instead of only applying the
transformations once, it evolves them further, creating complicated
non-linear combinations of features with many transformations. The
new features are given the name Feature N
for the N-th feature. You
can access the genetic feature's fitness and description (how they are
calculated) through the genetic_features
attribute.
ATOM uses the SymbolicTransformer class from the gplearn package for the genetic algorithm. Read more about this implementation here.
Warning
GFG can be slow for very large populations!
Selecting useful features
The FeatureSelector class provides tooling to select the relevant features from a dataset. It can be accessed from atom through the feature_selection method. The following strategies are implemented: univariate, PCA, SFM, RFE and RFECV.
Univariate
Univariate feature selection works by selecting the best features based
on univariate statistical F-test. The test is provided via the solver
parameter. It takes any function taking two arrays (X, y), and returning
arrays (scores, p-values).
Read more in sklearn's documentation.
Principal Components Analysis
Applying PCA will reduce the dimensionality of the dataset by maximizing
the variance of each dimension. The new features are called Component
1, Component 2, etc... The data is scaled to mean=0 and std=1 before
fitting the transformer (if it wasn't already).
Read more in sklearn's documentation.
Selection from model
SFM uses an estimator with feature_importances_
or coef_
attributes
to select the best features in a dataset based on importance weights.
The estimator is provided through the solver
parameter and can be
already fitted. ATOM allows you to use one its predefined models,
e.g. solver="RF"
. If you didn't call the FeatureSelector through atom,
don't forget to indicate the estimator's task adding _class
or _reg
after the name, e.g. RF_class
to use a random forest classifier.
Read more in sklearn's documentation.
Recursive feature elimination
Select features by recursively considering smaller and smaller sets of
features. First, the estimator is trained on the initial set of features
and the importance of each feature is obtained either through a coef_
attribute or through a feature_importances_
attribute. Then, the least
important features are pruned from current set of features. That procedure
is recursively repeated on the pruned set until the desired number of
features to select is eventually reached. Note that, since RFE needs to
fit the model again every iteration, this method can be fairly slow.
RFECV applies the same algorithm as RFE but uses a cross-validated metric
(under the scoring parameter, see RFECV)
to assess every step's performance. Also, where RFE returns the number
of features selected by n_features
, RFECV returns the number of
features that achieved the optimal score on the specified metric. Note
that this is not always equal to the amount specified by n_features
.
Read more in sklearn's documentation.
Removing features with low variance
Variance is the expectation of the squared deviation of a random
variable from its mean. Features with low variance have many values
repeated, which means the model will not learn much from them.
FeatureSelector removes
all features where the same value is repeated in at least
max_frac_repeated
fraction of the rows. The default option is to
remove a feature if all values in it are the same.
Read more in sklearn's documentation.
Removing features with multi-collinearity
Two features that are highly correlated are redundant, i.e. two will
not contribute more to the model than only one of them.
FeatureSelector will
drop a feature that has a Pearson correlation coefficient larger than
max_correlation
with another feature. A correlation of 1 means the
two columns are equal. A dataframe of the removed features and their
correlation values can be accessed through the collinear
attribute.
Tip
Use the plot_feature_importance
method to examine how much a specific feature contributes to the
final predictions. If the model doesn't have a feature_importances_
attribute, use plot_permutation_importance instead.
Warning
The RFE and RFECV strategies don't work when the solver is a CatBoost model due to incompatibility of the APIs.
Models
Predefined models
ATOM provides 31 models for classification and regression tasks that
can be used to fit the data in the pipeline. After fitting, every model
class is attached to the trainer as an attribute. We refer to these
"subclasses" as models (see the nomenclature). The
classes contain a variety of attributes and methods to help you
understand how the underlying estimator performed. They can be accessed
using their acronyms, e.g. atom.LGB
to access the LightGBM's model.
The available models and their corresponding acronyms are:
- "GP" for Gaussian Process
- "GNB" for Gaussian Naive Bayes
- "MNB" for Multinomial Naive Bayes
- "BNB" for Bernoulli Naive Bayes
- "CatNB" for Categorical Naive Bayes
- "CNB" for Complement Naive Bayes
- "OLS" for Ordinary Least Squares
- "Ridge" for Ridge Classification/Regression
- "Lasso" for Lasso Regression
- "EN" for Elastic Net
- "BR" for Bayesian Ridge
- "ARD" for Automated Relevance Determination
- "LR" for Logistic Regression
- "LDA" for Linear Discriminant Analysis
- "QDA" for Quadratic Discriminant Analysis
- "KNN" for K-Nearest Neighbors
- "RNN" for Radius Nearest Neighbors
- "Tree" for Decision Tree
- "Bag" for Bagging
- "ET" for Extra-Trees
- "RF" for Random Forest
- "AdaB" for AdaBoost
- "GBM" for Gradient Boosting Machine
- "XGB" for XGBoost
- "LGB" for LightGBM
- "CatB" for CatBoost
- "lSVM" for Linear-SVM
- "kSVM" for Kernel-SVM
- "PA" for Passive Aggressive
- "SGD" for Stochastic Gradient Descent
- "MLP" for Multi-layer Perceptron
Tip
The acronyms are case insensitive. You can also use lowercase to call the models, e.g. atom.lgb
.
Warning
The models should not be initialized by the user! Only use them through the trainers.
Custom models
It is also possible to use your own models in ATOM's pipeline. For example, imagine we want to use sklearn's Lars estimator (note that is not included in ATOM's predefined models). There are two ways to achieve this:
Using ATOMModel (recommended). With this approach you can pass the required model characteristics to the pipeline.
from sklearn.linear_model import Lars
from atom import ATOMRegressor, ATOMModel
model = ATOMModel(models=Lars, fullname="Lars Regression", needs_scaling=True, type="linear")
atom = ATOMRegressor(X, y)
atom.run(model)
Using the estimator's class or an instance of the class. This approach will also call ATOMModel under the hood, but it will leave its parameters to their default values.
from sklearn.linear_model import Lars
from atom import ATOMRegressor, ATOMModel
atom = ATOMRegressor(X, y)
atom.run(models=Lars)
Additional things to take into account:
- Custom models are not restricted to sklearn estimators, but they should follow sklearn's API, i.e. have a fit and predict method.
- Parameter customization (for the initializer)
is only possible for custom models which provide an estimator's class
or an instance that has a
set_params()
method, i.e. it's a child class of BaseEstimator. - Hyperparameter optimization for custom
models is ignored unless appropriate dimensions are provided through
bo_params
. - If the estimator has a
n_jobs
and/orrandom_state
parameter that is left to its default value, it will automatically adopt the values from the trainer it's called from.
Deep learning
Deep learning models can be used through ATOM's custom models as long as they follow sklearn's API. For example, models implemented with the Keras package should use the sklearn wrappers KerasClassifier or kerasRegressor.
Many deep learning models, for example in computer vision and natural language processing, use datasets with more than 2 dimensions, e.g. image data can have shape (n_samples, length, width, rgb). These data structures are not intended to store in a two-dimensional pandas dataframe. Since ATOM requires a dataframe as instance for the dataset, multidimensional data sets are stored in a single column called "Features" where every row contains one (multidimensional) sample. example. Note that, because of this, the data cleaning, feature engineering and some of the plotting methods are unavailable for deep learning datasets.
See in this example how to use ATOM to train and validate a Convolutional Neural Network implemented with Keras.
Training
The training phase is where the models are fitted and evaluated. After this, the models are attached to the trainer and you can use the plotting and predicting methods. The pipeline applies the following steps iteratively for all models:
- The optimal hyperparameters are selected.
- The model is trained on the training set and evaluated on the test set.
- The bagging algorithm is applied.
There are three approaches to run the training.
- Direct training:
- Training via successive halving:
- Training via train sizing:
The direct fashion repeats the aforementioned steps only once, while the other two approaches repeats them more than once. Every approach can be directly called from atom through the run, successive_halving and train_sizing methods respectively.
Models are called through their acronyms, e.g. atom.run(models="RF")
will train a Random Forest. If you want to run
the same model multiple times, add a tag after the acronym to
differentiate them.
atom.run(models=["RF1", "RF2"], est_params={"RF1": {"n_estimators": 100}, "RF2": {"n_estimators": 200}})
For example, this pipeline will fit two Random Forest models, one
with 100 and the other with 200 decision trees. The models can be
accessed through atom.rf1
and atom.rf2
. Use tagged models to
test how the same model performs when fitted with different
parameters or on different data sets. See the Imbalanced datasets
example.
Additional things to take into account:
- Models that need feature scaling will do so automatically before training if they are not already scaled.
- If an exception is encountered while fitting an estimator, the
pipeline will automatically jump to the next model. The errors are
stored in the
errors
attribute. Note that in case a model is skipped, there will be no model subclass for that estimator. - When showing the final results, a
!
indicates the highest score and a~
indicates that the model is possibly overfitting (training set has a score at least 20% higher than the test set). - The winning model (the one with the highest
mean_bagging
ormetric_test
) can be accessed through thewinner
attribute.
Metric
ATOM uses sklearn's SCORERS for model selection and evaluation. A scorer consists of a metric function and some parameters that define the scorer's properties such as it's a score or loss function or if the function needs probability estimates or rounded predictions (see make_scorer). ATOM lets you define the scorer for the pipeline in three ways:
- The
metric
parameter is one of sklearn's predefined scorers (as string). - The
metric
parameter is a score (or loss) function with signature metric(y, y_pred, **kwargs). In this case, use thegreater_is_better
,needs_proba
andneeds_threshold
parameters to specify the scorer's properties. - The
metric
parameter is a scorer object.
Note that all scorers follow the convention that higher return values
are better than lower return values. Thus, metrics which measure the
distance between the model and the data (i.e. loss functions), like
max_error
or mean_squared_error
, will return the negated value of
the metric.
Custom scorer acronyms
Since some of sklearn's scorers have quite long names and ATOM is all
about lazyfast experimentation, the package provides acronyms
for some of the most commonly used ones. These acronyms are case-insensitive
and can be used in the metric
parameter instead of the
scorer's full name, e.g. atom.run("LR", metric="BA")
will use
balanced_accuracy
. The available acronyms are:
- "AP" for "average_precision"
- "BA" for "balanced_accuracy"
- "AUC" for "roc_auc"
- "LogLoss" for "neg_log_loss"
- "EV" for "explained_variance"
- "ME" for "max_error"
- "MAE" for "neg_mean_absolute_error"
- "MSE" for "neg_mean_squared_error"
- "RMSE" for "neg_root_mean_squared_error"
- "MSLE" for "neg_mean_squared_log_error"
- "MEDAE" for "neg_median_absolute_error"
- "POISSON" for "neg_mean_poisson_deviance"
- "GAMMA" for "neg_mean_gamma_deviance"
Multi-metric runs
Sometimes it is useful to measure the performance of the models in more
than one way. ATOM lets you run the pipeline with multiple metrics at
the same time. To do so, provide the metric
parameter with a list of
desired metrics, e.g. atom.run("LDA", metric=["r2", "mse"])
. If you
provide metric functions, don't forget to also provide lists to the
greater_is_better
, needs_proba
and needs_threshold
parameters,
where the n-th value in the list corresponds to the n-th function. If
you leave them as a single value, that value will apply to every
provided metric.
When fitting multi-metric runs, the resulting scores will return a list
of metrics. For example, if you provided three metrics to the pipeline,
atom.knn.metric_bo
could return [0.8734, 0.6672, 0.9001]. It is also
important to note that only the first metric of a multi-metric run is
used to evaluate every step of the bayesian optimization and to select
the winning model.
Tip
Some plots let you choose which of the metrics to show using the
metric
parameter.
Parameter customization
By default, the parameters every estimator uses are the same default
parameters they get from their respective packages. To select different
ones, use est_params
. There are two ways to add custom parameters to
the models: adding them directly to the dictionary as key-value pairs
or through multiple dicts with the model names as keys.
Adding the parameters directly to est_params
will share them across
all models in the pipeline. In this example, both the XGBoost and the
LightGBM model will use n_estimators=200. Make sure all the models do
have the specified parameters or an exception will be raised!
atom.run(["XGB", "LGB"], est_params={"n_estimators": 200})
To specify parameters per model, use the model name as key and a dict of the parameters as value. In this example, the XGBoost model will use n_estimators=200 and the Multi-layer Perceptron will use one hidden layer with 75 neurons.
atom.run(["XGB", "MLP"], est_params={"XGB": {"n_estimators": 200}, "MLP": {"hidden_layer_sizes": (75,)}})
Some estimators allow you to pass extra parameters to the fit method
(besides X and y). This can be done adding _fit
at the end of the
parameter. For example, to change XGBoost's verbosity, we can run:
atom.run("XGB", est_params={"verbose_fit": True})
Note
If a parameter is specified through est_params
, it is
ignored by the bayesian optimization!
Hyperparameter optimization
In order to achieve maximum performance, we need to tune an estimator's
hyperparameters before training it. ATOM provides hyperparameter tuning
using a bayesian optimization
(BO) approach implemented by skopt.
The BO is optimized on the first metric provided with the metric
parameter. Each step is either computed by cross-validation on the
complete training set or by randomly splitting the training set every
iteration into a (sub) training set and a validation set. This process
can create some data leakage but ensures maximal use of the provided
data. The test set, however, does not contain any leakage and is
used to determine the final score of every model. Note that, if the
dataset is relatively small, the BO's best score can consistently be
lower than the final score on the test set (despite the leakage) due
to the considerable fewer instances on which it is trained.
There are many possibilities to tune the BO to your liking. Use
n_calls
and n_initial_points
to determine the number of iterations
that are performed randomly at the start (exploration) and the number
of iterations spent optimizing (exploitation). If n_calls
is equal to
n_initial_points
, every iteration of the BO will select its
hyperparameters randomly. This means the algorithm is technically
performing a random search.
Note
The n_calls
parameter includes the iterations in n_initial_points
,
i.e. calling atom.run("LR", n_calls=20, n_intial_points=10)
will run
20 iterations of which the first 10 are random.
Note
If n_initial_points=1
, the first trial is equal to the
estimator's default parameters.
Other settings can be changed through the bo_params
parameter, a
dictionary where every key-value combination can be used to further
customize the BO.
By default, the hyperparameters and corresponding dimensions per model
are predefined by ATOM. Use the dimensions
key to use custom ones.
Just like with est_params
, you can share the same dimensions across
models or use a dictionary with the model names as keys to specify the
dimensions for every individual model. Note that the provided search
space dimensions must be compliant with skopt's API.
atom.run("LR", n_calls=10, bo_params={"dimensions": [Integer(100, 1000, name="max_iter")]})
The majority of skopt's callbacks to stop the optimizer early can be
accessed through bo_params
. You can include other callbacks using
the callbacks
key.
atom.run("LR", n_calls=10, bo_params={"max_time": 1000, "callbacks": custom_callback()})
You can also include other parameters for the optimizer as key-value pairs.
atom.run("LR", n_calls=10, bo_params={"acq_func": "EI"})
Bagging
After fitting the estimator, you can asses the robustness of the model
using bootstrap aggregating
(bagging). This technique creates several new data sets selecting random
samples from the training set (with replacement) and evaluates them on
the test set. This way we get a distribution of the performance of the
model. The number of sets can be chosen through the bagging
parameter.
Tip
Use the plot_results method to plot the bagging scores in a boxplot.
Early stopping
XGBoost, LightGBM and CatBoost
allow in-training evaluation. This means that the estimator is evaluated
after every round of the training, and that the training is stopped
early if it didn't improve in the last early_stopping
rounds. This
can save the pipeline much time that would otherwise be wasted on an
estimator that is unlikely to improve further. Note that this technique
is applied both during the BO and at the final fit on the complete
training set.
There are two ways to apply early stopping on these models:
- Through the
early_stopping
key inbo_params
. This approach applies early stopping to all models in the pipeline and allows the input of a fraction of the total number of rounds. - Filling the
early_stopping_rounds
parameter directly inest_params
. Don't forget to add_fit
to the parameter to call it from the fit method.
After fitting, the model will get the evals
attribute, a dictionary of
the train and test performances per round (also if early stopping wasn't
applied). Click here
for an example using early stopping.
Tip
Use the plot_evals method to plot the in-training evaluation on the train and test set.
Successive halving
Successive halving is a bandit-based algorithm that fits N models to 1/N of the data. The best half are selected to go to the next iteration where the process is repeated. This continues until only one model remains, which is fitted on the complete dataset. Beware that a model's performance can depend greatly on the amount of data on which it is trained. For this reason, we recommend only to use this technique with similar models, e.g. only using tree-based models.
Use successive halving through the SuccessiveHalvingClassifier/SuccessiveHalvingRegressor
classes or from atom via the successive_halving
method. Consecutive runs of the same model are saved with the model's acronym
followed by the number of models in the run. For example, a
Random Forest in a run with 4 models would become model
RF4
.
Click here for a successive halving example.
Tip
Use the plot_successive_halving method to see every model's performance per iteration of the successive halving.
Train sizing
When training models, there is usually a trade-off between model performance and computation time that is regulated by the number of samples in the training set. Train sizing can be used to create insights in this trade-off and help determine the optimal size of the training set, fitting the models multiple times, ever increasing the number of samples in the training set.
Use train sizing through the TrainSizingClassifier/TrainSizingRegressor
classes or from atom via the train_sizing
method. The number of iterations and the number of samples per training
can be specified with the train_sizes
parameter. Consecutive runs of the
same model are saved with the model's acronym followed by the fraction of
rows in the training set (the .
is removed from the fraction!). For example,
a Random Forest in a run with 80% of the training samples
would become model RF08
.
Click here for a train sizing example.
Tip
Use the plot_learning_curve method to see the model's performance per size of the training set.
Voting
The idea behind Voting is to combine the predictions of conceptually different models to make new predictions. Such a technique can be useful for a set of equally well performing models in order to balance out their individual weaknesses. Read more in sklearn's documentation.
A Voting model is created from a trainer through the voting
method. The Voting model is added automatically to the list of
models in the pipeline, under the Vote
acronym. Although similar,
this model is different from the VotingClassifier and VotingRegressor
estimators from sklearn. Remember that the model is added to the
plots if the models
parameter is not specified. Plots that require
a data set will use the one in the current branch. Plots that require
an estimator object will raise an exception.
The Voting class has the same prediction attributes and prediction
methods as other models. The predict_proba
, predict_log_proba
,
decision_function
and score
methods return the average predictions
(soft voting) over the models in the instance. Note that these methods
will raise an exception if not all estimators in the Voting instance
have the specified method. The predict
method returns the majority
vote (hard voting). The scoring
method also returns the average
scoring for the selected metric over the models.
Click here for a voting example.
Warning
Although it is possible to include models from different branches in the same Voting instance, this is highly discouraged. Data sets from different branches with unequal shape can result in unexpected errors for plots and prediction methods.
Stacking
Stacking is a method for combining estimators to reduce their biases. More precisely, the predictions of each individual estimator are stacked together and used as input to a final estimator to compute the prediction. Read more in sklearn's documentation.
A Stacking model is created from a trainer through the stacking
method. The Stacking model is added automatically to the list of
models in the pipeline, under the Stack
acronym. Remember that the
model is added to the plots if the models
parameter is not
specified. Plots that require a data set will use the one in the
current branch. The prediction methods, the scoring method and the
plot methods that require an estimator object will use the Voting's
final estimator, under the estimator
attribute.
Click here for a stacking example.
Warning
Although it is possible to include models from different branches in the same Stacking instance, this is highly discouraged. Data sets from different branches with unequal shape can result in unexpected errors for plots and prediction methods.
Predicting
After running a successful pipeline, it is possible you would like to
apply all used transformations onto new data, or make predictions using
one of the trained models. Just like a sklearn estimator, you can call
the prediction methods from a fitted trainer, e.g. atom.predict(X)
.
Calling the method without specifying a model will use the winning model
in the pipeline (under attribute winner
). To use a different model,
simply call the method from a model, e.g. atom.KNN.predict(X)
.
All prediction methods transform the provided data through the data cleaning and feature engineering transformers before making the predictions. By default, this excludes outlier handling and balancing the dataset since these steps should only be applied on the training set. Use the method's kwargs to select which transformations to use in every call.
The available prediction methods are a selection of the most common methods for estimators in sklearn's API:
| transform | Transform new data through all transformers in a branch. |
| predict | Transform new data through all transformers in a branch and return class predictions. |
| predict_proba | Transform new data through all transformers in a branch and return class predictions. |
| predict_log_proba | Transform new data through all transformers in a branch and return class log-probabilities. |
| decision_function | Transform new data through all transformers in a branch and return predicted confidence scores. |
| score | Transform new data through all transformers in a branch and return the model's score. |
Except for transform, the prediction methods can be calculated on the train
and test set. You can access them through the model's prediction attributes,
e.g. atom.mnb.predict_train
or atom.mnb.predict_test
. Keep in mind that
the results are not calculated until the attribute is called for the first
time. This mechanism avoids having to calculate attributes that are never
used, saving time and memory.
Note
Many of the plots use the prediction attributes. This can
considerably increase the size of the class for large datasets. Use
the reset_predictions
method if you need to free some memory!
Plots
After fitting the models to the data, it's time to analyze the results. ATOM provides many plotting methods to compare the model performances. Descriptions and examples can be found in the API section. ATOM uses the packages matplotlib, seaborn and shap for plotting.
The plot methods can be called from a training
directly, e.g.
atom.plot_roc()
, or from one of the models, e.g. atom.LGB.plot_roc()
.
If called from training
, it will make the plot for all models in
the pipeline. This can be useful to compare the results of multiple
models. If called from a model, it will make the plot for only that
model. Use this option if you want information just for that specific
model or to make a plot less crowded.
Parameters
Apart from the plot-specific parameters they may have, all plots have four parameters in common:
- The
title
parameter allows you to add a custom title to the plot. - The
figsize
parameter adjust the plot's size. - The
filename
parameter is used to save the plot. - The
display
parameter determines whether the plot is rendered.
Aesthetics
The plot aesthetics can be customized using the plot attributes, e.g.
atom.style = "white"
. These attributes can be called from any instance
with plotting methods. Note that the plot attributes are attached to the
class and not the instance. This means that changing the attribute will
also change it for all other instances in the module. ATOM's default
values are:
- style: "darkgrid"
- palette: "GnBu_r_d"
- title_fontsize: 20
- label_fontsize: 16
- tick_fontsize: 12
Use the reset_aesthetics
method to reset all the aesthetics to their
default value.
Canvas
Sometimes it might be desirable to draw multiple plots side by side in order
to be able to compare them easier. Use the atom's canvas
method for this. The canvas method is a @contextmanager
, i.e. it is
used through the with
command. Plots in a canvas will ignore the
figsize, filename and display parameters. Instead, call these parameters
from the canvas for the final figure.
For example, we can use a canvas to compare the results of a XGBoost and LightGBM model on the train and test set. We could also draw the lines for both models in the same axes, but then the plot could become too messy.
atom = ATOMClassifier(X, y)
atom.run(["xgb", "lgb"], n_calls=0)
with atom.canvas(2, 2, title="XGBoost vs LightGBM", filename="canvas"):
atom.xgb.plot_roc(dataset="both", title="ROC - XGBoost")
atom.lgb.plot_roc(dataset="both", title="ROC - LightGBM")
atom.xgb.plot_prc(dataset="both", title="PRC - XGBoost")
atom.lgb.plot_prc(dataset="both", title="PRC - LightGBM")
SHAP
The SHAP (SHapley Additive exPlanations) python package uses a game theoretic approach to explain the output of any machine learning model. It connects optimal credit allocation with local explanations using the classic Shapley values from game theory and their related extensions. ATOM implements methods to plot 7 of SHAP's plotting functions directly from its API. The seven plots are: bar_plot, beeswarm_plot, decision_plot, force_plot, heatmap_plot, scatter_plot and waterfall_plot.
Since the plots are not made by ATOM, we can't draw multiple models in
the same figure. Selecting more than one model will raise an exception.
To avoid this, call the plot directly from a model, e.g. atom.xgb.force_plot()
.
Info
You can recognize the SHAP plots by the fact that they end (instead
of start) with the word plot
.
Available plots
A list of available plots can be find hereunder. Note that not all plots can be called from every class and that their availability can depend on the task at hand.
| plot_correlation | Plot the data's correlation matrix. |
| plot_scatter_matrix | Plot the data's scatter matrix. |
| plot_qq | Plot a quantile-quantile plot. |
| plot_distribution | Plot column distributions. |
| plot_pipeline | Plot a diagram of every estimator in atom's pipeline. |
| plot_pca | Plot the explained variance ratio vs the number of components. |
| plot_components | Plot the explained variance ratio per components. |
| plot_rfecv | Plot the RFECV results. |
| plot_successive_halving | Plot of the models" scores per iteration of the successive halving. |
| plot_learning_curve | Plot the model's learning curve. |
| plot_results | Plot a boxplot of the bagging's results. |
| plot_bo | Plot the bayesian optimization scoring. |
| plot_evals | Plot evaluation curves for the train and test set. |
| plot_roc | Plot the Receiver Operating Characteristics curve. |
| plot_prc | Plot the precision-recall curve. |
| plot_permutation_importance | Plot the feature permutation importance of models. |
| plot_feature_importance | Plot a tree-based model's feature importance. |
| plot_partial_dependence | Plot the partial dependence of features. |
| plot_errors | Plot a model's prediction errors. |
| plot_residuals | Plot a model's residuals. |
| plot_confusion_matrix | Plot a model's confusion matrix. |
| plot_threshold | Plot metric performances against threshold values. |
| plot_probabilities | Plot the probability distribution of the classes in the target column. |
| plot_calibration | Plot the calibration curve for a binary classifier. |
| plot_gains | Plot the cumulative gains curve. |
| plot_lift | Plot the lift curve. |
| bar_plot | Plot SHAP's bar plot. |
| beeswarm_plot | Plot SHAP's beeswarm plot. |
| decision_plot | Plot SHAP's decision plot. |
| force_plot | Plot SHAP's force plot. |
| heatmap_plot | Plot SHAP's heatmap plot. |
| scatter_plot | Plot SHAP's scatter plot. |
| waterfall_plot | Plot SHAP's waterfall plot. |


Event Location:
River City Labs
Lvl 3 TCB Building, 315 Brunswick street Fortitude Valley
Brisbane, Queensland, Australia
Abstract:
For a number of years, Azure Data Sync was stuck in "preview" mode in the old classic deployment model and with no updates on functionality over that time many thought that it was destined for the scrap heap. However with the recent revival and port to the Azure Resource Manager model it has become a viable option for organisations looking to deploy applications that are partially SaaS but with on local on-premises component. This session will show how one organisation has used Azure Data Sync to allow for centralised management of point-of-sales terminals across multiple retail groups. The session will discuss the SaaS based component built on Azure SQL Database to segregate different retail groups into dedicated databases. From this design the retail group's dedicated management database can then use Data Sync to gather sales and stock metrics from each terminal and push down price changes to selected groups of stores.
Speaker(s): Martin Cairney,
Abstract:
Power BI helps you build appealing visualizations of your data. With ever growing footprint of data it is equally important to get real-time insights into your data. It can be as simple as monitoring a single metric or viewing real-time sales performance across multiple locations. Power BI real-time streaming enables you to stream data and update dashboards in real-time. Any time sensitive data can be a source of streaming data set like IoT sensor devices, social media sources, service usage metrics etc. In this session 1. I will dive deep into real-time analytics with Power BI. 2. How to build streaming tiles in Power BI Dashboards. 3. Demo using Power BI REST APIs. 4. Demo using Azure Event Hub and Azure Stream Analytics.
Speaker(s): Manohar Punna,
Abstract:
Thinking about getting involved with Machine Learning(ML) and are unsure what it can do? This session provides answers the question: Where can ML can provide a solution? As it is important to understand the limitations of ML, the course also reviews when other analytic processes would work better. Learn the steps to ensure that your data is suited for ML analysis and what you can do to fix it. Once attendees understand the workflow, the course will cover the processes used in algorithm selection. We will implement ML solutions in both R and Python to show the strengths and limitations of each in SQL Server 2017. Session Goals • Understand the Machine Learning development process including data analytics and algorithm selection • Learn why to use either R or Python given the task being performed • Know how to implement a machine learning solution as part of database solution in SQL Server .
Speaker(s): Ginger Grant,
Abstract:
This 500 level session will focus on using undocumented statements and trace flags to get insight into how the query optimizer works and show you which operations it performs during query optimization. I will use these undocumented features to explain what the query optimizer does from the moment a query is submitted to SQL Server until an execution plan is generated including operations like parsing, binding, simplification, trivial plan, and full optimization. Concepts like transformation rules, the memo structure, how the query optimizer generates possible alternative execution plans, and how the best alternative is chosen based on those costs will be explained as well.
Speaker(s): Benjamin Nevarez,
Abstract:
With analytics becoming a buzzword in the recent past, everyone seems to want it in their businesses. Known as business intelligence for a long time, it helps an organization’s various decision makers take better business decisions using the insights that is provided. However, the path to a successful business intelligence implementation was always hounded by failure – The main reason being that BI is conceived as a one-time-implemented packaged solution, whereas business intelligence is in reality a journey. This session will focus on how you could develop a business intelligence solution by taking the organization on an evolving journey, using the various Microsoft tools and technologies at different stages.
Speaker(s): Gogula Aryalingam,
Abstract:
It’s almost a daily occurrence to hear about some sort of data breach. But what are the consequences of a data breach – for both the victims and companies involved – and what does that mean for you as a data professional. As governments start to legislate more in an effort to protect the privacy of its citizens the entire concept of data storage become more complex. Exactly what is legislation like the General Data Protection Regulation (GDPR) and how will it affect around the world. We’re seen Microsoft give us tools over the years – like Transparent Data Encryption and Dynamic Data masking - to help with this sort of thing – but is there a better answer? Come along to this session and hear how you and your team can lessen your chances of being the ones responsible for the next data breach.
Speaker(s): Martin Catherall,
Abstract:
Test Driven Development (TDD) is a design approach which has enabled application developers to write cleaner code. It is relevant for database development as it ensures that code produced using TDD and unit tests will be of higher quality which means interactions with data will be safer. TDD is not a new method of unit testing, it is an essential design practice for improving the quality of your deployed code. In this session it will be shown how we can use TDD to design and write better unit tests using open-source frameworks and industry standard tools. These tools can be run within SQL Server Management Studio which means DBAs can also take advantage of TDD and unit test, to ensure more reliable code is deployed to databases. TDD can result in code that can be deployed more reliably and faster when using DevOps processes such as Continuous Integration and Continuous Delivery. A comprehensive DEMO will reveal how Test Driven Development can help you deploy database code safer.
Speaker(s): Hamish Watson,
Abstract:
Practical SQL Server Performance Tuning Pre-Con is designed for the working SQL professional who has the relevant experience with SQL Server and only needs practical examples of SQL performance query tuning that can be applied in production right away. In this full-day training, participants will see relevant, crisp, real-world examples of SQL Server tuning focusing on common Practical Performance Troubleshooting Pre-Con is designed for the working SQL Server professional who has the relevant experience with SQL Server and only needs practical examples of troubleshooting SQL Server performance that can be applied in production right away. In this full-day training, participants will see relevant, crisp, real-world examples of common performance areas. An 8-hour, 100% demo-oriented delivery on SQL Server Performance Troubleshooting. Basic to Intermediate level, covering important aspects. Topics Include: Module 1: CPU Troubleshooting (Scheduling), IO Troubleshooting, Memory Trou
Speaker(s): Amit R S Bansal,
Abstract:
Both Availability Groups and Azure are big talking points when it comes to SQL Server. Deploying Availability Groups to Azure, requires an understanding of the infrastructure-based components that support an SQL Server install. In this session, we go beyond the traditional database silo, as we walk through all the steps required to successfully configure AlwaysOn Availability groups, exclusively in Azure.
Speaker(s): Michael van Halderen,
Abstract:
In this session I will give an intro into all the various aspects for Power BI, starting with Power BI Desktop (Importing data create a measure), using the Power BI Service (Creating Dashboards, updating reports, creating App Workspaces, creating Apps, sharing of dashboards content) It will an interactive demo based session, where the goal will be for the user to walk away with a better understanding of what Power BI is capable of
Speaker(s): Gilbert Quevauvilliers,
Abstract:
Are you a whizz at SQL and curious about learning more about DAX? This session will be aimed to share some helpful tips and tricks for creating beautiful DAX when building Power BI reports or Tabular Cubes. Most people who learn DAX come from an Excel background, but this session will be tailored to those used to set based approaches such as SQL.
Speaker(s): Phillip Seamark,
Abstract:
Welcome to the dungeon. Yes, SQL Server memory concepts are like entering a dungeon where you are guaranteed to get lost. It’s dark and complex out there and not many have come back alive. This session will help you find your way out of the dungeon. In this deep-dive session you will understand SQL Server memory architecture, how the database engine consumes memory and how to track memory usage. Complex concepts will be made simple and you will see some light beyond the darkness. Finally, you will learn how to troubleshoot common memory issues.
Speaker(s): Amit R S Bansal,
Abstract:
With the pending release of SQL Server Managed Instance, the capabilities of the product as a near 100% compatible with an on premises instance will be discussed. What will be addressed are the capabilities of the product, features that are supported, how to migrate with the azure database migration service and what used cases would make you select this product.
Speaker(s): Henry Rooney,
Abstract:
Powershell has been part of Windows for > 10 years and has been part of SQL Server since 2008. In spite of this the adoption among Database Professionals for use in investigating and managing their environments has been low. With the release of the open source DBA Tools module from DBATools.IO, with its 300+ commands, the time has arrived for Database Professionals to embrace PowerShell and upgrade their skills to support the modern Hybrid environment. In this session we will look how to download, install and begin using the power within both this module and Powershell. No prior experience with Powershell required!
Speaker(s): Patrick Flynn,
Abstract:
Most SQL Server developers and DBAs work with SQL Server Management Studio (SSMS) all the time. But SSMS is a very capable tool and most users only know how to use a fraction of its features. Join Greg to see his favourite tips and tricks for working with SSMS.
Speaker(s): Greg Low,
Abstract:
In SQL 2016, SQL Server Reporting Services (SSRS) underwent massive changes with the addition of many new reporting features. Since that release, there have been many further developments, including the release of Power BI Report Server and SSRS 2017. In this demo laden session, Craig will recap the changes that SSRS has undergone from SSRS 2016 onwards, as well as look at and discuss Power BI Report Server.This session will be valuable for anyone new to SSRS, or anyone who has not had an opportunity to work with the latest versions of SSRS.
Speaker(s): Craig Bryden,
Abstract:
Advanced data analytics does not live only in the realm of data scientists. The necessary tools now exist in SQL Server 2017 using the language which is number one on the list of most popular programming languages today, Python. This session will provide and introduction to Python, cover how to integrate the language into SQL Server, demonstrate how to use Python in stored procedures and review how you can determine the resources that Python is using within SQL Server.
Speaker(s): Ginger Grant,
Abstract:
Organisations capture huge volumes of data and they need actionable information to act on them proactively in real-time to stay competitive. This requires a different thinking from the conventional Data Warehouse Architecture to more Cloud based Data Processing Architecture where high volume batch and real-time processing can be achieved using optimal cost. In this session you will learn about 1. Overview of Lambda Architecture 2. How Azure Services implement Lambda Architecture 3. Advantages of leveraging Azure for Lambda Architecture 4. Business Scenarios to consider Lambda Architecture 5. End to End Demo
Speaker(s): Anupama Natarajan,
This is a list of speakers from the XML Guidebook records. The details and URLs were valid at the time of the event.
LinkedIn: https://nz.linkedin.com/in/hamishwatson8
Contact: http://www.sqlservercentral.com/blogs/the-hybrid-dbas-blog/
Hamish Watson is a Microsoft Data Platform MVP and VMware Expert with a passion for efficient database and application deployment using DevOps methodologies. He has 20+ years of IT experience in managing and deploying large scale databases on SQL Server technologies. He has been managing SQL Server since SQL Server 2000, and pragmatic approaches to delivering business value to clients is his career passion. Educating and helping others learn is a driver for Hamish. He is a Director-At-Large on the PASS Board, international speaker, and a repeat guest lecturer at a local university.
LinkedIn: https://www.linkedin.com/pub/manohar-punna/15/153/508
Contact: http://www.sqlservergeeks.com/author/manoharpunna/
Manohar Punna is an Data Platform Geek and Vice President of DataPlatformGeeks by passion and a Data Platform Consultant by profession. He is a speaker at various conferences like PASS Summit, SQLBits, DPS. He has authored over 150 blogs and has written a One DMV a Day series which is a longest one day series on any topic on SQL Server till date. Manohar is a product of this community and strongly believes in giving back to the community. So, ask him anything you would like to know and he is happy to learn it with you.
LinkedIn: https://www.linkedin.com/in/fourmoo/
Contact: https://www.fourmoo.com/blog
Power BI Data Analytics Consultant with over 12 years experience. From small to enterprise implementations on Azure (Azure Analysis Services, Function Apps, Runbooks, Automation Accounts, SQL Serverless DB) and On-Premise Microsoft Platform (SQL Server, Integration Services, Analysis Services Multidimensional and Tabular, Reporting Services) Recently I have focused on Power BI, with its rapidly changing features and incredible uptake it has allowed me to consult in a variety of different and challenging solutions. I was awarded the Microsoft MVP award for Power BI since 2017. I have spoken at the Microsoft Business Applications Summit (Seattle Atlanta), Power BI World Tour,SQL Saturdays other events.
LinkedIn: http://www.linkedin.com/in/AmitBansal2010
Amit R. S. Bansal is a SQL Server Specialist at SQLMaestros. He leads the SQL Server practice with a focused team providing consulting, training, and content development services to more than 160+ SQL customers globally. He frequently speaks at international conferences on SQL Server performance tuning, which is his core expertise. Amit is also honored with Microsoft Regional Director status, MVP award, and Microsoft Certified Master of SQL Server credential. Amit has been working with SQL Server since 1999 and has been part of countless mission-critical SQL deployments. Performance Tuning in SQL Server is his core area of expertise. To learn more about Amit, visit http://sqlmaestros.com/amit-bansal.
LinkedIn: https://www.linkedin.com/in/craigbryden/
Craig has been working with SQL Server for over 20 years and currently holds several SQL Server based certifications. He has also previously held an MCT certification. Craig's contribution to the SQL Server community was recognised in 2018 with a Microsoft MVP award. He was involved with Microsoft Learning to set some of the current SQL server Exams. Craig is the Chief Data Strategist at BiTQ. Craig is an organiser of the QLD Power BI User Group
LinkedIn: https://www.linkedin.com/in/ginger-grant-3a177b157/
Contact: http://www.DesertIsleSQL.com
Ginger Grant manages the consultancy Desert Isle Group and shares what she has learned while working with data technology to people around the world. As a Microsoft MVP in Data Platform, Microsoft Certified Trainer and an instructor on DataCamp, she focuses on guiding clients to create solutions using the entire Microsoft Data Stack, which includes SQL Server, Power BI, and Azure Data Cloud components. When not working, she protypes the latest pre-release data technologies, maintains her blog http://www.desertislesql.com, and spends time on twitter @desertislesql.
LinkedIn: https://www.linkedin.com/in/ginger-grant-3a177b157/
Contact: http://www.DesertIsleSQL.com
Ginger Grant manages the consultancy Desert Isle Group and shares what she has learned while working with data technology to people around the world. As a Microsoft MVP in Data Platform, Microsoft Certified Trainer and an instructor on DataCamp, she focuses on guiding clients to create solutions using the entire Microsoft Data Stack, which includes SQL Server, Power BI, and Azure Data Cloud components. When not working, she protypes the latest pre-release data technologies, maintains her blog http://www.desertislesql.com, and spends time on twitter @desertislesql.
LinkedIn: http://www.linkedin.com/in/greglow
Contact: http://blog.greglow.com
Greg Low is well-known in the SQL Server community as a mentor, trainer, author, and community leader. He is a certified master for SQL Server, was an instructor in that program, and holds a PhD in Computer Science. Microsoft often calls on Greg to develop data-related content, and to train their staff. He regularly speaks at tier-one conferences internationally. Greg is best known for his SQL Down Under podcast, SDU Tools, and his eBooks and whitepapers. He heads up a boutique consultancy called SQL Down Under in Melbourne Australia. Greg has been awarded as an MVP since 2001.
LinkedIn: http://www.linkedin.com/in/AmitBansal2010
Amit R. S. Bansal is a SQL Server Specialist at SQLMaestros. He leads the SQL Server practice with a focused team providing consulting, training, and content development services to more than 160+ SQL customers globally. He frequently speaks at international conferences on SQL Server performance tuning, which is his core expertise. Amit is also honored with Microsoft Regional Director status, MVP award, and Microsoft Certified Master of SQL Server credential. Amit has been working with SQL Server since 1999 and has been part of countless mission-critical SQL deployments. Performance Tuning in SQL Server is his core area of expertise. To learn more about Amit, visit http://sqlmaestros.com/amit-bansal.
LinkedIn: https://au.linkedin.com/in/henryrooney
Having worked with SQL Server for more years that I can remember I am still enthusiastic about the product encouraging business to take advantage of the second greatest asset they have, their data!!! I have presented at numerous user groups and SQL Saturdays and enjoy sharing my thoughts and receiving feedback on what my thoughts are.
LinkedIn: https://www.linkedin.com/in/martincatherall
Contact: http://martincatherall.com
Martin is a data consultant in Melbourne, Australia, a Microsoft Data Platform MVP, and PASS Regional Mentor for the Asia Pacific (APAC) region. Martin founded the Christchurch, New Zealand PASS Local Group and lead the group for a number of years before relocating to Melbourne. He has been using SQL Server in various roles since 2000. In addition to anything data related, he enjoys playing the guitar and having fun with his family.
Contact: http://www.benjaminnevarez.com/
Benjamin Nevarez is a SQL Server independent consultant based in Los Angeles, California, who specializes in SQL Server query tuning and optimization. He is the author of “SQL Server 2014 Query Tuning amp; Optimization” and “Inside the SQL Server Query Optimizer” and co-author of “SQL Server 2012 Internals.quot; Benjamin has also been a speaker at many SQL Server conferences, including PASS Summit, SQL Server Connections, and SQLBits. His blog can be found at http://www.benjaminnevarez.com.
LinkedIn: http://www.linkedin.com/in/gogula
Contact: http://datamaul.wordpress.com
Gogula is a data analytics professional from Sri Lanka, with 14+ years on the Microsoft data platform. He has worked with many aspects of data analytics and BI solutions from architecting, designing, developing and consulting across various industries and verticals. He is Regional Mentor for PASS South Asia, Data Platform MVP, MCSE, former MCT, and MSc in IT. Gogula's passion revolves data analytics and BI; hence enjoys writing, teaching and speaking about the things he works with. He was also involved as an SME for Microsoft certification development. He currently juggles his full time job as Lead Architect while speaking at local and foreign events, along with regular stints at the Sri Lankan Data Community which he co-founded.
Contact: http://sqllensman.com/blog/
Patrick Flynn is a Senior Database Administrator with 10 years experience in large 24 x 7 enterprise environments. He is a certified master for SQL Server and a regular attendee of the PASS Summit. Has presented at SQLSaturday events in Sydney, Melbourne, Brisbane and Auckland, Edmonton and Calgary, Oslo and Cambridge
LinkedIn: https://nz.linkedin.com/in/anupama-natarajan-516a107
Contact: http://www.anupamanatarajan.com
Anu Natarajan is a Data and AI Consultant with 15+ years of experience working in design and development of Data Warehouse, Business Intelligence, AI enabled applications, and SaaS integrated solutions. Anu is a Microsoft MVP Data Platform, Microsoft Certified Trainer and passionate in sharing knowledge. She loves solving complex business problems with innovative solutions using technologies. Anu also speaks at conferences including PASS Summit, SQL Saturdays, Data Platform Summit, Difinity, and she organizes local user group meetups.
Contact: http://www.serioussqlserver.com
Michael van Halderen is an independent SQL Server professional who has been working in the IT industry for over 15 years. He has worked exclusively with SQL server for more than 10 years in both DBA and DB Developer roles in Australia and the UK. Michael has contributed to SQL Server course development in Redmond, is an MCSE: Data Platform; and is certified to implement Azure Infrastructure solutions.
LinkedIn: http://au.linkedin.com/in/martincairney
Martin has 20 years’ experience in SQL Server technologies. His experience spans both the Database Engine and infrastructure requirements, and Data Warehousing and BI implementations. He has worked across many industry sectors including London’s global financial institutions and both State and Federal Government Departments. He is a SQL Server MVP, MCT and an experienced conference presenter, having presented at PASS Summit, SQLBits, and SQL Saturday events and User Groups round the world
LinkedIn: https://www.linkedin.com/in/seamark
An accomplished database and business intelligence (BI) professional with an in-depth knowledge of the Microsoft BI stack along with extensive knowledge of data warehouse (DW) methodologies and enterprise data modelling. Expert knowledge in all facets of BI/DW including planning architecture, project management, dimensional modelling, performance tuning, ETL design, development and optimization, report and dashboard design as well as installation and administration. Author of multiple books on DAX. Over 27 years of commercial experience in delivering business applications across a broad range of technologies.
The following is a list of sponsors that helped fund the event.


|
Model-View-Controller
This architecture is used in simple GUI applications.
The architecture is event-driven, which means that all activity starts by some event and is propagated by
some other events.
The model is the information contents of the component. It can be as simple as an integer or a string,
and as complex as an interface to an external database. The MVC component does not need to contain the
model itself. It may contain just a link to the model. And this is common if multiple MVC components
are connected to a model.
The view is the visual representation of the component, usually on a computer screen. It can be a textbox or a button in a form on the screen,
anything that represents the model or part of it. Try to think of the view as only the visual aspect
of the component. I.e. just the picture of the textbox that can in itself not be manipulated by a keypress
or mouseclick. The controller takes care of all the action. It is sent external events like keypresses, mouseclicks, mousemoves, timer updates, etc. It knows how to change the model in response to these events and it it also knows how to change the component's state in the view. If one for example presses a key when a textbox is active, the controller tells the model to add the character to the string and it tells the view to advance the cursor position. Examples
Where does it come from?The MVC architecture was developed as part of the Smalltalk group at the famous Xerox PARC. It is usually credited to the Norwegian Trygve Reenskaug, who worked there as a visiting scientist in 1978/1979. MVC is since then an integral part of the Smalltalk programming language.When should you use it?Most often you don't need to build such an architecture from scratch. The architectures usually come with visual programming environments (like Visual C++, JBuilder, etc. etc.) which create the code for all MVC components for you, together with the event handling mechanisms required. If this is so, it is still useful to know the basics of the architecture you're working with.How does it work?An MVC component is created in these steps
The control flow within an MVC component. The controller receives an event, say a keypress from the user (1). Depending on its own logic, it processes the event, and updates the model (2a) or only the characteristics of the view (2b). The model notifies the view(s) (3). The view updates itself as can be seen by the user (4). If the model is changed, not only the view of the component is notified, but also the views of other components which registered themselves to the model. In the next picture the same component as before is shown on top and a registered component is shown below. The view of the registered component receives a notification from the model (3). The view updates itself as can be seen by the user (4). Common implementation techniques
Links |


Overview
Learning Experience
Curriculum
Outcome
Ratings & Reviews
As of now, there’s no prototype available for Tablets
Please use your desktop/laptop to view this prototype
As of now, there’s no prototype available for mobile devices
Please use your desktop/laptop to view this prototype
Overview
Learning Experience
Curriculum


Deliver digital products that make a bottom line difference with Toronto's multichannel experience design studio, Say Yeah!
Consider your customer’s journey from awareness to purchase to support. Each interaction throughout this journey plays a role in defining the experience for your users.
Most importantly, these interactions give you an opportunity to move each user from potential customer to vocal advocate.
We’ll work with you to design a customer journey that delivers those advocates, from service design to product strategy, design to deployment, validating each step of the way.
Learn more about our approachDelivering products that have a bottom line impact requires a mix of services that allow you to improve each step of the customer journey.
Improving conversions, decision-making, contextual use, and validation are the pillars of our problem solving. If you’re facing one or more of these challenges, get in touch.
We’ll help you improve user flows and transactional results within a product, such as signups, checkouts, or other calls to action.
We’ll provide your team with the tools they need to improve service delivery at each stage of the customer journey, from communications to online products, sales to support.
We’ll ensure your users find, view, and interact with information and data in an intuitive, rewarding way, improving insight, and driving action.
We’ll define purposeful experiences for users with different devices and screen sizes, considering when, where, and how they’re interacting with your business and what it will take to drive them to action.
We'll provide the tools and expertise to measure product releases over time, ensuring design and engineering efforts are meeting business and user goals.
From market validation to raising money, bringing new products to market to making an existing one work, we’re proud to have helped companies of all sizes deliver better products.
View our client list by industryOptimizing operations to deliver customer value: how fixing a poorly designed internal system saved Virgin Gaming’s most valued customers.
View the Virgin Gaming case studyIf you have a new product you’re working on bringing to market, here are a number of tools and services to help you find product/market fit.
Let's get startedMeasuring the value of your existing product has never been easier. Here are some tools and services to get you started.
Let's get startedWe solve meaningful problems, finding the right balance between business goals and user needs in a way that serves your bottom line.
Our custom services mix covers the full lifecycle of a product:


The trade volume chart represents the trade volume for a curated list of markets on the network. The 'Live' option shows data from the last 24 hours, updated every 5 minutes. The 'Historical' option shows data for the selected date, UTC time.
Each currency traded is represented by an arc on the outer circle, with its length representing its volume relative to all others on the circle. Hover over the name of a currency or its arc to highlight that currency's portion of exchange volume. The chord between two arcs represents the relative volume of exchanges between the currencies at each end. Hover over one of these chords to highlight that market exclusively.
The column on the left shows the number of exchanges and the total volume traded, normalized to the display currency. Filter the currencies shown here by clicking the name or arc of that currency.
The right column shows volume data for all currencies, a single currency, or a single market, depending on highlighting. Data includes the total volume for the currency/pair normalized to the display currency, the total volume in nominal terms, a count of exchanges, and a percentage of the total volume. The total percentage adds up to 200%, because there are always two currencies represented in each trade.