Powerful Data Standardization and Extraction by Autodesk Platform Services

JOSHA VAN REIJ: Hello, all. Welcome at this session. And thank you for joining. I know what you're thinking-- great another PowerPoint presentation, my lucky day. But fear not. We promise to make this presentation as enjoyable as a tax audit. So sit back, relax, prepare to be dazzled by charts and graphs that even a magician would envy.

No, we're joking. I hope you'll enjoy the session. We'll include a lot of live demos. And feel free to reach out if you have any feedback. So this class is about powerful data standardization by using the Autodesk Platform Services APIs.

So first, as an introduction about ourselves. So I'm Josha van Reij. I'm a product owner at Arcadis working in the digital solutions space. And for my free time, I like to do cycling. And yeah, I like to work on my own house. I'm here with my colleague Amy Cai, who is the tech lead for this solution. And she will tell more about herself later in this presentation.

So why data standardization? Well, maybe to share a story with you what happened in 1999. The NASA Mars Climate Orbiter was launched for a mission to study the martian atmosphere and climate. But the spacecraft was expected to enter the orbit around Mars, but it ended in a failure.

And the root cause of this was bad data quality, specifically the unit conversion. There were two companies working on the project, and they both used a different. So one used metric, and the other one used imperial. And there was no proper conversion in place. So this is one of the reasons why this quote, so you can have all the fancy technology you want, but if the data quality is poor well, basically this happens.

So our class today, starting with the agenda. So we start off with why data standardization. Then we go further in what did we develop with a couple of live demos. And we're going to show you how we automated certain tasks of the engineer. And at the end very shortly, what the project benefits are by using these toolings.

What you acquire in this session is how you can leverage standardization within your organization for business value and for your clients. How to use the Autodesk Platform Surfaces APIs yourself to standardize data. Discover how you can integrate certain systems into each other, and how to prepare your organization for the future way of working.

So starting with the first topic for today, why data standardization. So as I mentioned, I work at Arcadis. It's a large organization, which brings a lot of challenges due to its size. Of course, I'm not going to go through this slide in detail. But maybe I can mention something about Arcadis.

And that's that Arcadis comes from the word Arcadia from the Greek methodology. And there it stands for well-being and wellness. And that's also one of the reasons, at least that I believe, that we grow this fast in amount of people.

But having this amount of people also caused us some challenges. So we have a very wide range of products that we use. And everything is either local or cloud-based with our own standardization, with our own file storage, which results in a lot of fragmented data standardization and not having the ability to get cross-project data insights. We have to manually extract the data from the different applications to be able to get analytics and deliver to the client.

And because of the scattered use of different applications, it takes a lot of time to actually process the data. And still, we'll have a low quality data as a result. So that's what we're trying to solve.

And within Arcadis, we have the vision that by driving digital leadership and automation through smart data standardization for a sustainable and high-quality client delivery. So that's the goal that we want to reach and we created some tooling for. But to be able to do that, we have splitted the efficient a little bit down.

So what we want to accomplish is we want to-- well, basically, we want to break up all those different files on different locations into small pieces of data, small bits of data so that when we have all those small pieces of data, we can bring it together in the cloud. And have it centralized so that all the different project collaborators using all their different local or cloud-based engineering applications can use the same data at the same moment, so a central place. So that's the underlying thought we had with this vision for digital leadership.

But then, to accomplish this, we needed to develop something. So that's also the second part of this session, what did we develop? So this video will highlight high over what we developed. And later, we'll go in more detail.

So the Arcadis OTL, that's what we developed. Many might know it as an ontology. You could compare Arcadis ontology like a recipe. So for example, in lasagna, you could compare it to a bridge or a road or on building. We have certain instructions, so the rules. How do certain objects in that building relate to each other? And the ingredients, what are the information requirements needed for that bridge or building?

We collected with a team all this information. And we standardized it on a global level. So in this video, you can see that we have certain asset types with certain decomposition and certain information requirements. And we highlight that in the tool we call the OTL Viewer.

