What is the cpt model? *

The cpt model is the first developed API that has been widely used by CRUX employees and external clients in the past years. It consists of a fully automated soil classification based on a convolutional neural network, quite a mouthful isn't it? ;)

It may seem a scary name but in this post I will show you that it's very easy to use and probably one of the best alternatives that are available nowadays to automatically interpret a cpt.

Why do we need it?

Soil classification has been for many years a human process. An engineer interprets the results of a Cone Penetration Test and comes up with a certain soil layering of the area.
These interpretations are often always the first step in a geotechnical project and their outcome has a great impact on the rest of the decisions that are made in the project.

The problems arise when you try to ask two different engineers to classify a cpt, they will certainly come up with two different classifications, so how can we say who is right?
Another "problem" arises when "too much" soil investigation is available for a project and the engineers find themselves looking at 200+ files without having a good tool to analyze them and make the best decisions.

Do you recognize yourself in the description above? If so, keep reading, we might have a solution for you!

The solution

A data-driven approach in a country where we have so much open source data available seems to be an efficient and correct way to proceed.

In order to train the model roughly 49.000 Cpts and 40.000 boreholes were checked, from which 1800 pairs met the condition of being less than 6 meters apart. These have been used as labeled data for the first model training. The model is then retrained periodically whenever new data are available that meet the condition of being 6 meters apart.

Several cpt classification methods have been developed in the past, they are widely used and can be found in the literature. Robertson classification is probably the most known.

The problem with these empirical classifications is that they try to fit all geographical areas with one formula and if you have tried them you will often find yourself disagreeing with them. For Robertson it is for example known, that it finds it difficult to detect the dutch peat layers.

In the image below you can see a comparison between the Cpt model (left) and the Robertson classification (right) that misses the dutch peat layer.

Another problem with these classifications is that they provide a classification every two centimeters but they don't offer a way to group these tiny layers into some lithological soil layers.

The cpt model instead groups layers based on the signals of the qc and friction ratio. The model includes a steering or penalty parameter which gives you the freedom of getting many of just a few layers. In the pictures below you can see how by increasing the "penalty" parameter the number of layers decreases. The penalty is initially 0 (you get a layer every 2 cm), then increased to 2 and finally 5.

How can you use it?

Let's see how you could use this very helpful tool. All you need is a little knowledge of Python and an internet connection.

We start with importing the functions from our library nuclei that will help us to make the https request.

from nuclei import call_endpoint, get_endpoints

The function get_endpoints returns the endpoints of a given APP.

APP = 'gef-model'
get_endpoints(APP)

['/classify', '/default-version', '/model-versions', '/nen-table', '/plot']

The next thing to do is define a "schema", a python dictionary that will be the body of the request. We just have to define an aggregate_layers_penalty that is the parameter discussed above and a cpt_content that is the content of a cpt file in the string form. We then call the function call_endpoint specifying the APP, the endpoint'/plot' and the schema. The function returns a beautiful plot!

schema = {
  "aggregate_layers_penalty": 2,
  "cpt_content": content,
}

call_endpoint(APP, '/plot', schema)

Another useful endpoint is the '/classify' endpoint. This endpoint will return a pandas DataFrame with all the digital information that you need. The classification is given in percentages of gravel, sand, silt, clay and peat. We can add an extra key "merge_nen_table" to add additional columns such as the soil type name, the soil code and and the other parameters according to the NEN 9997-1 table 2.b. We can then select "layer_table" from the returned dictionary's keys and select some of the many columns of the pandas dataframe that we want to inspect.

schema = {
    "aggregate_layers_penalty": 5,
    "cpt_content": content,
    "merge_nen_table": True
}

result = call_endpoint(APP, '/classify', schema)
result["layer_table"][["depth_top", "G", "S", "L", "C", "P",
"elevation_with_respect_to_NAP", "nen_row", "soil_code", "grain_pressure"]]

You can either use the NEN description to identify the layer type or create your own description based on the components. We used both methods in several projects and they are both very valid methods!

Unfortunately I can't cover all the functionalities and possibilities that are available in this tool, so if you are curious about it please send an email to aW5mb0BjZW1zYnYubmw= and get in touch with us!

In the next blog post I will cover the applications of the cpt-model, so make sure to follow us on LinkedIn to stay up-do-date!

References:

If you want to know more about how the model is built, take a look at this blog post written by my colleague Ritchie Vink.

*Disclaimer:
This blog relates to the previous CPT Core version, called GEF-model. We've since updated the API, renamed the service, and introduced additional features. Explore the new API advancements for enhanced functionality.