IBM Watson StudioIBM Watson Studio
Log InSign Up
Sync
Migrate
New
New
    Launch IDE
    Add to project
    Add to project
    • BETA
    • BETA
    • BETA
    • BETA
    • Cloud
    • Local
    • Desktop
    • Overview
      • What's new
        • IBM Watson Studio
          • IBM Watson Knowledge Catalog
            • Offering plans
              • Feature matrix
                • About assets
                  • Lineage
                    • Profiles
                      • Previews
                      • Known issues
                        • FAQs
                          • IBM Watson APIs
                            • Security
                              • Keeping your data secure and compliant
                              • Notices
                                • Accessibility
                                • Getting started
                                  • Videos
                                    • Signing up
                                      • Setting up additional account users
                                        • Choosing a tool
                                          • Roles for Watson apps
                                          • Projects
                                            • Creating a project
                                              • Object storage
                                                • Importing a project
                                                • Administering projects
                                                  • Managing collaborators
                                                    • Project collaborator roles
                                                      • Adding associated services
                                                        • Exporting projects
                                                        • Managing assets in projects
                                                          • Environments
                                                            • Default environments
                                                              • Spark environments
                                                                • Data Refinery environments
                                                                  • RStudio environments
                                                                    • Creating environments
                                                                      • Customizing environments
                                                                        • Changing environments
                                                                          • Stopping active runtimes
                                                                            • Runtime usage
                                                                            • Jobs
                                                                              • Adding catalog assets to a project
                                                                                • Leaving a project
                                                                                  • Markdown cheatsheet
                                                                                  • Preparing data
                                                                                    • Adding data to a project
                                                                                      • Adding very large files to a project
                                                                                        • Adding connections to projects
                                                                                          • Connection types
                                                                                            • Controlling access to COS buckets
                                                                                            • Adding data from a connection
                                                                                              • Adding a folder asset from a connection
                                                                                              • Downloading data assets
                                                                                                • Refining data
                                                                                                  • Adding data to Data Refinery
                                                                                                    • Specifying the format of your data
                                                                                                      • Validating your data
                                                                                                        • Visualizing your data
                                                                                                          • Managing Data Refinery flows
                                                                                                            • Copying data from source to target
                                                                                                              • GUI operations
                                                                                                                • dplyr R library support
                                                                                                                  • Updates for Data Refinery July 12
                                                                                                                    • Tutorial: Shape raw data
                                                                                                                    • Data annotation
                                                                                                                      • Annotating data with Figure Eight
                                                                                                                        • Annotating data with DefinedCrowd
                                                                                                                        • Ingesting streaming data
                                                                                                                          • Get started with streams flows
                                                                                                                            • Connections in a streams flow
                                                                                                                              • Creating a connection in a streams flow
                                                                                                                              • Creating a streams flow by using a wizard
                                                                                                                                • Creating a streams flow manually
                                                                                                                                  • Installing Python libraries
                                                                                                                                    • Python model operator
                                                                                                                                      • MQTT (Source and Target) operator
                                                                                                                                        • HTTP operator
                                                                                                                                          • JSON path
                                                                                                                                            • Data types
                                                                                                                                              • Aggregation operator examples
                                                                                                                                                • Buckets, file paths, and partitions in Cloud Object Storage
                                                                                                                                                  • Code operator examples
                                                                                                                                                    • Cloud Function operator
                                                                                                                                                      • Filter operator examples
                                                                                                                                                        • SPSS model operator
                                                                                                                                                          • Event Streams (Source) operator
                                                                                                                                                            • Streams (Source and Target) operators
                                                                                                                                                              • Kafka (Source and Target) operators
                                                                                                                                                              • Importing a streams flow
                                                                                                                                                                • Editing a streams flow
                                                                                                                                                                  • Running a streams flow and monitoring its metrics
                                                                                                                                                                    • Downloading the user log
                                                                                                                                                                      • Downloading streams flow code
                                                                                                                                                                        • Congestion
                                                                                                                                                                          • Running example streams flow
                                                                                                                                                                            • Data Historian example streams flow
                                                                                                                                                                              • Clickstream example streams flow
                                                                                                                                                                              • Tutorials for streams flows
                                                                                                                                                                                • Tutorial for Data Historian
                                                                                                                                                                                  • Tutorial for designing and creating a streams flow
                                                                                                                                                                                    • Tutorial for using a predictive model with streaming data
                                                                                                                                                                                      • Tutorial for metrics
                                                                                                                                                                                  • Data science
                                                                                                                                                                                    • Notebooks
                                                                                                                                                                                      • Creating notebooks
                                                                                                                                                                                        • Parts of a notebook
                                                                                                                                                                                          • The Jupyter and notebook environment
                                                                                                                                                                                          • Libraries and scripts
                                                                                                                                                                                            • Installing custom libraries
                                                                                                                                                                                              • Deep learning libraries for notebooks
                                                                                                                                                                                                • Importing scripts into a notebook
                                                                                                                                                                                                • Coding and running notebooks
                                                                                                                                                                                                  • Loading and accessing data in a notebook
                                                                                                                                                                                                    • Manually adding the project token
                                                                                                                                                                                                      • Using project-lib for Python
                                                                                                                                                                                                        • Using Python functions to work with Cloud Object Storage
                                                                                                                                                                                                          • Using project-lib for R
                                                                                                                                                                                                          • Scheduling a notebook
                                                                                                                                                                                                          • SPSS predictive analytics algorithms
                                                                                                                                                                                                            • Data preparation
                                                                                                                                                                                                              • Classification and regression
                                                                                                                                                                                                                • Clustering
                                                                                                                                                                                                                  • Forecasting
                                                                                                                                                                                                                    • Survival analysis
                                                                                                                                                                                                                      • Score
                                                                                                                                                                                                                      • Visualizations in notebooks
                                                                                                                                                                                                                        • Brunel visualizations
                                                                                                                                                                                                                          • SPSS model visualizations
                                                                                                                                                                                                                            • Linear regression
                                                                                                                                                                                                                              • Logistic regression
                                                                                                                                                                                                                                • Random trees
                                                                                                                                                                                                                                  • Predictor importance
                                                                                                                                                                                                                                • Sharing and publishing notebooks
                                                                                                                                                                                                                                  • Sharing notebooks
                                                                                                                                                                                                                                    • Hiding code in a notebook
                                                                                                                                                                                                                                      • Publishing notebooks on GitHub
                                                                                                                                                                                                                                        • Publishing notebooks as a gist
                                                                                                                                                                                                                                      • RStudio
                                                                                                                                                                                                                                        • Analytics Dashboards
                                                                                                                                                                                                                                        • Machine learning & AI models
                                                                                                                                                                                                                                          • Visual Recognition Models
                                                                                                                                                                                                                                            • Image classification with Core ML
                                                                                                                                                                                                                                              • Setting up
                                                                                                                                                                                                                                                • Custom image classification models
                                                                                                                                                                                                                                                  • Preparing images
                                                                                                                                                                                                                                                    • Training
                                                                                                                                                                                                                                                      • Testing
                                                                                                                                                                                                                                                        • Retraining
                                                                                                                                                                                                                                                          • Moving to a new service instance
                                                                                                                                                                                                                                                          • Custom object detection models
                                                                                                                                                                                                                                                            • Preparing images for object detection
                                                                                                                                                                                                                                                              • Training object detection
                                                                                                                                                                                                                                                                • Testing object detection
                                                                                                                                                                                                                                                                • Built-in models
                                                                                                                                                                                                                                                                  • Developing apps
                                                                                                                                                                                                                                                                    • Sample images
                                                                                                                                                                                                                                                                    • Natural Language Classification
                                                                                                                                                                                                                                                                      • Building a classifier
                                                                                                                                                                                                                                                                        • Preparing training data
                                                                                                                                                                                                                                                                          • Training
                                                                                                                                                                                                                                                                            • Testing
                                                                                                                                                                                                                                                                              • Retraining
                                                                                                                                                                                                                                                                              • Notebooks
                                                                                                                                                                                                                                                                                • Developing apps
                                                                                                                                                                                                                                                                                • Machine Learning
                                                                                                                                                                                                                                                                                  • Supported frameworks
                                                                                                                                                                                                                                                                                    • Getting started
                                                                                                                                                                                                                                                                                      • Terminology
                                                                                                                                                                                                                                                                                        • Custom components
                                                                                                                                                                                                                                                                                          • scikit-learn
                                                                                                                                                                                                                                                                                            • TensorFlow
                                                                                                                                                                                                                                                                                            • Machine Learning plans and runtime usage
                                                                                                                                                                                                                                                                                              • Setting up
                                                                                                                                                                                                                                                                                                • Command line interface
                                                                                                                                                                                                                                                                                                  • Cloud object storage
                                                                                                                                                                                                                                                                                                  • Authentication
                                                                                                                                                                                                                                                                                                    • Service credentials
                                                                                                                                                                                                                                                                                                    • Examples
                                                                                                                                                                                                                                                                                                      • AutoAI tutorial
                                                                                                                                                                                                                                                                                                        • Machine Learning tutorials
                                                                                                                                                                                                                                                                                                          • Neural network modeler
                                                                                                                                                                                                                                                                                                            • Experiment builder
                                                                                                                                                                                                                                                                                                              • Experiment builder (HPO)
                                                                                                                                                                                                                                                                                                                • Python client (notebook)
                                                                                                                                                                                                                                                                                                                  • CLI
                                                                                                                                                                                                                                                                                                                    • CLI (HPO)
                                                                                                                                                                                                                                                                                                                    • Deep Learning sample apps
                                                                                                                                                                                                                                                                                                                      • Deployed function
                                                                                                                                                                                                                                                                                                                        • Node.js
                                                                                                                                                                                                                                                                                                                          • Python Flask
                                                                                                                                                                                                                                                                                                                            • Core ML
                                                                                                                                                                                                                                                                                                                          • Building models
                                                                                                                                                                                                                                                                                                                            • AutoAI
                                                                                                                                                                                                                                                                                                                              • Building an AutoAI model from sample data
                                                                                                                                                                                                                                                                                                                                • Building an AutoAI model
                                                                                                                                                                                                                                                                                                                                  • Selecting an AutoAI model
                                                                                                                                                                                                                                                                                                                                    • Deploying an AutoAI model
                                                                                                                                                                                                                                                                                                                                      • AutoAI implementation details
                                                                                                                                                                                                                                                                                                                                      • Synthesized Neural Networks
                                                                                                                                                                                                                                                                                                                                        • Building Synthesized Neural Network models
                                                                                                                                                                                                                                                                                                                                          • Text training data format
                                                                                                                                                                                                                                                                                                                                            • Image training data format
                                                                                                                                                                                                                                                                                                                                            • Deploying Synthesized Neural Network models
                                                                                                                                                                                                                                                                                                                                              • Testing deployments
                                                                                                                                                                                                                                                                                                                                                • Using deployments
                                                                                                                                                                                                                                                                                                                                                  • Deployment payload format
                                                                                                                                                                                                                                                                                                                                                  • Downloading NeuNetS models
                                                                                                                                                                                                                                                                                                                                                  • Spark MLlib modeler
                                                                                                                                                                                                                                                                                                                                                    • SPSS Modeler
                                                                                                                                                                                                                                                                                                                                                      • Nodes palette
                                                                                                                                                                                                                                                                                                                                                        • Import
                                                                                                                                                                                                                                                                                                                                                          • Data Asset node
                                                                                                                                                                                                                                                                                                                                                            • User Input node
                                                                                                                                                                                                                                                                                                                                                              • Sim Gen node
                                                                                                                                                                                                                                                                                                                                                              • Record Operations
                                                                                                                                                                                                                                                                                                                                                                • Select node
                                                                                                                                                                                                                                                                                                                                                                  • Sample node
                                                                                                                                                                                                                                                                                                                                                                    • Sort node
                                                                                                                                                                                                                                                                                                                                                                      • Balance node
                                                                                                                                                                                                                                                                                                                                                                        • Distinct node
                                                                                                                                                                                                                                                                                                                                                                          • Aggregate node
                                                                                                                                                                                                                                                                                                                                                                            • Merge node
                                                                                                                                                                                                                                                                                                                                                                              • Append node
                                                                                                                                                                                                                                                                                                                                                                                • Streaming Time Series node
                                                                                                                                                                                                                                                                                                                                                                                  • SMOTE node
                                                                                                                                                                                                                                                                                                                                                                                    • RFM Aggregate node
                                                                                                                                                                                                                                                                                                                                                                                      • Space-Time-Boxes node
                                                                                                                                                                                                                                                                                                                                                                                        • Extension Transform node
                                                                                                                                                                                                                                                                                                                                                                                        • Field Operations
                                                                                                                                                                                                                                                                                                                                                                                          • Auto Data Prep node
                                                                                                                                                                                                                                                                                                                                                                                            • Type node
                                                                                                                                                                                                                                                                                                                                                                                              • Filter node
                                                                                                                                                                                                                                                                                                                                                                                                • Derive node
                                                                                                                                                                                                                                                                                                                                                                                                  • Filler node
                                                                                                                                                                                                                                                                                                                                                                                                    • Reclassify node
                                                                                                                                                                                                                                                                                                                                                                                                      • Binning node
                                                                                                                                                                                                                                                                                                                                                                                                        • RFM Analysis node
                                                                                                                                                                                                                                                                                                                                                                                                          • Ensemble node
                                                                                                                                                                                                                                                                                                                                                                                                            • Partition node
                                                                                                                                                                                                                                                                                                                                                                                                              • Set to Flag node
                                                                                                                                                                                                                                                                                                                                                                                                                • Restructure node
                                                                                                                                                                                                                                                                                                                                                                                                                  • Transpose node
                                                                                                                                                                                                                                                                                                                                                                                                                    • Field Reorder node
                                                                                                                                                                                                                                                                                                                                                                                                                      • History node
                                                                                                                                                                                                                                                                                                                                                                                                                        • Time Intervals node
                                                                                                                                                                                                                                                                                                                                                                                                                          • Anonymize node
                                                                                                                                                                                                                                                                                                                                                                                                                            • Reproject node
                                                                                                                                                                                                                                                                                                                                                                                                                            • Graphs
                                                                                                                                                                                                                                                                                                                                                                                                                              • Charts node
                                                                                                                                                                                                                                                                                                                                                                                                                                • Plot node
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Multiplot node
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Time Plot node
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Distribution node
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Histogram node
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Collection node
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Web node
                                                                                                                                                                                                                                                                                                                                                                                                                                              • Evaluation node
                                                                                                                                                                                                                                                                                                                                                                                                                                              • Modeling
                                                                                                                                                                                                                                                                                                                                                                                                                                                • Auto Classifier node
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Auto Numeric node
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Auto Cluster node
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TCM node
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Bayes Net node
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • C5.0 node
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • C&R Tree node
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • CHAID node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • QUEST node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Tree-AS node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Random Trees node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Random Forest node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Decision List node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Time Series node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • GenLin node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • GLMM node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • GLE node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Linear node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Linear-AS node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Regression node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • LSVM node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Logistic node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Neural Net node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • KNN node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Cox node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • PCA/Factor node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • SVM node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Feature Selection node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Discriminant node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • SLRM node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Spatio-Temporal Prediction (STP) node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Spatio-Temporal Prediction (STP) model nugget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Association Rules node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Apriori node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • CARMA node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sequence node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Kohonen node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Anomaly node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • K-Means node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • TwoStep cluster node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • TwoStep-AS cluster node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Isotonic-AS node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Extension Model node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • XGBoost-AS node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • K-Means-AS node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • XGBoost Tree node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • XGBoost Linear node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Gaussian Mixture node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • KDE node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • One-Class SVM node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Outputs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Table node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Matrix node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Analysis node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Data Audit node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Transform node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Statistics node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Means node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Report node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Set Globals node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Extension Output node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Export
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Data Asset export node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Working with your data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • SQL optimization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Migrating import and export nodes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Neural network modeler
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Python client
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Deep learning experiments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Training runs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Training definition
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Example
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Coding guidelines
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 3rd-party libraries
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Running deep learning experiments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Deep learning experiment builder
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Using GPUs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Hyperparameter optimization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Distributed training
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Distributed deep learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Tutorial
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Importing models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • PMML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Spark MLlib
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • scikit-learn
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TensorFlow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Keras
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Deploying
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Deployment endpoint URL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Deploying functions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Implementation details
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Model management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Continuous learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Decision Optimization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Getting started
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • About Decision Optimization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Ways to use Decision Optimization for Watson Studio
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Examples and samples
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Decision Optimization notebooks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decision Optimization model builder
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • User interface and scenarios
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Visualization view
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Modeling Assistant models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Selecting a Decision domain in the Modeling Assistant
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Formulating and running a model: house construction scheduling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Python DOcplex models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Input output data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Solving and analyzing a model: the diet problem
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Create new scenario
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Working with multiple scenarios
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Generating multiple scenarios
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • OPL models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Run parameters
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Deploying with Watson Machine Learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Deployment steps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Creating a Watson Machine Learning service instance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Watson Machine Learning Authentication
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Model deployment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Model execution
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Model input and output data file formats
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Model input and output data adaptation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Output data definition
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Solve parameters
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • REST API example
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Python client example
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Migrating from DOcplexcloud
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Catalogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Administering a catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Creating a catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Managing access to a catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Catalog collaborator permissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Changing catalog settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Deleting a catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Catalog assets
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Finding and viewing an asset in a catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Adding assets to a catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Adding a file
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Adding a connection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Discovering data assets from a connection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Adding data from a connection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Adding a folder asset from a connection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Publishing an asset from a project
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Integrating with Information Governance Catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Automatically synchronizing assets with Information Governance Catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Importing assets from Information Governance Catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Fixing import problems
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Downloading data assets
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Editing asset properties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Controlling access to an asset
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Profiling an asset
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Removing an asset
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Governance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Example scenarios for data protection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Restricting access to assets
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Restricting access with policies
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Authorizing some users only
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Hiding data values in asset columns from others
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Categories
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Policies
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Policy evaluation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Finding and viewing a policy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Creating a policy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Managing policies
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Data protection rules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creating data protection rules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Masking considerations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Masking data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • System terms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Examples of term input
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Viewing or editing rules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Policy usage statistics
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Business terms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Finding and viewing business terms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creating a business term
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Managing business terms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Importing business terms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Data classification
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Classifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Data classes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Data class groups
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Troubleshooting
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • One instance limit for Watson Knowledge Catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Policies
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Streams flows
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Data Refinery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Deep Learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Machine Learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • IBM Cloud Status
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Administration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Managing your Watson apps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Monitoring your resources
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Managing environment runtimes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Managing authorized users for Watson Studio
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configuring Cloud Object Storage for project and catalog creation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Managing your Watson Knowledge Catalog app
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Upgrading your Watson apps or Cloud service plans
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Stop using Watson apps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Managing your settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Determining your roles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Managing your IBM Cloud account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Activity Tracker events
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Assigning the IAM Editor role
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Setting up Watson Studio Enterprise
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Adding an Amazon EMR service
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Adding and managing IBM Cloud services
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Overview
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • What's new
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • IBM Watson Studio
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • IBM Watson Knowledge Catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Offering plans
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Feature matrix
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • About assets
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lineage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Profiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Previews
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Known issues
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • FAQs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • IBM Watson APIs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Security
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Keeping your data secure and compliant
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Notices
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Accessibility
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Getting started
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Videos
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Signing up
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Setting up additional account users
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Choosing a tool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Roles for Watson apps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Projects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Creating a project
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Object storage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Importing a project
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Administering projects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Managing collaborators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Project collaborator roles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Adding associated services
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Exporting projects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Managing assets in projects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Environments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Default environments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Spark environments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Data Refinery environments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • RStudio environments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Creating environments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Customizing environments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Changing environments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Stopping active runtimes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Runtime usage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Jobs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Adding catalog assets to a project
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Leaving a project
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Markdown cheatsheet
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Preparing data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Adding data to a project
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Adding very large files to a project
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Adding connections to projects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Connection types
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Controlling access to COS buckets
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Adding data from a connection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Adding a folder asset from a connection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Downloading data assets
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Refining data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Adding data to Data Refinery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Specifying the format of your data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Validating your data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Visualizing your data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Managing Data Refinery flows
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Copying data from source to target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • GUI operations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • dplyr R library support
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Updates for Data Refinery July 12
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Tutorial: Shape raw data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Data annotation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Annotating data with Figure Eight
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Annotating data with DefinedCrowd
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Ingesting streaming data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get started with streams flows
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Connections in a streams flow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Creating a connection in a streams flow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Creating a streams flow by using a wizard
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Creating a streams flow manually
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Installing Python libraries
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Python model operator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • MQTT (Source and Target) operator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • HTTP operator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • JSON path
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Data types
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Aggregation operator examples
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Buckets, file paths, and partitions in Cloud Object Storage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Code operator examples
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Cloud Function operator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Filter operator examples
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • SPSS model operator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Event Streams (Source) operator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Streams (Source and Target) operators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Kafka (Source and Target) operators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Importing a streams flow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Editing a streams flow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Running a streams flow and monitoring its metrics
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Downloading the user log
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Downloading streams flow code
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Congestion
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Running example streams flow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Data Historian example streams flow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Clickstream example streams flow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Tutorials for streams flows
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Tutorial for Data Historian
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Tutorial for designing and creating a streams flow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Tutorial for using a predictive model with streaming data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Tutorial for metrics
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Data science
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Notebooks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Creating notebooks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parts of a notebook
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The Jupyter and notebook environment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Libraries and scripts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Installing custom libraries
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Deep learning libraries for notebooks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Importing scripts into a notebook
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Coding and running notebooks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Loading and accessing data in a notebook
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Manually adding the project token
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Using project-lib for Python
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Using Python functions to work with Cloud Object Storage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Using project-lib for R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Scheduling a notebook
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • SPSS predictive analytics algorithms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Data preparation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Classification and regression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Clustering
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Forecasting
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Survival analysis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Score
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Visualizations in notebooks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Brunel visualizations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • SPSS model visualizations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Linear regression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Logistic regression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Random trees
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Predictor importance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Sharing and publishing notebooks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Sharing notebooks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Hiding code in a notebook
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Publishing notebooks on GitHub
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Publishing notebooks as a gist
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • RStudio
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Analytics Dashboards
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Machine learning & AI models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Visual Recognition Models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Image classification with Core ML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Setting up
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Custom image classification models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Preparing images
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Training
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Testing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Retraining
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Moving to a new service instance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Custom object detection models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Preparing images for object detection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Training object detection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Testing object detection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Built-in models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Developing apps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sample images
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Natural Language Classification
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Building a classifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Preparing training data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Training
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Testing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Retraining
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Notebooks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Developing apps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Machine Learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Supported frameworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Getting started
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Terminology
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Custom components
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • scikit-learn
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • TensorFlow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Machine Learning plans and runtime usage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Setting up
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Command line interface
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Cloud object storage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Authentication
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Service credentials
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Examples
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • AutoAI tutorial
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Machine Learning tutorials
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Neural network modeler
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Experiment builder
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Experiment builder (HPO)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Python client (notebook)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • CLI
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • CLI (HPO)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Deep Learning sample apps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deployed function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Node.js
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Python Flask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Core ML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Building models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • AutoAI
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Building an AutoAI model from sample data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Building an AutoAI model
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Selecting an AutoAI model
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deploying an AutoAI model
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • AutoAI implementation details
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Synthesized Neural Networks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Building Synthesized Neural Network models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Text training data format
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Image training data format
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deploying Synthesized Neural Network models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Testing deployments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Using deployments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Deployment payload format
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Downloading NeuNetS models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Spark MLlib modeler
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • SPSS Modeler
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Nodes palette
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Import
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Data Asset node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • User Input node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sim Gen node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Record Operations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Select node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sample node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sort node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Balance node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Distinct node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Aggregate node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Merge node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Append node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Streaming Time Series node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • SMOTE node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • RFM Aggregate node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Space-Time-Boxes node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Extension Transform node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Field Operations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Auto Data Prep node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Type node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Filter node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Derive node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Filler node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Reclassify node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Binning node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • RFM Analysis node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ensemble node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Partition node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Set to Flag node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Restructure node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Transpose node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Field Reorder node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • History node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Time Intervals node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Anonymize node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Reproject node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Graphs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Charts node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plot node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Multiplot node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Time Plot node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Distribution node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Histogram node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Collection node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Web node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Evaluation node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Modeling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Auto Classifier node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Auto Numeric node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Auto Cluster node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TCM node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Bayes Net node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • C5.0 node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • C&R Tree node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • CHAID node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • QUEST node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tree-AS node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Random Trees node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Random Forest node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decision List node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Time Series node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • GenLin node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • GLMM node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • GLE node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Linear node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Linear-AS node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Regression node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • LSVM node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Logistic node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Neural Net node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • KNN node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cox node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • PCA/Factor node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • SVM node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Feature Selection node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Discriminant node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • SLRM node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Spatio-Temporal Prediction (STP) node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Spatio-Temporal Prediction (STP) model nugget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Association Rules node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Apriori node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • CARMA node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sequence node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Kohonen node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Anomaly node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • K-Means node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TwoStep cluster node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TwoStep-AS cluster node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Isotonic-AS node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Extension Model node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • XGBoost-AS node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • K-Means-AS node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • XGBoost Tree node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • XGBoost Linear node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Gaussian Mixture node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • KDE node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • One-Class SVM node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Outputs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Table node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Matrix node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Analysis node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Data Audit node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Transform node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Statistics node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Means node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Report node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Set Globals node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Extension Output node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Export
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Data Asset export node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Working with your data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • SQL optimization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Migrating import and export nodes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Neural network modeler
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Python client
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Deep learning experiments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Training runs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Training definition
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Example
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Coding guidelines
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 3rd-party libraries
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Running deep learning experiments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deep learning experiment builder
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Using GPUs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Hyperparameter optimization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Distributed training
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Distributed deep learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Tutorial
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Importing models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • PMML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Spark MLlib
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • scikit-learn
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • TensorFlow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Keras
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Deploying
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Deployment endpoint URL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Deploying functions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Implementation details
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Model management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Continuous learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Decision Optimization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Getting started
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • About Decision Optimization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Ways to use Decision Optimization for Watson Studio
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Examples and samples
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Decision Optimization notebooks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Decision Optimization model builder
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • User interface and scenarios
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Visualization view
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Modeling Assistant models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Selecting a Decision domain in the Modeling Assistant
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Formulating and running a model: house construction scheduling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Python DOcplex models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Input output data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Solving and analyzing a model: the diet problem
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Create new scenario
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Working with multiple scenarios
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Generating multiple scenarios
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • OPL models
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Run parameters
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deploying with Watson Machine Learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Deployment steps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creating a Watson Machine Learning service instance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Watson Machine Learning Authentication
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Model deployment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Model execution
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Model input and output data file formats
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Model input and output data adaptation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Output data definition
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Solve parameters
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • REST API example
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Python client example
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Migrating from DOcplexcloud
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Catalogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Administering a catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Creating a catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Managing access to a catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Catalog collaborator permissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Changing catalog settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deleting a catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Catalog assets
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Finding and viewing an asset in a catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Adding assets to a catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Adding a file
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Adding a connection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Discovering data assets from a connection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Adding data from a connection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Adding a folder asset from a connection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Publishing an asset from a project
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Integrating with Information Governance Catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Automatically synchronizing assets with Information Governance Catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Importing assets from Information Governance Catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Fixing import problems
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Downloading data assets
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Editing asset properties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Controlling access to an asset
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Profiling an asset
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Removing an asset
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Governance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Example scenarios for data protection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Restricting access to assets
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Restricting access with policies
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Authorizing some users only
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Hiding data values in asset columns from others
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Categories
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Policies
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Policy evaluation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Finding and viewing a policy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Creating a policy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Managing policies
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Data protection rules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creating data protection rules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Masking considerations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Masking data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • System terms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Examples of term input
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Viewing or editing rules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Policy usage statistics
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Business terms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Finding and viewing business terms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Creating a business term
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Managing business terms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Importing business terms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Data classification
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Classifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Data classes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Data class groups
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Troubleshooting
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • One instance limit for Watson Knowledge Catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Policies
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Streams flows
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Data Refinery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Deep Learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Machine Learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • IBM Cloud Status
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Administration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Managing your Watson apps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Monitoring your resources
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Managing environment runtimes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Managing authorized users for Watson Studio
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Configuring Cloud Object Storage for project and catalog creation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Managing your Watson Knowledge Catalog app
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Upgrading your Watson apps or Cloud service plans
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Stop using Watson apps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Managing your settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Determining your roles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Managing your IBM Cloud account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Activity Tracker events
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Assigning the IAM Editor role
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Setting up Watson Studio Enterprise
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Adding an Amazon EMR service
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Adding and managing IBM Cloud services
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Troubleshoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Troubleshoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • One instance limit for Watson Knowledge Catalog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Troubleshooting policies
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Troubleshoot Streams Designer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Troubleshoot Data Refinery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Troubleshoot Deep Learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Troubleshoot Machine Learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • View IBM Cloud service status
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Contact
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Privacy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Terms of Use