After having this global standardization, we want to make it project specific. That's also where the main part of this class will be about. So with that standardized structure, we created the tool the OTL Optimizer, formerly known as PIMS, to create a project-specific decomposition based on ontology. And you can fill in the information that's required for the different sustainability and cost management needs. So that's fairly high over what we developed.

But this session, we're going to go in more detail in each of these topics. So the first where we go in more detail is the OTL Viewer, which contains the ontology, the asset types, information requirements. The second one we go in more detail is the OTL Optimizer, where we make it project-specific, where we can collaborate with different people around the world, and connect to local applications with local connectors. And the third one is Powered by OTL. We make our ontology available for externals and other internal solutions to leverage or data standardization that we can collaborate between each other.

How that would look like from an OTL business architecture is a bit like this. So you can see on the left side, we have the ontology. That could either be data or geometry. Then we have the OTL Viewer, where in the middle, where we highlight and visualize that ontology. And the OTL Optimizer, where we collect all the data based on the ontology with Revit, Civil 3D, Open Bridge, and Open Road as local connectors to retrieve the information from the geometry. And we synchronize that to our common data platform that we make it available for all the different platforms within and outside Arcadis.

And then going in depth, first about the ontology. So this is another live demo that I'm going to show you. So this is the OTL Viewer, where you can see the global standardized structure for the different asset types that we currently have available.

Inside there, you see the decomposition, so which types object types belong under which object types, so the taxonomies and the decomposition and all the information requirements. And each object type and information requirements have their own unique identifier. So you can relate back to it from different applications. And everything contains its own description.

So this is also how the principle of linked data works as integrated within this tool. But the standardization itself is the first step because you also need to get it to your project. I think you are all might recognize this. So you have a certain engineer within your company, and he or she has a certain information need. So to get the information he or she needs, she sends a mail to one or multiple colleagues in the hope she will get the right information.

And then many times, you get either incorrect data, incomplete data, or duplicate information because it's very fragmented around. So that's what we solved with the OTL Optimizer. So we bring the data to a central point, where all the different roles can collaborate at the same time on the same data.

So in this video, you can see how we create a project in the OTL Optimizer. So also, this is a cloud-based tool just like the OTL Viewer, where any Arcadian can create their own project. And a project is based on a certain main asset type. So in this case, what we're showing is the bridge.

And if wanted, you can already select some starting object types on the right side. By creating the project with this asset type, you're basically retrieving the ontology as its base. And the data standardization will now be the core of this project.

So after the project is created, people can start collaborating. So users can be added to the project and collaborate together. And there are three different use cases, three different workflows that we support with the tooling that maybe you also could leverage. So one is without a 3D model. So that's one is used a lot in early design phases, where there is no 3D model, or projects that don't actually have a 3D requirement, like a renovation project that just wants a sustainability analysis.

The second use case is connecting the 2D model afterwards. So they already have your project decomposition. And you connect the geometry to the instances afterwards. And the third one that Amy will be presenting is starting with an 3D model. So then you generate the project decomposition based on the 3D model.

So this is use case one. So this is without a 3D model. So in this demo, we will show you the project that we just created.

We're clicking on the project. And we see the starting instances. In here, we can add an additional asset type, like in this case, the building. After adding this building, it will retrieve the standardized structure of the building. And you can start looking at its attributes. So here, you'll see the standard attributes that you could fill in for a building.

After that, you can add your instances. And you only see the suggested object types from the ontology structure, so not the entire list of different object types available for building. And the same here-- after creating that instance and those instances, it will be added under the building. So this is basically building up your project-specific decomposition and all the information requirements belonging to the different object types. So each object type has its own information requirements based on the standardized structure of the Arcadis ontology.

Besides attributes, you also have materials with attributes. That's a more complex situation, because based on the selection of the material, it will get additional information requirements. And that accounts for all the different enumerations inside of the material. But all this information is needed to be able to do in detail sustainability analysis.

