+
+ |
+ 1 cup of sugar |
+ 2 cups of sugar |
+ 3 cups of sugar |
+
+
+ | 3 cups of flour |
+ 1 cup of sugar & 3 cups of flour |
+ 1 cup of sugar & 4 cups of flour |
+ 1 cup of sugar & 5 cups of flour |
+
+
+ | 4 cups of flour |
+ 2 cups of sugar & 3 cups of flour |
+ 2 cups of sugar & 4 cups of flour |
+ 2 cups of sugar & 5 cups of flour |
+
+
+ | 5 cups of flour |
+ 3 cups of sugar & 3 cups of flour |
+ 3 cups of sugar & 4 cups of flour |
+ 3 cups of sugar & 5 cups of flour |
+
+
+
+ Notice how this looks like a grid. You are _searching_ this _grid_ for the best combination of sugar and flour. _The only way for you to get the best-tasting cookies is to bake cookies with all of these combinations, taste test each batch, and decide which batch is best._ If you skipped some of the combinations, then it’s possible you’ll miss the best-tasting cookies.
+
+ Now, what happens when you’re in the real world and you have more than two ingredients? For example, you also have to decide how many eggs to include. Well, your “grid” now becomes a 3-dimensional grid. If you decide between 2 eggs and 3 eggs, then you need to try all nine combinations of sugar and flour for 2 eggs, and you need to try all nine combinations of sugar and flour for 3 eggs.
+
+ The more ingredients you include, the more combinations you'll have. Also, the more values of ingredients (e.g. 3 cups, 4 cups, 5 cups) you include, the more combinations you have to choose.
+
+ **Applied to Machine Learning:** When you build models, you have lots of choices to make. Some of these choices are called hyperparameters. For example, if you build a random forest, you need to choose things like:
+
+ - How many decision trees do you want to include in your random forest?
+ - How deep can each individual decision tree grow?
+ - At least how many samples must be in the final “node” of each decision tree?
+
+ The way we test this is just like how you taste-tested all of those different batches of cookies:
+
+ 1. You pick which hyperparameters you want to search over (all three are listed above).
+ 2. You pick what values of each hyperparameter you want to search.
+ 3. You then fit a model separately for each combination of hyperparameter values.
+ 4. Now it’s time to taste test: you measure each model’s performance (using some metric like accuracy or root mean squared error).
+ 5. You pick the set of hyperparameters that had the best-performing model. (Just like your recipe would be the one that gave you the best-tasting cookies.)
+
+ Just like with ingredients, the number of hyperparameters and number of levels you search are important.
+
+ - Trying 2 hyperparameters (ingredients) of 3 levels apiece → 3 * 3 = 9 combinations of models (cookies) to test.
+ - Trying 2 hyperparameters (ingredients) of 3 levels apiece and a third hyperparameter with two levels (when we added the eggs) → 3 * 3 * 2 = 18 combinations of models (cookies) to test.
+
+ The formula for that is: you take the number of levels of each hyperparameter you want to test and multiply it. So, if you try 5 hyperparameters, each with 4 different levels, then you’re building 4 * 4 * 4 * 4 * 4 = 4^5 = 1,024 models.
+
+ Building models can be time-consuming, so if you try too many hyperparameters and too many levels of each hyperparameter, you might get a really high-performing model but it might take a really, really, really long time to get.
+
+ DataRobot automatically GridSearches for the best hyperparameters for its models. It is not an exhaustive search where it searches every possible combination of hyperparameters. That’s because this would take a very, very long time and might be impossible.
+
+ **In one line, but technical:** GridSearch is a commonly-used technique in machine learning that is used to find the best set of hyperparameters for a model.
+
+ **Bonus note:** You might also hear RandomizedSearch, which is an alternative to GridSearch. Rather than setting up a grid to check, you might specify a range of each hyperparameter (e.g. somewhere between 1 and 3 cups of sugar, somewhere between 3 and 5 cups of flour) and a computer will randomly generate, say, 5 combinations of sugar/flour. It might be like:
+
+ - Batch A: 1.2 cups of sugar & 3.5 cups of flour.
+ - Batch B: 1.7 cups of sugar & 3.1 cups of flour.
+ - Batch C: 2.4 cups of sugar & 4.1 cups of flour.
+ - Batch D: 2.9 cups of sugar & 3.9 cups of flour.
+ - Batch E: 2.6 cups of sugar & 4.8 cups of flour.
+
+??? ELI5 ""Keras vs. TensorFlow""
+ In DataRobot, “TensorFlow"" really means “TensorFlow 0.7” and “Keras” really means “TensorFlow 1.x"".
+
+ In the past, TensorFlow had many interfaces, most of which were lower level than Keras, and Keras supported multiple backends (e.g., Theano and TensorFlow). However, TensorFlow consolidated these interfaces and Keras now only supports running code with TensorFlow, so as of Tensorflow 2.x, Keras and TensorFlow are effectively one and the same.
+
+ Because of this history, upgrading from an older TensorFlow to a new TensorFlow is easier to understand than switching from TensorFlow to Keras.
+
+ **Example:**
+
+ Keras vs. Tensorflow is like an automatic coffee machine vs. grinding and brewing coffee manually.
+
+ There are many ways to make coffee, meaning TensorFlow is not the only technology that can be used by Keras. Keras offers ""buttons"" (interface) that is powered by a specific ""brewing technology"" (TensorFlow, CNTK, Theano or something else, known as the Keras backend).
+
+ Earlier, DataRobot used the lower-level technology, TensorFlow, directly. But just like grinding and brewing coffee manually, this takes a lot more effort and maintenance, and increased the maintenance burden as well, so DataRobot switched to a higher-level technology, like Keras, that provides many nice things under the hood, for example, delivering more advanced blueprints in the product more quickly, which would have taken a lot of effort if manually implemented in TensorFlow.
+
+??? ELI5 ""How does CPU differ from GPU (in term of training ML models)?""
+ Think about CPU (central processing unit) as a 4-lane highway with trucks delivering the computation, and GPUs (graphics processing unit) as a 100-lane highway with little shopping carts. GPUs are great at parallelism, but only for less complex tasks. Deep learning specifically benefits from that since it's mainly batches of matrix multiplication, and these can be parallelized very easily. So, training a neural network in a GPU can be 10x faster than on a CPU. But not all model types get that benefit.
+
+ Here's another one:
+
+ Let’s say there is a very large library, and the goal is to count all of the books. The librarian is knowledgeable about where books are, how they’re organized, how the library works, etc. The librarian is perfectly capable of counting the books on their own and they’ll probably be very good and organized about it.
+
+ But what if there is a big team of people who could count the books with the librarian—not library experts, just people who can count accurately.
+
+ * If you have 3 people who count books, that speeds up your counting.
+ * If you have 10 people who count books, your counting gets even faster.
+ * If you have 100 people who count books...that’s awesome!
+
+ *A CPU is like a librarian.* Just like you need a librarian running a library, you need a CPU. A CPU can basically do any jobs that you need done. Just like a librarian could count all of the books on their own, a CPU can do math things like building machine learning models.
+
+ *A GPU is like a team of people counting books.* Just like counting books is something that can be done by many people without specific library expertise, a GPU makes it much easier to take a job, split it among many different units, and do math things like building machine learning models.
+
+ For more details on this analogy, see [Robot-to-Robot](rr-gpu-v-cpu).
+
+??? ELI5 ""What is meant by single-tenant and multi-tenant SaaS?""
+ *Single-tenant*: You rent an apartment. When you're not using it, neither is anybody else. You can leave your stuff there without being concerned that others will mess with it.
+
+ *Multi-tenant*: You stay in a hotel room.
+
+ *Multi-tenant:* Imagine a library with many individual, locked rooms, where every reader has a designated room for their personal collection, but the core library collection at the center of the space is shared, allowing everyone to access those resources. For the most part, you have plenty of privacy and control over your personal collection, but there's only one of copy of each book at the center of the building, so it's possible for someone to rent out the entire collection on a particular topic, leaving others to wait their turn.
+
+ *Single-tenant:* Imagine a library network of many individual branches, where each individual library branch carries a complete collection while still providing private rooms. Readers don't need to share the central collection of their branch with others, but the branches are maintained by the central library committee, ensuring that the contents of each library branch is regularly updated for all readers.
+
+ *On-prem:* Some readers don't want to use our library space and instead want to make a copy to use in their own home. These folks make a copy of the library and resources and take them home, and then maintain them on their own schedule with their own personal resources. This gives them even more privacy and control over their content, but they lose the convenience of automated updates, new books, and library management.
+","datarobot_english_documentation/datarobot_docs|en|more-info|eli5.txt"
+"---
+title: Modeling
+description: When a spatial structure is present in the input dataset, Location AI’s modeling enhancements expand traditional automated feature engineering and improve model options.
+---
+
+# Modeling {: #modeling }
+
+When a spatial structure is present in the input dataset, Location AI’s modeling enhancements expand traditional automated feature engineering and improve model options. Location AI accomplishes this using several targeted techniques including:
+
+* Automated feature engineering of location variable geometric properties.
+* Creation of derived features from spatially lagged variables.
+* Feature derivation characterizing spatial hotspots, coldspots, and transitions.
+
+## Automated location feature engineering {: #automated-location-feature-engineering }
+
+Location AI’s ability to ingest, autorecognize, and transform geospatial data unlocks powerful capabilities for DataRobot model blueprints. For example, geometric properties associated with row-level geometries can be powerful predictors in machine learning models. Location AI unlocks this potential in geospatial data by automatically deriving features from the properties of the input geometries. DataRobot derives features for the following geometric properties:
+
+* MultiPoints
+ * Centroid
+
+* Lines/MultiLines
+ * Centroid
+ * Length
+ * Minimum bounding rectangle area
+
+* Polygons/MultiPolygons
+ * Centroid
+ * Perimeter
+ * Area
+ * Minimum bounding rectangle area
+
+As with DataRobot’s [automated derivation](feature-transforms#variable-type-transformations) of date features, automatically derived geometry features are displayed within the **Data** tab as a child feature of the parent ""Location"" type feature.
+
+
+
+## Derived spatial lag features {: #derived-spatial-lag-features }
+
+Spatially lagged features are derived to gain insight into the spatial structure of the data (i.e., spatial autocorrelation) to help inform DataRobot models of spatial dependence patterns. Access the Location AI _Spatial Neighborhood Featurizer_ by searching the Leaderboard for models that include a spatial featurizer. Expand the model and view the blueprint to access the individual tasks.
+
+!!! note
+ In this public preview version, the spatial featurizer is limited in the number of rows and numeric features it can process.
+
+Location AI implements several techniques for automatically deriving spatially lagged features from the input dataset, including:
+
+* _Spatial Lag_: A k-nearest neighbor approach to calculate mean neighborhood values of numeric features at varying spatial lags and neighborhood sizes.
+
+* _Spatial Kernel_: Characterizes spatial dependence structure using a spatial kernel neighborhood technique. This technique characterizes spatial dependence structure for all numeric variables using varying kernel sizes, weighting by distance.
+
+## Derived local autocorrelation features {: #derived-local-autocorrelation-features }
+
+In addition to capturing spatial dependence structure in neighborhood features, Location AI uses local indicators of spatial association to capture hot and cold spots of spatial similarity within the context of the entire input dataset. The Spatial Neighborhood Featurizer calculates neighborhood indicators of association for all non-target numeric variables. The derived features characterize the relative magnitude of local spatial dependence in the input dataset. Features derived in this manner can help present particularly impactful local spatial dependence structures to DataRobot models, improving model accuracy where hot spots and cold spots or abrupt transitions in feature values are present.
+","datarobot_english_documentation/datarobot_docs|en|modeling|special-workflows|location-ai|lai-model.txt"
+"---
+title: Monitoring agent use cases
+description: Investigate MLOPs reporting and monitoring use cases, including how to report metrics when the prediction environment isn't connected to DataRobot and how to monitor Spark environments.
+---
+
+# Monitoring agent use cases {: #monitoring-agent-use-cases }
+
+Reference the use cases below for examples of how to apply the monitoring agent:
+
+* [Enable large-scale monitoring](#enable-large-scale-monitoring)
+* [Perform advanced agent memory tuning for large workloads](#perform-advanced-agent-memory-tuning-for-large-workloads)
+* [Report metrics](#report-metrics)
+* [Monitor a Spark environment](#monitor-a-spark-environment)
+* [Monitor using the MLOps CLI](#monitor-using-the-mlops-cli)
+
+
+## Enable large-scale monitoring {: #enable-large-scale-monitoring }
+
+To support large-scale monitoring, the MLOps library provides a way to calculate statistics from raw data on the client side. Then, instead of reporting raw features and predictions to the DataRobot MLOps service, the client can report anonymized statistics without the feature and prediction data. Reporting prediction data statistics calculated on the client side is the optimal (and highly performant) method compared to reporting raw data, especially at scale (billions of rows of features and predictions). In addition, because client-side aggregation only sends aggregates of feature values, it is suitable for environments where you don't want to disclose the actual feature values.
+
+To enable the large-scale monitoring functionality, you must set one of the feature type settings. These settings provide the dataset's feature types and can be configured programmatically in your code (using setters) or by defining environment variables.
+
+!!! note
+ If you configure these settings programmatically in your code _and_ by defining environment variables, the environment variables take precedence.
+
+=== ""Environment variables""
+
+ The following environment variables are specific to large-scale monitoring:
+
+ | Variable | Description |
+ |----------|--------------|
+ | `MLOPS_FEATURE_TYPES_FILENAME` | The path to the file containing the dataset's feature types in JSON format.