Convertir des ontologies conformes aux standards du secteur en langage DTDL pour Azure Digital Twins

Article
07/24/2024

La plupart des ontologies sont basées sur des standards du web sémantique tels que OWL, RDF et RDFS.

Pour utiliser un modèle avec Azure Digital Twins, il doit être au format DTDL. Cet article fournit des conseils d’aide généraux relatifs à la conception sous la forme d’un modèle de conversion. Celui-ci permet de convertir des modèles RDF au format DTDL pour qu’ils puissent être utilisés avec Azure Digital Twins.

L’article contient également un exemple de code de convertisseur pour les convertisseurs RDF et OWL, qui peut être étendu à d’autres schémas du secteur du bâtiment.

Bien que les exemples de cet article soient axés sur la construction, vous pouvez également appliquer des processus similaires aux ontologies standard dans différentes industries pour les convertir en DTDL.

Modèle de conversion

Il existe plusieurs bibliothèques tierces qui peuvent être utilisées lors de la conversion de modèles RDF en DTDL. Certaines de ces bibliothèques vous permettent de charger votre fichier de modèle dans un graphique. Vous pouvez parcourir le graphique en recherchant des constructions RDFS et OWL spécifiques, et les convertir en DTDL.

Le tableau suivant est un exemple de la façon dont les constructions RDFS et OWL peuvent être mappées à DTDL.

Concept RDFS/OWL	Construction RDFS/OWL	Concept DTDL	Construction DTDL
Classes	`owl:Class` Suffixe IRI `rdfs:label` `rdfs:comment`	Interface	`@type:Interface` `@id` `displayName` `comment`
Sous-classes	`owl:Class` Suffixe IRI `rdfs:label` `rdfs:comment` `rdfs:subClassOf`	Interface	`@type:Interface` `@id` `displayName` `comment` `extends`
Propriétés DataType	`owl:DatatypeProperty` `rdfs:label` ou `INode` `rdfs:label` `rdfs:range`	Propriétés de l’interface	`@type:Property` `name` `displayName` `schema`
Object Properties (Propriétés de l’objet)	`owl:ObjectProperty` `rdfs:label` ou `INode` `rdfs:range` `rdfs:comment` `rdfs:label`	Relationship	`type:Relationship` `name` `target` (ou omis si aucune `rdfs:range`) `comment` `displayName`

L’extrait de code C# suivant montre comment un fichier de modèle RDF est chargé dans un graphique et converti en DTDL à l’aide de la bibliothèque dotNetRDF.

using VDS.RDF.Ontology;
using VDS.RDF.Parsing;
using System;
using System.Collections.Generic;
using Newtonsoft.Json;

namespace DigitalTwins_Samples
{
    public class DigitalTwinsConvertRDFSample
    {

        public void Run()
        {

            Console.WriteLine("Reading file...");

            FileLoader.Load(_ontologyGraph, rdfFile.FullName);

            // Start looping through for each owl:Class
            foreach (OntologyClass owlClass in _ontologyGraph.OwlClasses)
            {

                // Generate a DTMI for the owl:Class
                string Id = GenerateDTMI(owlClass);

                if (!String.IsNullOrEmpty(Id))
                {

                    Console.WriteLine($"{owlClass.ToString()} -> {Id}");

                    // Create Interface
                    var dtdlInterface = new DtdlInterface
                    {
                        Id = Id,
                        Type = "Interface",
                        DisplayName = GetInterfaceDisplayName(owlClass),
                        Comment = GetInterfaceComment(owlClass),
                        Contents = new List<DtdlContents>(),
                    };

                    // An OWL graph can have parent/child classes.
                    // So to understand if an OWL class is a base class or a child class,
                    // look for a superclass on any given OWL class.
                    // If found, convert these to parent + child Interfaces using DTDL extends.
                    IEnumerable<OntologyClass> foundSuperClasses = owlClass.DirectSuperClasses;

                    //...
                }

                // Add interface to the list of interfaces
                _interfaceList.Add(dtdlInterface);
            }

            // Serialize to JSON
            var json = JsonConvert.SerializeObject(_interfaceList);

        }
    }
}

Exemples de convertisseurs

Cette section contient un exemple de code de convertisseur pour les convertisseurs RDF et OWL. Il est possible d’étendre cet exemple de code à d’autres schémas du secteur du bâtiment.

Application de conversion RDF

Vous trouverez un exemple d’application qui permet de convertir un fichier de modèle basé sur RDF au format DTDL version 2 (v2). DTDL v2 est pris en charge par Azure Digital Twins, mais vous pouvez également suivre ces instructions pour convertir des modèles DTDL v2 au format DTDL v3 plus récent.

L’exemple d’application a été validé pour le schéma Brick et peut être étendu à d’autres schémas du secteur du bâtiment, notamment Building Topology Ontology (BOT), Semantic Sensor Network ou Industry Foundation Classes (IFC) de buildingSmart.

L’exemple est une application en ligne de commande .NET Core appelée RdfToDtdlConverter.

Pour télécharger le code sur votre ordinateur, sélectionnez le bouton Parcourir le code sous le titre sur la page de l’exemple, qui vous permet d’accéder au référentiel GitHub de l’exemple. Sélectionnez le bouton Code et Télécharger le fichier ZIP pour télécharger l’exemple sous la forme d’un fichier .zip appelé RdfToDtdlConverter-main.zip. Vous pouvez ensuite décompresser le fichier et explorer le code.

Vous pouvez utiliser cet exemple pour voir les modèles de conversion en contexte et comme bloc de construction pour vos propres applications effectuant des conversions de modèle en fonction de vos besoins spécifiques.

Convertisseur OWL2DTDL

Le convertisseur OWL2DTDL est un exemple de base de code qui traduit une ontologie OWL en un ensemble de déclarations d’interface DTDL que vous pouvez utiliser avec le service Azure Digital Twins. Il fonctionne également pour les réseaux d’ontologies, constitués d’une ontologie racine réutilisant d’autres ontologies via des déclarations owl:imports. Ce convertisseur a été utilisé pour traduire l’ontologie RealEstateCore en DTDL, et peut être utilisé pour n’importe quelle ontologie basée sur OWL.

Cet exemple de code n’est pas une solution complète prenant en charge l’intégralité de la spécification OWL, mais il peut vous donner des idées et un point de départ que vous pouvez utiliser pour développer vos propres pipelines d’ingestion d’ontologie.

Étapes suivantes

Passez au développement de modèles basés sur des ontologies : Chemin de développement de modèle complet.

Partager via