The project decomposition can be built out by clicking on the plus icon. Now you see an additional deeper level of instances and different suggested brands because the ontology for this object type shows different types of suggested types. So this is how you could build up a project without any geometry but still have the information requirements and all the project data available for all the different use cases within the company.

The second use case is connecting the geometry afterwards. So we're going to go to the same project, where we now have added many additional instances to the project. To be able to connect geometry, we first need to connect it to an file storage. So default is basically a manual upload. And ACC is connected live to a 3D model inside one of your ACC projects that you have access to. Nowadays, we also have ProjectWise, where you can also connect it live.

So here, we select an example project, a 2D model of a building. And connect it to the project. And now, when an update happens of the model in ACC, it will automatically update inside this Optimizer project. But more important, if we navigate to the project, we can actually select the model inside the 3D viewer on the right side. And it shows instantly.

And this is what we need for the second use case. So we want to be able to connect the geometry of this 3D model to the instances that we previously created on the left side. So for example, the stair that you see here we can connect that to the stair instance. And we do that by selecting the stair inside the 3D model, then pressing on the link icon next to the instance. And then you can press the plus icon to make the connection to the instance, as you can see here.

And then it's also interactive. So when you select the instance, it will also highlight it inside the 2D viewer. And more importantly, also for this part, so after connecting the geometry to the instance, the system now knows what is connected to each other. And with the local engineering connectors, you can start extracting data.

So that's what you see here in this demo. It's Revit, one of the local applications where we created a connector for. And we have made a mapping between the attributes of the instance and the parameters of the model. And based on that mapping that you have to create once for the project or for the asset type, you can run an extraction for the selection or for the entire model. And then the data from the 3D model will be pushed to the database of the Optimizer, so basically to the instance.

This makes the extraction of quantities quite efficient because you only have to set it up once, and then you only have to keep pressing Extract All. And it keeps updating the values of the instances. But as you can see, it's local. We have to go to the local application. And there are way more efficient ways of doing this. And that's where my colleague Amy will show you how that has been done in the tooling.

AMY CAI: Thank you, Josha. So I'm Amy. I'm the technical lead for this tooling. And I'm delighted to be here to share our data standardization expertise with you.

So in the previous row, you observed that we could create a project with our 3D model. And then connect the model later, either through Revit Connector or from the application. Now, in this demo, I'd like to show with you that we can initiate a project with a 3D model.

So in this video, you see that on the left side, we have the project decomposition. And on the right side, that's the model. And now, I'm starting with scanning the types from the model. It's basically trying to extract the parameter called ACC OTL object type. Because in this parameter from the model, it's stored OTL type, which is ontology type that represent a certain type relating with this object. And here is another example for it.

Now, once I gather all of this information, I can start creating the ontology instance. And here now on the left side, you see that once I expand, there is this bridge. And it's created with the different instance under it.

Yeah, at this moment, if I go through each instance, you'll see that the object attributes are still empty, as you can see here. Now, before I extract quantity value from the model, I will need to do a calculation mapping, just like what Josha did in the connector. It's basically mapping the attribute with the instance. And mapping how you would extract the quantity value from the model. So for example, volume, I would get the volume information from the geometry as well here.

Now, once the calculation mapping is configured, I go back to the project and selecting the same model. Yeah, so at this moment, you see that the object attributes, they still empty. So now I can start the calculation, which is extracting the quantity value with AEC data model API for a model based on the calculation configuration that we configure. So now, if I select abutment, you see that those area that we configured, they are filling with the quantity value from the model. And here is another example for that.

So yeah, that's how the tooling work, how we extract the quantity information with the model. But you have see how the tooling working. And you may wonder how is everything actually mapping behind the scene.

So as you can see here, I have this sample ontology from the bridge. From Arcadis, we create ontology by different assets like bridge road building. And in this example, it's just a snapshot that showing the more broader view how everything linked with each other.

So here is this suspension bridge. It's a type of bridge. And it's connecting with a certain project. And it has its own document.

