OpenVINO によるナレッジグラフの最適化¶

この Jupyter ノートブックはオンラインで起動でき、ブラウザーのウィンドウで対話型環境を開きます。ローカルにインストールすることもできます。次のオプションのいずれかを選択します。

このノートブックの目的は、インテル® ディストリビューションの OpenVINO™ ツールキットを使用して、ConvE ナレッジグラフ埋め込みモデルのパフォーマンス最適化を紹介することです。最適化プロセスには次の手順が含まれます。

トレーニングしたモデルを OpenVINO の最適化と推論に適した形式でエクスポートします。
最適化された OpenVINO モデルで得られた推論パフォーマンスの高速化をレポートします。

ConvE モデルは、論文 “畳み込み 2D 知識グラフ埋め込み” (https://arxiv.org/abs/1707.01476) の実装です。サンプル・データセットは以下からダウンロードできます。
https://github.com/TimDettmers/ConvE/tree/master/countries/countries_S1

%pip install -q "openvino>=2023.1.0"

                                    DEPRECATION: pytorch-lightning 1.6.5 has a non-standard dependency specifier torch>=1.8.*. pip 24.1 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of pytorch-lightning or contact the author to suggest that they release a version with a conforming dependency specifiers. Discussion can be found at https://github.com/pypa/pip/issues/12063

                                

                                    Note: you may need to restart the kernel to use updated packages.

                                

Windows* 固有の設定¶

                                        # On Windows, add the directory that contains cl.exe to the PATH
# to enable PyTorch to find the required C++ tools.
# This code assumes that Visual Studio 2019 is installed in the default directory.
# If you have a different C++ compiler, please add the correct path
# to os.environ["PATH"] directly.
# Note that the C++ Redistributable is not enough to run this notebook.

# Adding the path to os.environ["LIB"] is not always required
# - it depends on the system's configuration

import sys

if sys.platform == "win32":
    import distutils.command.build_ext
    import os
    from pathlib import Path

    VS_INSTALL_DIR = r"C:/Program Files (x86)/Microsoft Visual Studio"
    cl_paths = sorted(list(Path(VS_INSTALL_DIR).glob("**/Hostx86/x64/cl.exe")))
    if len(cl_paths) == 0:
        raise ValueError(
            "Cannot find Visual Studio. This notebook requires a C++ compiler. If you installed "
            "a C++ compiler, please add the directory that contains"
            "cl.exe to `os.environ['PATH']`."
        )
    else:
        # If multiple versions of MSVC are installed, get the most recent version
        cl_path = cl_paths[-1]
        vs_dir = str(cl_path.parent)
        os.environ["PATH"] += f"{os.pathsep}{vs_dir}"
        # Code for finding the library dirs from
        # https://stackoverflow.com/questions/47423246/get-pythons-lib-path
        d = distutils.core.Distribution()
        b = distutils.command.build_ext.build_ext(d)
        b.finalize_options()
        os.environ["LIB"] = os.pathsep.join(b.library_dirs)
        print(f"Added {vs_dir} to PATH")

                                    

実行を成功させるのに必要なパッケージをインポート¶

                                        import json
from pathlib import Path
import sys
import time

import numpy as np
import torch
from sklearn.metrics import accuracy_score
from torch.nn import functional as F, Parameter
from torch.nn.init import xavier_normal_

import openvino as ov

# Fetch `notebook_utils` module
import urllib.request
urllib.request.urlretrieve(
    url='https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/main/notebooks/utils/notebook_utils.py',
    filename='notebook_utils.py'
);
from notebook_utils import download_file

                                    

設定: シリアル化されたモデルファイルと入力データファイルへのパスを含める¶

                                            # Path to the pretrained model checkpoint
modelpath = Path('models/conve.pt')

# Entity and relation embedding dimensions
EMB_DIM = 300

# Top K vals to consider from the predictions
TOP_K = 2

# Required for OpenVINO conversion
output_dir = Path("models")
base_model_name = "conve"

output_dir.mkdir(exist_ok=True)

# Paths where PyTorch and OpenVINO IR models will be stored
ir_path = Path(output_dir / base_model_name).with_suffix(".xml")

                                        

                                            data_folder = "data"

# Download the file containing the entities and entity IDs
entdatapath = download_file(
    "https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/text/countries_S1/kg_training_entids.txt",
    directory=data_folder
)

# Download the file containing the relations and relation IDs
reldatapath = download_file(
    "https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/text/countries_S1/kg_training_relids.txt",
    directory=data_folder
)

# Download the test data file
testdatapath = download_file(
    "https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/json/countries_S1/e1rel_to_e2_ranking_test.json",
    directory=data_folder
)

                                        

data/kg_training_entids.txt:   0%|          | 0.00/3.79k [00:00<?, ?B/s]

data/kg_training_relids.txt:   0%|          | 0.00/62.0 [00:00<?, ?B/s]

data/e1rel_to_e2_ranking_test.json:   0%|          | 0.00/19.1k [00:00<?, ?B/s]

モデル・チェックポイントをダウンロード¶

                                            model_url = 'https://storage.openvinotoolkit.org/repositories/openvino_notebooks/models/knowledge-graph-embeddings/conve.pt'

download_file(model_url, filename=modelpath.name, directory=modelpath.parent)

models/conve.pt:   0%|          | 0.00/18.8M [00:00<?, ?B/s]

                                            PosixPath('/opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-609/.workspace/scm/ov-notebook/notebooks/219-knowledge-graphs-conve/models/conve.pt')

                                        

ConvE モデルクラスの定義¶

                                            # Model implementation reference: https://github.com/TimDettmers/ConvE
class ConvE(torch.nn.Module):
    def __init__(self, num_entities, num_relations, emb_dim):
        super(ConvE, self).__init__()
        # Embedding tables for entity and relations with num_uniq_ent in y-dim, emb_dim in x-dim
        self.emb_e = torch.nn.Embedding(num_entities, emb_dim, padding_idx=0)
        self.ent_weights_matrix = torch.ones([num_entities, emb_dim], dtype=torch.float64)
        self.emb_rel = torch.nn.Embedding(num_relations, emb_dim, padding_idx=0)
        self.ne = num_entities
        self.nr = num_relations
        self.inp_drop = torch.nn.Dropout(0.2)
        self.hidden_drop = torch.nn.Dropout(0.3)
        self.feature_map_drop = torch.nn.Dropout2d(0.2)
        self.loss = torch.nn.BCELoss()
        self.conv1 = torch.nn.Conv2d(1, 32, (3, 3), 1, 0, bias=True)
        self.bn0 = torch.nn.BatchNorm2d(1)
        self.bn1 = torch.nn.BatchNorm2d(32)
        self.ln0 = torch.nn.LayerNorm(emb_dim)
        self.register_parameter('b', Parameter(torch.zeros(num_entities)))
        self.fc = torch.nn.Linear(16128, emb_dim)

    def init(self):
        """ Initializes the model """
        # Xavier initialization
        xavier_normal_(self.emb_e.weight.data)
        xavier_normal_(self.emb_rel.weight.data)

    def forward(self, e1, rel):
        """ Forward pass on the model.
        :param e1: source entity
        :param rel: relation between the source and target entities
        Returns the model predictions for the target entities
        """
        e1_embedded = self.emb_e(e1).view(-1, 1, 10, 30)
        rel_embedded = self.emb_rel(rel).view(-1, 1, 10, 30)
        stacked_inputs = torch.cat([e1_embedded, rel_embedded], 2)
        stacked_inputs = self.bn0(stacked_inputs)
        x = self.inp_drop(stacked_inputs)
        x = self.conv1(x)
        x = self.bn1(x)
        x = F.relu(x)
        x = self.feature_map_drop(x)
        x = x.view(1, -1)
        x = self.fc(x)
        x = self.hidden_drop(x)
        x = self.ln0(x)
        x = F.relu(x)
        x = torch.mm(x, self.emb_e.weight.transpose(1, 0))
        x = self.hidden_drop(x)
        x += self.b.expand_as(x)
        pred = torch.nn.functional.softmax(x, dim=1)
        return pred

                                        

データローダーの定義¶

                                            class DataLoader():
    def __init__(self):
        super(DataLoader, self).__init__()

        self.ent_path = entdatapath
        self.rel_path = reldatapath
        self.test_file = testdatapath
        self.entity_ids, self.ids2entities = self.load_data(data_path=self.ent_path)
        self.rel_ids, self.ids2rel = self.load_data(data_path=self.rel_path)
        self.test_triples_list = self.convert_triples(data_path=self.test_file)

    def load_data(self, data_path):
        """ Creates a dictionary of data items with corresponding ids """
        item_dict, ids_dict = {}, {}
        fp = open(data_path, "r")
        lines = fp.readlines()
        for line in lines:
            name, id = line.strip().split('\t')
            item_dict[name] = int(id)
            ids_dict[int(id)] = name
        fp.close()
        return item_dict, ids_dict

    def convert_triples(self, data_path):
        """ Creates a triple of source entity, relation and target entities"""
        triples_list = []
        dp = open(data_path, "r")
        lines = dp.readlines()
        for line in lines:
            item_dict = json.loads(line.strip())
            h = item_dict['e1']
            r = item_dict['rel']
            t = item_dict['e2_multi1'].split('\t')
            hrt_list = []
            hrt_list.append(self.entity_ids[h])
            hrt_list.append(self.rel_ids[r])
            t_ents = []
            for t_idx in t:
                t_ents.append(self.entity_ids[t_idx])
            hrt_list.append(t_ents)
            triples_list.append(hrt_list)
        dp.close()
        return triples_list

                                        

トレーニングされた ConvE モデルを評価¶

まず、PyTorch を使用してモデルのパフォーマンスを評価します。目標は、元のモデル推論と OpenVINO 中間表現推論結果に変換されたモデルの間に精度の違いがないことを確認することです。ここでは、テスト・データセットでのモデルのパフォーマンスを評価するため、単純な精度メトリックを使用します。ただし、平均逆順位、Hits@10 などのメトリックを使用するのが一般的です。

                                            data = DataLoader()
num_entities = len(data.entity_ids)
num_relations = len(data.rel_ids)

model = ConvE(num_entities=num_entities, num_relations=num_relations, emb_dim=EMB_DIM)
model.load_state_dict(torch.load(modelpath))
model.eval()

pt_inf_times = []

triples_list = data.test_triples_list
num_test_samples = len(triples_list)
pt_acc = 0.0
for i in range(num_test_samples):
    test_sample = triples_list[i]
    h, r, t = test_sample
    start_time = time.time()
    logits = model.forward(e1=torch.tensor(h), rel=torch.tensor(r))
    end_time = time.time()
    pt_inf_times.append(end_time - start_time)
    score, pred = torch.topk(logits, TOP_K, 1)

    gt = np.array(sorted(t))
    pred = np.array(sorted(pred[0].cpu().detach()))
    pt_acc += accuracy_score(gt, pred)

avg_pt_time = np.mean(pt_inf_times) * 1000
print(f'Average time taken for inference: {avg_pt_time} ms')
print(f'Mean accuracy of the model on the test dataset: {pt_acc/num_test_samples}')

                                        

                                            Average time taken for inference: 0.7827480634053549 ms
Mean accuracy of the model on the test dataset: 0.875

ナレッジグラフ上の予測¶

ここでは、サンプル評価タスクとして、ナレッジグラフ上でエンティティー予測を実行します。ソース・エンティティー san_marino とリレーション locatedIn をナレッジグラフに渡し、ターゲット・エンティティーの予測を取得します。期待される予測は、ナレッジグラフへの入力として渡されるエンティティーと関係を含む事実のトリプルを形成するターゲット・エンティティーです。

                                            entitynames_dict = data.ids2entities

ent = 'san_marino'
rel = 'locatedin'

h_idx = data.entity_ids[ent]
r_idx = data.rel_ids[rel]

logits = model.forward(torch.tensor(h_idx), torch.tensor(r_idx))
score, pred = torch.topk(logits, TOP_K, 1)

for j, id in enumerate(pred[0].cpu().detach().numpy()):
    pred_entity = entitynames_dict[id]
    print(f'Source Entity: {ent}, Relation: {rel}, Target entity prediction: {pred_entity}')

                                        

                                            Source Entity: san_marino, Relation: locatedin, Target entity prediction: southern_europe
Source Entity: san_marino, Relation: locatedin, Target entity prediction: europe

トレーニング済みの PyTorch モデルを OpenVINO 推論用の IR 形式に変換¶

OpenVINO でパフォーマンスを評価するには、トレーニング済みの PyTorch モデルを中間表現 (IR) 形式に変換します。ov.convert_model 関数は、PyTorch モデルを OpenVINO モデル・クラス・インスタンスに変換するのに使用できます。このインスタンスは、デバイスに読み込む準備が整っているか、ov.save_model を使用して OpenVINO 中間表現 (IR) 形式でディスクに保存できます。

                                            print('Converting the trained conve model to IR format')

ov_model = ov.convert_model(model, example_input=(torch.tensor(1), torch.tensor(1)))
ov.save_model(ov_model, ir_path)

                                            Converting the trained conve model to IR format

                                        

OpenVINO でモデルのパフォーマンスを評価¶

OpenVINO フレームワークでモデルのパフォーマンスを評価します。これには、次の 3 つの主要な API 呼び出しを行います。

OpenVINO を初期化する Core()
モデルをロードする read_model()
モデルをコンパイルする compile_model()

次に、create_infer_request() API 呼び出しを使用してモデルを推論できます。

                                            core = ov.Core()
ov_model = core.read_model(model=ir_path)

推論デバイスの選択¶

OpenVINO を使用して推論を実行するためにドロップダウン・リストからデバイスを選択します。

                                        import ipywidgets as widgets

device = widgets.Dropdown(
    options=core.available_devices + ["AUTO"],
    value='CPU',
    description='Device:',
    disabled=False,
)

device

                                    

                                        Dropdown(description='Device:', options=('CPU', 'AUTO'), value='CPU')

                                    

                                        compiled_model = core.compile_model(model=ov_model, device_name=device.value)
input_layer_source = compiled_model.inputs[0]
input_layer_relation = compiled_model.inputs[1]
output_layer = compiled_model.output(0)

ov_acc = 0.0
ov_inf_times = []
for i in range(num_test_samples):
    test_sample = triples_list[i]
    source, relation, target = test_sample
    model_inputs = {input_layer_source: np.int64(source), input_layer_relation: np.int64(relation)}
    start_time = time.time()
    result = compiled_model(model_inputs)[output_layer]
    end_time = time.time()
    ov_inf_times.append(end_time - start_time)
    top_k_idxs = list(np.argpartition(result[0], -TOP_K)[-TOP_K:])

    gt = np.array(sorted(t))
    pred = np.array(sorted(top_k_idxs))
    ov_acc += accuracy_score(gt, pred)

avg_ov_time = np.mean(ov_inf_times) * 1000
print(f'Average time taken for inference: {avg_ov_time} ms')
print(f'Mean accuracy of the model on the test dataset: {ov_acc/num_test_samples}')

                                    

                                        Average time taken for inference: 0.9586711724599203 ms
Mean accuracy of the model on the test dataset: 0.10416666666666667

OpenVINO グラフ最適化によって得られるプラットフォーム固有のスピードアップを決定¶

                                            # prevent division by zero
delimiter = max(avg_ov_time, np.finfo(float).eps)

print(f'Speedup with OpenVINO optimizations: {round(float(avg_pt_time)/float(delimiter),2)} X')

                                            Speedup with OpenVINO optimizations: 0.82 X

                                        

ベンチマーク・アプリを使用して変換された OpenVINO モデルをベンチマーク¶

OpenVINO ツールキットは、特定のモデルに最適な構成パラメーターで得られるプラットフォーム固有のランタイム・パフォーマンスを測定するベンチマーク・アプリケーションを提供します。詳細については以下を参照してください。
https://docs.openvino.ai/2024/learn-openvino/openvino-samples/benchmark-tool.html

ここでは、ベンチマーク・アプリケーションを使用して、ナレッジ・グラフ・モデル推論に最適な構成でのパフォーマンスの推定値を取得します。ベンチマーク・アプリケーションの実行中に観測された平均 (AVG)、最小 (MIN)、最大 (MAX) のレイテンシーとスループット・パフォーマンス (サンプル/秒単位) を取得します。OpenVINO 推論のベンチマーク・アプリによって決定されたプラットフォーム固有の最適な構成パラメーターも、ベンチマーク・アプリの結果を確認することで取得できます。

                                            print('Benchmark OpenVINO model using the benchmark app')
! benchmark_app -m $ir_path -d $device.value -api async -t 10 -shape "input.1[1],input.2[1]"

                                            Benchmark OpenVINO model using the benchmark app

                                        

[Step 1/11] Parsing and validating input arguments
[ INFO ] Parsing input parameters
[Step 2/11] Loading OpenVINO Runtime
[ INFO ] OpenVINO:
[ INFO ] Build ................................. 2023.3.0-13775-ceeafaf64f3-releases/2023/3
[ INFO ]
[ INFO ] Device info:
[ INFO ] CPU
[ INFO ] Build ................................. 2023.3.0-13775-ceeafaf64f3-releases/2023/3
[ INFO ]
[ INFO ]
[Step 3/11] Setting device configuration
[ WARNING ] Performance hint was not explicitly specified in command line. Device(CPU) performance hint will be set to PerformanceMode.THROUGHPUT.
[Step 4/11] Reading model files
[ INFO ] Loading model files
[ INFO ] Read model took 4.18 ms
[ INFO ] Original model I/O parameters:
[ INFO ] Model inputs:
[ INFO ]     e1 (node: e1) : i64 / [...] / []
[ INFO ]     rel (node: rel) : i64 / [...] / []
[ INFO ] Model outputs:
[ INFO ]     *NO_NAME* (node: aten::softmax/Softmax) : f32 / [...] / [1,271]
[Step 5/11] Resizing model to match image sizes and given batch
[ INFO ] Model batch size: 1
[Step 6/11] Configuring input of the model
[ INFO ] Model inputs:
[ INFO ]     e1 (node: e1) : i64 / [...] / []
[ INFO ]     rel (node: rel) : i64 / [...] / []
[ INFO ] Model outputs:
[ INFO ]     *NO_NAME* (node: aten::softmax/Softmax) : f32 / [...] / [1,271]
[Step 7/11] Loading the model to the device

                                            [ INFO ] Compile model took 53.83 ms
[Step 8/11] Querying optimal runtime parameters
[ INFO ] Model:
[ INFO ]   NETWORK_NAME: Model0
[ INFO ]   OPTIMAL_NUMBER_OF_INFER_REQUESTS: 12
[ INFO ]   NUM_STREAMS: 12
[ INFO ]   AFFINITY: Affinity.CORE
[ INFO ]   INFERENCE_NUM_THREADS: 24
[ INFO ]   PERF_COUNT: NO
[ INFO ]   INFERENCE_PRECISION_HINT: <Type: 'float32'>
[ INFO ]   PERFORMANCE_HINT: THROUGHPUT
[ INFO ]   EXECUTION_MODE_HINT: ExecutionMode.PERFORMANCE
[ INFO ]   PERFORMANCE_HINT_NUM_REQUESTS: 0
[ INFO ]   ENABLE_CPU_PINNING: True
[ INFO ]   SCHEDULING_CORE_TYPE: SchedulingCoreType.ANY_CORE
[ INFO ]   ENABLE_HYPER_THREADING: True
[ INFO ]   EXECUTION_DEVICES: ['CPU']
[ INFO ]   CPU_DENORMALS_OPTIMIZATION: False
[ INFO ]   CPU_SPARSE_WEIGHTS_DECOMPRESSION_RATE: 1.0
[Step 9/11] Creating infer requests and preparing input tensors
[ WARNING ] No input files were given for input 'e1'!. This input will be filled with random values!
[ WARNING ] No input files were given for input 'rel'!. This input will be filled with random values!
[ INFO ] Fill input 'e1' with random values
[ INFO ] Fill input 'rel' with random values
[Step 10/11] Measuring performance (Start inference asynchronously, 12 inference requests, limits: 10000 ms duration)
[ INFO ] Benchmarking in inference only mode (inputs filling are not included in measurement loop).
[ INFO ] First inference took 3.90 ms

                                        

                                            [Step 11/11] Dumping statistics report
[ INFO ] Execution Devices:['CPU']
[ INFO ] Count:            104112 iterations
[ INFO ] Duration:         10001.51 ms
[ INFO ] Latency:
[ INFO ]    Median:        0.95 ms
[ INFO ]    Average:       0.97 ms
[ INFO ]    Min:           0.53 ms
[ INFO ]    Max:           8.98 ms
[ INFO ] Throughput:   10409.63 FPS

                                        

まとめ¶

このノートブックでは、トレーニング済みの PyTorch ナレッジグラフ埋め込みモデルを OpenVINO 形式に変換します。変換後の精度に差がないことを確認しています。ナレッジグラフのサンプル評価も行います。次に、OpenVINO グラフの最適化によって得られるプラットフォーム固有の実行時パフォーマンスの高速化方法を決定します。OpenVINO のパフォーマンス最適化の詳細については、以下を参照してください。
https://docs.openvino.ai/2024/openvino-workflow/running-inference/optimize-inference.html