And this bridge will have different parts, like deck, foundation beam. And on the deck, each part would have its own parts. For example, deck has a part of pavement. And each part would have their own data information. Like, for example, foundation has sensor movement data, and beam has its geometry, like 3D shape. And each part would have their own material. And each material would have their own quantitative value, like volume.

So based on this ontology type, we create our database architecture. Yeah, so in this database architecture, you see that we're starting from this orange node. That's project. And project would include information, like project name and project code and project version.

And then if we navigate to the left side, you see these two blue nodes. Stands for unique attribute and unique type. So this is basically the data underneath the calculation mapping. It's mapping the relationship between the instance and the attribute, how we extract the quantitative value from the model.

And then when we navigate up, you will see that we have this node related with the project unit system. So user can configure their own unique system, like imperial or metric system, and select the related unit to corresponding attribute. And then when we navigate to the right part of the purple nodes, here it stands for the project storage. And each storage have its own model with it.

Now, I'd like to mention that we now currently supporting the ACC storage, as well as the ProjectWise storage. And when I navigate down you see this yellow nodes here. That's representing the projected composition. So that's the part that you see in previous video about deck and the foundation.

So each project can has many, many instance, ontology instance under it. And each instance would have more parts under it as well. And then each ontology instance, or we call it object here, would have its own activity and the material, as well as attributes.

So based on this overview, I would like to expand the part specifically relating with 3D geometry, how we establish the connection between OTL instance and the geometry. So in previous video that you see that once I gather those information from the model, I create those instance automatically. And when I go through instance, it also relating with a certain object from the geometry. So the connection between instance and the object are established automatically.

How do we do that? So in this data architect, you see I have this project. The project has its own storage. And I have this purple node, which is the model. And the model would link with OTL instance by the geometry object unique ID.

The reason why we're using this ID is because even when the object from the model is updated, this ID stay the same, which means when you update the model, connection will remain the same. And we can update the model information corresponding automatically. So that's how the data mapping behind the scene. So I'll hand back to Josha for the agenda next.

JOSHA VAN REIJ: Thank you, Amy. Yeah, so that's a good overview, I think, of the product itself. So how did we automate certain tasks inside this tooling? So you might have noticed this during the demos and also just now by Amy, her presentation. There are still some steps we need to take, so some challenges that we have.

So one of them is we had to manually create a connection between the geometry and the instance or prepare the 3D model to be recognized, which object types relates to which geometry. And the same for the parameters and the data extraction. We need to make a calculation configuration to be able to extract the data.

Besides that, we're getting requests from clients with their own information requirements, their own ontologies, and their own data requirements. And last but not least, we have a lot of historical projects, thousands of Revit models, Civil 3D that we want to use to get insights but are not compliant to the new ontology. That's why we're at the moment implementing an AI model to recognize these mappings between object types and attributes, both historical as new models to how extract and quantify all this data and optimizer that we then can use for different dashboarding.

How have we implemented this? So we go back to the same project again to show you live how the first version of this object recognition works. So inside the project, we first select the model that we want to apply the AI model on. So that's the same building project.

And then we want to add the building asset again. But instead of pressing Add Asset, we have created a new button at the right top corner where it will recognize, or it will scan the geometry. And it tries to relate basically to the object types from the ontology to see if anything can be recognized.

What turns green has been recognized. So as you can see, it's a high success rate for this asset type. And all the instances are created on the left side. So at the moment that geometry recognizes a certain object type in the viewer. Then it will add the instance to the left side and create a connection. So that's why the connection icon is green.

And of course, also we will retrieve all the information requirements from the OTL. So if you click on any of those instances, you'll see because of the connection it is navigating to it. But this is also showing the information requirements on the right side.

So this is the first implementation of the AI model. But of course, the other two remaining challenges is that what we're now working on with this training.

AMY CAI: So yeah, you have seen that we integrate the first version of this type recognition model in Optimizer. But how is the model being trained? So here is an overview of this training progress that I use.

First is asking the right question to form a guideline or statement that can be used throughout the whole training progress. Secondly is gather the information and prepare the data. And then third progress is select the candidate algorithm based on the question you ask previously. And then fourth progress is training the model. And then come to the last step, which is evaluate the model with the testing data. See if gets close to the target that you set at the beginning.

There is another session we'll dive deeper into this training progress, but here, I would like to highlight the key points in each progress. So asking the right question, what to ask. Yeah, so here are three questions to help you asking the question to form the statement that can be used.

First question is, what's the main target? So in my case, my target was generating a predictive model capable of forecasting data type. And then the second question is asking, what's the scope? So in my case, recognizing OTL or ontology is the scope that I need to apply throughout the whole training progress. And then the third question is about this performance target. What is the performance target you want to aim at? So in my case at the beginning, I set at least 80% of forecasting accuracy.

So with this whole question being answered, we can now form our statement, which is a guideline throughout the whole model training progress, which is utilize the machine learning workflow to progress Arcadis 3D model data generating a predictive model capable of forecasting OTL types within accuracy of at least 80%. Now the statement is there, next step is prepare the data. So how do we prepare the data?

Here are three steps. First step is the data collection. Gather and acquiring the necessary data from various resources. In my case, I gather all this information from ACC and use that data to train the model. But second step is once you collect those data, there can be data that it has missing value or error in the data. So you will have to do the data cleaning. Then we come to the last step, which is data transformation, which is basically encoding the categorical variables and performing other data transformation to make it suitable for this modeling.

Now, once the data is prepared, we come to the third step, which is algorithm selection. I believe there are various opinion about which factors are important when coming into the algorithm selection. And here I have three factors that help me to select my candidate algorithm. The first factor is asking, what is the learning type? Is it a supervised learning type, or is it a unsupervised learning type?

And second factor is asking the result of this model is it a Boolean, like true or false result, or is it a category? So in my case, it was a category result. Then the third factor is checking on the complexity of this algorithm you want to start with. You can start with the basic one. You can also start with enhanced algorithms. So in my case, I start with basic algorithm. With these three factors combined, I narrow down all these algorithms into three candidate algorithm. And I start training the model with it.

Now, once the algorithm is selected, we come to the last part, which is the training model itself. Before training, we need to split the data that we gathered and cleaned into different data subset. So I split it into training data subset and test data set. You can also add another set, which is for validation.

And how do we split the data? It can be 70% training data set, 30% testing set. It can also be 80/20 and 90/10%. So that's based on your own scenario. Once data is split, we can train a model with a candidate algorithm that we selected. And then evaluate the model with the testing data that we split it.

So that's how this whole type recognition model being trained.

JOSHA VAN REIJ: And yeah, to close out this session, we just would like to highlight you some project benefits by using data standardization within your organization. So by using the different use cases, whether it's the manual filling in or a case the optimizer, or by using AI and extracted data automatically, in all cases, we get the data out of the models and out of the systems. And we make it available for client delivery and for different dashboards, so that saves a lot of time at the end of the project.

One of our early adopters, Mark Kroezen, BIM manager within Arcadis Netherlands has given us this feedback, this quote. So "With the Arcadis OTL, data transforms into insights, reshaping our projects with standardization, high quality, and more efficiency."

So this is resulting in some benefits in projects. So if we compare it to our previous way of working and now using this data standardization approach, we noticed that 60% of the project data is more structured. And it makes it possible to have cross projects data insights. It's a lot less data processing time. So we go from many separate solutions to a more one-fits-most application landscape. And also the quality of the data is much higher. And we are able to do automated client delivery in a standardized way.

So we hope after this session that you now have experienced how you could apply yourself data standardization within your company to get higher value for your business and clients. Or how you could use the Autodesk Platform Services APIs to create something similar or something even better, of course. And besides that, we hope also that you can, by this presentation, get some insights in how could you prepare your organization. Because we know there's a lot of companies and clients are moving to ontology structures and data standardization. And we hope this presentation helps you with preparing for that.

With that said, I would like to thank you for joining this session, and have a great day.