Method to index an intermediate data tensor

Abstract

In an example method for use in a split inferencing architecture, information is obtained at a first endpoint describing at least a first sub-model of a split-inferencing machine learning model. In communication with a second endpoint, a tensor indexing algorithm is selected. The first sub-model is executed to obtain at least one tensor. The tensor is sent to the second endpoint, each tensor being identified by a respective reference determined according to the selected tensor indexing algorithm.

Description

METHOD TO INDEX AN INTERMEDIATE DATA TENSORCROSS REFERENCE

[0001] This application claims the benefit of European Patent Application No. 24306886.3, filed 8 November 2024, the entire disclosure of which is incorporated herein by reference.BACKGROUND

[0002] The present disclosure relates to machine learning (ML) models. New uses for machine learning models are constantly being developed. As the usefulness of such models increases, the computational complexity of those models continues to grow. It may be difficult to implement a complete machine learning model entirely on one computing device, particularly where the computing device is consumer level user equipment. The present disclosure thus relates to techniques in which an ML model is implemented partly on one endpoint (such as user equipment, UE) and partly on another endpoint (which may be a network entity), referred to as split inferencing.SUMMARY

[0003] Briefly stated, in one embodiment, a method comprises: at a first endpoint, obtaining information describing at least a first sub-model of a split-inferencing machine learning model; in communication with a second endpoint, selecting a tensor indexing algorithm; executing the first sub-model to obtain at least one tensor; and sending the tensor to the second endpoint, wherein each tensor is identified by a respective reference determined according to the selected tensor indexing algorithm. An apparatus according to some embodiments comprises one or more processors configured to perform such a method.

[0004] A method according to some embodiments comprises: at a second endpoint, obtaining information describing at least a second sub-model of a split-inferencing machine learning model; in communication with a first endpoint, selecting a tensor indexing algorithm; receiving at least one tensor from the first endpoint, wherein each tensor is identified by a respective reference determined according to the selected tensor indexing algorithm; and executing the second sub-model on the at least one tensor. An apparatus according to some embodiments comprises one or more processors configured to perform such a method.BRIEF DESCRIPTION OF THE DRAWINGS

[0005] The following detailed description will be better understood when read in conjunction with the appended drawings, in which there are shown examples of one or more of the multiple embodiments of the present disclosure. It should be understood, however, that the embodiments described herein are not limited to the precise arrangements and instrumentalities shown in the drawings.

[0006] FIG. 1 illustrates an architecture for a split inference between the UE (user equipment) and network, with the media data source in the UE.

[0007] FIG. 2 illustrates an architecture for a split inference between the UE (user equipment) and network, with the media data source in the network.

[0008] FIGs. 3A-3C illustrate a split inferencing model in which only one connection is present. FIG. 3A illustrates Part I, which is the sub-model used to initiate the inference on the EndPointl (e.g. UE). FIG. 3B illustrates Part II, which is the sub-model used to finalize the inference process on EndPoint2 (e.g. a network). FIG. 3C illustrates the topology of the entire model (with names removed for clarity of illustration).

[0009] FIGs. 4A-4D illustrate an example of a split inferencing model with two connections. FIG. 4A illustrates Part I. FIG. 4B and 4C together illustrate Part II. FIG. 4D illustrates the complete model topology (with names removed for clarity of illustration).

[0010] FIG. 5 illustrates a split inference architecture that may be used to implement an indexing method with negation and transmission of intermediate data with encoded tensor name.

[0011] FIG. 6 is a call flow diagram illustrating a negotiation method performed in some embodiments.

[0012] FIG. 7 is a call flow diagram illustrating an inference loop method performed in some embodiments.

[0013] FIG. 8 provides an overview of the topology of an ML model used in some embodiments. For clarity of illustration, most nodes are not labelled.

[0014] FIG. 9 illustrates Submodel I based on the model of FIG. 8 split at the node with index 5.

[0015] FIG. 10 illustrates Submodel II based on the model of FIG. 8 split at the node with index 5.

[0016] FIG. 11 is a call flow diagram illustrating implementation of split inferencing in a 3GPP framework.

[0017] FIG. 12 is a functional block diagram of an apparatus on which some embodiments may be implemented.DETAILED DESCRIPTION

[0018] In describing the various embodiments of the present disclosure, certain terminology is used herein for convenience only and should not be considered as limiting such embodiments. In the drawings, the same reference numerals are employed for designating the same elements throughout the several figures and the present description.Overview of Split Inferencing of a Trained Model

[0019] FIG. 1 provides an overview of an architecture (3GPP SA4 AI4media) for split inferences of a model composed of n layers or nodes (1 ..n) between the network and a user equipment (UE), where a first inference implemented on a first endpoint processes first part of the model, i.e. layers 1..k, and the second inference implemented on a second endpoint processes the second part of the model, i.e. layers k+1 ..n. The architecture shows the delivery and access functions of intermediate data between the UE and the network when the media data source originates from the UE. The first part of the inference is then performed in the UE and the second part in the network. The resulting output data is finally sent back to the UE.

[0020] In another configuration, illustrated in FIG. 2, the media data source comes from the network, then the first part of the Al model is performed on the network side and the second part on the UE. Example embodiments herein may be implemented using either configuration.

[0021] A pre-processing is used to adapt the input media data to the input inference. Conversely, a post-processing is used to adapt the output results data of the inference to the media consumption.

[0022] In the present disclosure, the terms “layers” or “nodes” may be used interchangeably. Among those skilled in the art, the term “layers" is used more often in frameworks like Tensorflow, while “nodes” tends to be used with reference to the ONNX framework. The term “branch” refers to the entity that links two nodes or two layers e.g. the output of a node / layer A that is the input of node / layer B.Branch splitting

[0023] Artificial intelligence (Al) and / or machine learning (ML) model architectures have various different structures and different levels of complexity. A neural network can include thousand or millions of nodes. Each node is connected with at least another node. In case ofmultiple connections, the split operation applies on multiple branches. In case of a simple connection, the split operation applied on a single branch.

[0024] Single-branch split. FIGs. 3A-3C show a representation of the efficientnet_liteO_Opset16.onnx model which was split at the node numbered “node 10” in the numbering scheme of that model, where only one connection is present. FIG. 3A illustrates Part I, which is the sub-model used to initiate the inference on the EndPointl (e.g. UE). FIG. 3B illustrates Part II, which is the sub-model used to finalize the inference process on EndPoint2 (e.g. Network). FIG. 3C illustrates the topology of the entire model (with names removed for clarity of illustration). The name of the “node 10” output is “ / blocks / blocks.1 / blocks.1 .0 / conv_pw / Conv_output_0” with short name “Conv_output_0”. This branch name is used to identify the intermediate data which are sent from EndPointl (e.g. UE) to EndPoint2 (e.g. Network).

[0025] The intermediate data delivery function associates intermediate data with node I / O naming, e.g. “ / blocks / blocks.1 / blocks.1 .0 / conv_pw / Conv_output_0”.

[0026] The intermediate data access function parses the intermediate data packet, retrieves the node I / O naming, e.g. branch “ / blocks / blocks.1 / blocks.1.0 / conv_pw / Conv_output_0” and can route the intermediate data to the ad-hoc layer in the model inference engine.

[0027] Multibranch split. For some models, or some parts of a model, a node is connected to several nodes for its input, and / or several nodes for its output. A split made at a such node is called a multibranch split. The result is several tensors that encapsulate intermediate data.

[0028] FIGs. 4A-4D illustrate an example of the resnet model split at node 6 into Part I and Part II. FIG. 4A illustrates Part I. FIG. 4B and 4C together illustrate Part II. FIG. 4D illustrates the complete model topology (with names removed for clarity of illustration). The split is made of two branches:• one branch from “node 6” (7feature_extractor / feature_extractor / feature_extractor.4 / feature_extractor.4.0 / conv2 / Conv”) to node 7 with branch name 7feature_extractor / feature_extractor / feature_extractor.4 / feature_extractor.4.0 / conv2 / Conv_output_0””,• and one branch from “node 3” (7feature_extractor / feature_extractor / feature_extractor.3 / MaxPool”) to “node 9” with branch name 7feature_extractor / feature_extractor / feature_extractor.3 / MaxPool_output_0”.

[0029] Tensors and intermediate data are conventionally identified with the branch naming, [7feature_extractor / feature_extractor / feature_extractor.4 / feature_extractor.4.0 / conv2 / Conv_ output_0” , 7feature_extractor / feature_extractor / feature_extractor.3 / MaxPool_output_0”].

[0030] The intermediate data delivery function combines intermediate data with branch naming.

[0031] The intermediate data access function parses the intermediate data packet, retrieves the branch naming and can route the intermediate data to the EndPoint2.Overview of the ONNX format

[0032] ONNX is an open format built to represent machine learning models. ONNX defines a common set of operators - the building blocks of machine learning and deep learning models - and a common file format to enable Al developers to use models with a variety of frameworks, tools, runtimes, and compilers.

[0033] ONNX may be used to describe a computational graph. The model itself is organized in graph, in a tree-like way (e.g. an ONNX model may be load as onnx_model = onnx.load(onnx_model_name)).

[0034] Inputs of a model are available as a list of string (e.g. onnx_model. graph. input).

[0035] Outputs of a model are available as a list of string (e.g. onnx_model. graph. output).

[0036] Each machine learning operation is represented by a “node”.

[0037] All nodes are available through a list (e.g. onnx_model. graph. node)

[0038] Each node has following properties:• node. name: a string that identifies this node• node. input: a list of string that represent tensor name expected by the node• node. output: a list of string that represent tensor name generated by the node• node.op_type: a string that identifies the operation of the node

[0039] Running an inference with an ONNX model conventionally involves passing a dictionary containing the association tensor name I tensor value, such as the following example, in which the tensor names are the names of the input tensors of the model. { «tensor_name_l» : tensor_value_lj «tensor_name_2» : tensor_value_2j«tensor_name_n» : tensor_value_n }Overview of issues addressed in some embodiments

[0040] An application running on a UE may make use of an AI / ML model M to infer pictures, videos, texts, or audio sequences. For some reasons, like local constraints on memory and / or energy limitations, the inference process is distributed between an EndPointl and anEndPoint2 respectively a UE itself and the Network. Thus, on EndPointl the application downloads or otherwise obtains a sub-model M1 which is a sub-part of M, while EndPoint2 (Network) downloads or otherwise obtains the corresponding sub-model M2. M1 and M2 have at least one input, and at least one output.

[0041] M1 and M2 are two sub-models that constitute model M. By working together, they replicate the M inference process in the sense that they provide the same functionality with the same results in terms of accuracy or score.

[0042] The inference is distributed between M1 and M2. Intermediate data of the M1 inference results are then communicated to the second endpoint.

[0043] A straightforward solution is to communicate these intermediate data by communicating both “tensor name” and “tensor value”. However, this straightforward solution regarding the tensor names may have the following issues:• Tensor names have often a long size due to complex naming conventions used at the conception of the model, or during the automatic conversion of the model from the original framework (e.g. tensorflow, pytorch, ...) to ONNX framework, (e.g. StatefulPartitionedCall / StatefulPartitionedCall / dense / StatefulPartitionedCall / MatMul:0 , / feature_extractor / feature_extractor / feature_extractor.3 / MaxPool) that may unnecessarily slow down the transmission of intermediate data.• Tensor names may contain special characters like 7”, “\” that may generate some troubles for interoperability between various operating systems.• Information transmitted in the clear can give important information to hacker that may discover tensor names, model used, and may exploit this information to create a computer breach.Overview of example embodiments

[0044] In view of these issues, example embodiments endeavourto provide a way to generate a more concise and unique representation of the tensor name. Example embodiments further provide techniques for communicating the method used to generate this unique representation.

[0045] Some example embodiments make use of a negotiation phase and an inference loop phase. In the negotiation phase, some or all of the following actions may be taken:• A first endpoint and a second endpoint negotiate an indexing algorithm supported by both endpoints. This negotiation step may also occur during inference loop step.• At the end of this negotiation step each endpoint has knowledge of the agreed indexing algorithm table, the agreed indexing algorithm, and has built or collected the tensors indexing table (the table of association index - tensor names).

[0046] In the inference loop phase, some or all of the following actions may be taken:• A first endpoint infers a first part of the model resulting in intermediate data.• A first endpoint selects an agreed indexing algorithm.• A first endpoint encodes the tensor name by generating a key index based on the agreed indexing algorithm.• A first endpoint sends the intermediate data to the second endpoint with the encoded tensor name.• A second endpoint receives the intermediate data with the encoded tensor name.• According to the agreed indexing algorithm received at the negotiation step, a second endpoint decodes the received encoded tensor names and retrieve the original tensor names.• A second endpoint infers the second part of the model.

[0047] The list of indexing algorithms table exchanged at the negotiation phase may be provided using different means. A predefined table of indexing algorithms may also be used.

[0048] Example embodiments operate to hide and shorten intermediate data tensor names. Example embodiments index intermediate data tensor names to enable the exchange of a simple index instead of full tensor names. Such embodiments offer some gain on the data length of data exchanged and some confidentiality on the data exchanged as the tensor name is not explicitly communicated between the two endpoints. Some embodiments include a negotiation phase to indicate the use of the method between the two endpoints and exchange additional information used to run the selected algorithm.Bijection between keys and tensor names

[0049] Example embodiments generate a key in an unequivocal way that establishes a bijection between the tensor name and the generated key. With ONNX models for example, this is possible thanks to the fact that ONNX graphs are DAG (Direct Acyclic Graph). Consequently, all nodes are sequentially listed in a unique way. In addition, for each node, all outputs of the nodes are also listed in a unique way. This makes it possible to browse all node’s output in a unique way and to generate a unique node output reference.Key indexation

[0050] Example embodiments may make use of any of a variety of indexations. In some embodiments the indexation may be a global unique reference such, as:• an integer from 0 to n, indicating the rank of the tensor in the model; or• a string using a specific format including an integer from 0 to n: e.g. “output_34”, ”tensor_37”

[0051] It should be noted that the term “rank” used herein refers to the ordinal position of a tensor (e.g. first, second, third etc.) among the tensors used in a model, rather than the tensor rank in the sense of tensor rank decomposition as used in linear algebra. In some embodiments the indexation may be a combined / relative reference, combining a node index, and an output node index, such as:• an array of integers: [node index, node output index of this node] e.g. [17,0], [17,1], where [17, 0] means the first output of node 17, [17, 1] means the second output of node 17;• a couple of integers: (node index, node output index of this node) e.g. (17,0), (17,1)• a string composed of two integers: node index.node_output_index_of_this node e.g. “0.0”, “0.1”; or• a string using a specific format including two integers: e.g. “outputJD.O”, “tensor_0.1”Indexing algorithms

[0052] Encoding phase: pseudocode to generate a global reference. A technique as shown in the following pseudocode may be used by a first endpoint to encode a tensor name by generating a global unique reference (e.g. an integer from 0 to n, where(n+1) is the number of node outputs in the model). This pseudocode may run either on the full model, or on submodel I. For sake of simplicity, full model or submodel I is called “M1” on the pseudo code below.• Input: model M1 with nodes ni having output Oj• Initialize ‘outputjndex’ to 0• Create dictionary ‘D’ that will store association “output name” to ’’outputjndex”• For all nodes ni of the model M1 : o For all outputs Oj of node ni■ set D[Oj output name] to outputjndex■ increment outputjndex by one• D contains the key index / global reference of each tensor_name• For each tensor (tensor_name, tensor_value) of intermediate tensors, send (D[tensor_name], tensor_value) to the second endpoint

[0053] In a variant embodiment, tensors may be sorted by alphabetical order as shown in the following pseudocode.• Input: model M1 with nodes ni having output Oj• Create dictionary ‘D’ that will store association “output name” to ’’outputjndex”• Initialize tensorjist to []• For all nodes ni of the model M1 : o For all outputs Oj of node ni■ Add Oj output name to tensorjist• Sort tensorjist by alphabetical order• Initialize ‘outputjndex’ to 0• For all tensor_name of tensorjist: o set D[tensor_name] to outputjndex o increment outputjndex by one• D contains the key index / global reference of each tensor_name• For each tensor (tensor_name, tensor_value) of intermediate tensors, send (D[tensor_name], tensor_value) to the second endpoint

[0054] Decoding phase: pseudocode to retrieve tensor name from a global reference. A technique as shown in the following pseudocode may be used by a second endpoint to decode a global unique reference to retrieve the original tensor name. This pseudocode may run either on the full model, or on submodel I. For sake of simplicity, full model or submodel I is called “M1” on the pseudo code below.• Input: model M1 with nodes ni having output Oj• Initialize ‘outputjndex’ to 0• Create dictionary ‘D_reverse’ that will store association “outputjndex” to “output name”• For all nodes ni of the model M1 : o For all outputs Oj of node ni■ set D_reverse[outputjndex] to Oj output name■ increment outputjndex by one• D_reverse contains the original tensor_name for each global reference• For each tensor (global_reference, tensor_value) of intermediate tensors, retrieve the tensor_name by doing tensor_name= D_reverse[global_reference]

[0055] In a variant embodiment, tensors may be sorted by alphabetical order as shown in the following pseudocode.• Input: model M1 with nodes ni having output Oj• Initialize tensorjist to []• Create dictionary ‘D_reverse’ that will store association “outputjndex” to “output name”• For all nodes ni of the model M1 : o For all outputs Oj of node ni■ Add Oj output name to tensorjist• Sort tensorjist by alphabetical order• Initialize ‘outputjndex’ to 0• For all tensor_name of tensorjist: o set D_reverse[output_index] to tensor_name o increment outputjndex by one• D_reverse contains the original tensor_name for each global reference

[0056] Encoding phase: pseudocode to generate a reference related to the node rank. A technique as shown in the following pseudocode may be used by a first endpoint to encode a tensor name by generating a reference related to a node rank (e.g. a couple of integers (node rank, node output rank of this node)). This pseudocode may run either on the full model, or on submodel I. For sake of simplicity, full model or submodel I is called “M1” on the pseudo code below.• Input: model M1 with nodes ni having output Oj• Initialize ‘node_rank’ to 0• Create dictionary ‘D’ that will store association output name to (node_rank, output_rank)• For all nodes ni of the model M1 : o Initialize ‘output_rank’ to 0 o For all outputs Oj of node ni■ set D[Oj output name] to (node_rank, output_rank)■ increment output_rank’ by one o increment node_rank by one• D contains the key index / related reference of each tensor_name• For each tensor (tensor_name, tensor_value) of intermediate tensors, send (D[tensor_name], tensor_value) to the second endpoint

[0057] Decoding phase: pseudocode to retrieve tensor name from couple (node rank, node output rank). A technique as shown in the following pseudocode may be used by a second endpoint to decode a related reference to retrieve the original tensor name. This pseudocode may run either on the full model, or on submodel I. For sake of simplicity, full model or submodel I is called “M1” on the pseudo code below.• Input: model M1 with nodes ni having output Oj• Initialize ‘node_rank’ to 0• Create dictionary ‘D_ reverse that will store association (node_rank, output_rank) to output name• For all nodes ni of the model M1 : o Initialize ‘output_rank’ to 0 o For all outputs Oj of node ni■ set D_reverse [(node_rank, output_rank)] to Oj output name■ increment output_rank by one o increment node_rank by one• D_reverse contains the original tensor_name for each related reference• For each tensor (related_reference, tensor_value) of intermediate tensors, retrieve the tensor_name by doing tensor_name= D_reverse[related_reference]Architecture

[0058] FIG. 5 illustrates a split inference architecture that may be used to implement an indexing method with negation and transmission of intermediate data with encoded tensor name.Negotiation and setup

[0059] Example embodiments may be implemented in a context in which endpoints are already exchanging information on the split point, i.e. the layer or node where the inference ends on the first endpoint and where it starts on the second endpoint.

[0060] The negotiation phase may be implemented to determine which indexing algorithm will be used to encode the tensor name of each tensor of the intermediate data. In addition to current information, like split point index, in example embodiments, information identifying the indexing algorithm will be exchanged between both endpoints. FIG. 6 illustrates a negotiation method performed in some embodiments. At 601 , a negotiation phase has started and both parties, EndPointl and EndPoint2 have agreed on a SplitPoint. At 602, EndPointl and EndPoint2 agree on an indexing algorithm table (see Table 1 : indexing algorithm table). At603, EndPointl and EndPoint2 agree on an indexing algorithm. Endpoint I and endpoint II obtain submodels with different possible ways. At 604a, EndPointl downloads the full model and extracts the submodel I; alternatively, at 604b, EndPointl downloads the submodel I. At 604c, EndPoint2 downloads the full model and extracts the submodel I and submodel II. Alternatively, at 604d, EndPoint2 downloads the submodel I and submodel II. Alternatively, at 604e, EndPoint2 downloads the submodel II. At 605, each endpoint either builds the tensors indexing table from the submodel I, or downloads it. At this point, each endpoint has obtained its submodel (submodel I for endpoint I, submodel II for endpoint II) , the tensors indexing table, and has information indicating which indexing algorithm will be used. At 606, the inference loop may start.

[0061] In some embodiments, key indexation may be used by exchanging a reference indicating the indexing algorithm used. This reference may be one of the possible references of an indexing algorithm table like that of T able 1 .Table 1 : indexing algorithm table

[0062] In some embodiments, information such as that reflected in Table 1 may be available to both endpoints via an out of band solution or exchanged between the endpoints during the negotiation.Inference loop

[0063] FIG. 7 illustrates the inference loop, the phase during which the inference process runs and intermediate data are sent from EndPointl to EndPoint2, as implemented in some embodiments. At 701 , the inference loop is running. At 702, on EndPointl , the inference process is applied on sub-model Part I and generates intermediate data. At 703, on EndPointl , the encoding process is applied on the tensor name of intermediate data using the agreed index algorithm in the negotiation phase. At 704, intermediate data with the tensor name encoded are sent from EndPointl to EndPoint 2. At 705, on EndPoint2, the decoding process is applied on the tensor name of intermediate data using the agreed indexing algorithm table, the agreed index algorithm, and the tensors indexing table obtained during the negotiation phase. At 706, on EndPoint2, the inference process is applied on sub-model Part II.Illustration with an existing model

[0064] An example embodiment is illustrated here with respect to an existing Nerf (neural radiance field) model. FIG. 8 provides an overview of the topology of the model (for clarity of illustration, most nodes are not labelled).

[0065] The following table provides a list of the indices and names of all nodes in the model.

[0066] The following table provides a list of all node outputs of the model, with a global index and a related index.2024P00796WG

[0067] In a case where the model is split at the node with index 5, the resulting Submodel I is as illustrated in FIG. 9. In the illustration of FIG. 9, the nodes are identified by their node indices. Correspondingly, the resulting Submodel II is as illustrated in FIG. 10. In the illustration of FIG. 10, the nodes are identified by their node indices.

[0068] In the case as illustrated in FIGs. 9-10, where the model is split after the node with index 5, the intermediate tensors names to communicate from EndPointl to EndPoint2 are as follows: 'StatefulPartitionedCall / StatefulPartitionedCall / dense_1 / StatefulPartitionedCall / BiasAdd:0','StatefulPartitionedCall / StatefulPartitionedCall / tf_op_layer_split / PartitionedCall / split:0','StatefulPartitionedCall / StatefulPartitionedCall / tf_o pjay er_sp I it / Pa rtitio nedCal l / s p lit : 1 '

[0069] In one example embodiment, the tensor names are encoded using a global index, for example as follows:• “3” for‘StatefulPartitionedCall / StatefulPartitionedCall / dense_1 / StatefulPartitionedCall / BiasAdd:0’,• “0” for 'StatefulPartitionedCall / StatefulPartitionedCall / tf_op_layer_split / PartitionedCall / split:0',• “1” for StatefulPartitionedCall / StatefulPartitionedCall / tf_op_layer_split / PartitionedCall / split: 1 '

[0070] The compression ratios in this case may be estimated as follows:• If the global index is coded with a 16 bits integer:16 bits for the global index, about 80 * 8=640 bits for the tensor name: 640 / 16=40• If the global index is coded with a string: encoded length is 8 bits640 / 8=80

[0071] In another example embodiment, the tensor names are encoded with the couple index:• “2.0” or (2,0) for‘StatefulPartitionedCall / StatefulPartitionedCall / dense_1 / StatefulPartitionedCall / BiasAdd:0’,• “0.0” or (0,0) for'StatefulPartitionedCall / StatefulPartitionedCall / tf_op_layer_split / PartitionedCall / split:0',• “0.1” or (0,1) forStatefulPartitionedCall / StatefulPartitionedCall / tf_op_layer_split / PartitionedCall / split: 1 '

[0072] The compression ratios in this case may be estimated as follows:• If index is coded with two 16 bits integer:2*16=32 bits for the global index, about 80 * 8=640 bits for the tensor name: 640 / 32=20• If index is coded with a string: encoded tensor name is made of a string of three characters (e.g. “0.0”) to four characters (e.g. “36.0”).640 / (3*8)=26.67640 / (4*8)=20Implementations using 3GPP

[0073] In 3GPP SA4 26.927 v0.90, “Study on Artificial Intelligence (Al) and Machine Learning (ML) for Media,” clause 6.6.4 provides a table describing intermediate data information for split AI / ML operations. In an example embodiment implemented in a 3GPP system, the following information may be included in the intermediate data and may be described in the table as follows.

[0074] The row in the table with Tensor Name may also be amended as follows.

[0075] In an example embodiment, the table describing intermediate data information may identify the structure of intermediate data output from a first endpoint to be retrieved to feed the inference of the second endpoint after transmission of the intermediate data over the network. An example of an updated table is as follows.

[0076] In some embodiments, the tensor identification can have any of a variety of different formats. For example, a tensor identifier can be a name, a numerical index that can be extracted from a list or a tensor index table

[0077] A tensor encoding type may be used to identify from which method the tensor is identified, either by an index of table or of a list, by a name.

[0078] A tensor identifier type may be negotiated and exchanged between split endpoints during the configuration stage.2024P00796WGCall flow

[0079] In 3GPP SA4 26.927 v0.90, Clause 5.2.3.2 describes basic workflows for split inferencing. An overview of the workflow is provided in the call flow diagram of FIG. 11 . Some embodiments may be implemented using a 3GPP split inferencing call flow such as that illustrated in FIG. 11.

[0080] In FIG. 11 , a UE has some or all of the following components: a UE data source 2052, a UE data destination 2054, a UE application 2056, an Al model inference engine 2058, an Al model access function 2060, and an intermediate data access function 2062. A network includes some or all of the following components: an intermediate data delivery function 2064, an Al model delivery function 2066, an Al model repository 2068, an Al model inference engine 2070, a network application 2072, and a data source 2074.

[0081] At 2000, session establishment is performed. In an Al split inference negotiation, at 2001 , a UE’s endpoint capability information is obtained.

[0082] In a case where the network decides on the Al model split, the split inference negotiation proceeds with steps 2002a-2007a. At 2002a, a split inference request is made. At 2003a, the network gets the UE’s request information. At 2004a, the network selects the split Al model. At 2005a, the network application requests allocation of resources for Al inference, and at 2006a it receives a response. At 2007a, the Al split inference response is sent to the UE.

[0083] In a case where the network decides on the Al model split, the split inference negotiation proceeds with steps 2002b-2009b. At 2002b, the UE makes an Al model information request. At 2003b, an Al model is selected, and at 2004b, an Al model information response is provided to the UE. At 2005b, the UE selects a split Al model and at 2006b sends an Al split inference selection request to the network. At 2007b a request is made to allocate Al inference resources, and a response is received at 2008b. At 2009b, an Al split inference selection response is sent to the UE.

[0084] Al model subset delivery is performed in steps 2010-2014. At 2010, selected Al model subsets are identified. At 2011 , the appropriate AI / ML subset is passed to the network for inferencing. At 2012, a UE Al model subset delivery session is established. At 2013, the appropriate AI / ML subset is delivered to the UE. At 2014, the UE’s AI / ML model subset is passed to the UE’s Al model inference engine for inferencing.

[0085] In a case where the data source for the Al inferencing is on the network, the Al split inferencing proceeds with steps 2015a through 2020a. At 2015a, the input media data is retrieved from the network or from a peer user. At 2016a, Al inferencing is performed on the first sub-model, and at 2018a, the resulting intermediate data is provided to the UE. At 2019a, the UE runs the second sub-model on the intermediate data, and at 2020a, it provides the inference output to the appropriate UE data destination.

[0086] In a case where the data source for the Al inferencing is in the UE, the Al split inferencing proceeds with steps 2015b through 2021 b. At 2015b, the input media data is provided to the Al model inference engine of the UE. At 2016b, the UE runs the first sub-model on the input media data to obtain intermediate data. At 2017b, an intermediate data delivery session is established, and at 2018b, the intermediate data is delivered to the Al model inference engine on the network. At 2019b, the second sub-model is run on the intermediate data to obtain the final output of the model. The output is then delivered to the UE (at 2020b) or to another recipient (at 2021 b).

[0087] Within this workflow, at 2006b, the UE application sends an Al split inference selection request to the network application with the selected split point configuration. In an example2024P00796WG embodiment, this flow 2006b may be extended to carry information on the tensor name encoding, as tensor name encoding may be part of the split point configuration.Compression metadata

[0088] In 3GPP SA4 26.927 v0.90, Clause 6.6.7 describes compression metadata. In some embodiments, the following information may be added in the existing table describing compression metadata.

[0090] As a result, example embodiments implemented in a 3GPP system may use metadata as described in the following updated table.2024P00796WG

[0091] Example embodiments enable two endpoints to transmit efficiently intermediate data tensor names with bandwidth gain and confidentiality. Example systems

[0092] Some embodiments may be implemented on a system of one or more processors as illustrated in FIG. 12. FIG. 12 is a block diagram of an example of a system in which various aspects and embodiments are implemented. System 1300 can be embodied as a device including the various components described below and is configured to perform one or moreof the aspects described in this document. Examples of such devices, include, but are not limited to, various electronic devices such as personal computers, laptop computers, smartphones, tablet computers, digital multimedia set top boxes, digital television receivers, personal video recording systems, connected home appliances, and servers. Elements of system 1300, singly or in combination, can be embodied in a single integrated circuit (IC), multiple ICs, and / or discrete components. For example, in at least one embodiment, the processing and encoder / decoder elements of system 1300 are distributed across multiple ICs and / or discrete components. In various embodiments, the system 1300 is communicatively coupled to one or more other systems, or other electronic devices, via, for example, a communications bus or through dedicated input and / or output ports. In various embodiments, the system 1300 is configured to implement one or more of the aspects described in this document.

[0093] The system 1300 includes at least one processor 1310 configured to execute instructions loaded therein for implementing, for example, the various aspects described in this document. Processor 1310 can include embedded memory, input output interface, and various other circuitries as known in the art. The system 1300 includes at least one memory 1320 (e.g., a volatile memory device, and / or a non-volatile memory device). System 1300 includes a storage device 1340, which can include non-volatile memory and / or volatile memory, including, but not limited to, Electrically Erasable Programmable Read-Only Memory (EEPROM), Read-Only Memory (ROM), Programmable Read-Only Memory (PROM), Random Access Memory (RAM), Dynamic Random Access Memory (DRAM), Static Random Access Memory (SRAM), flash, magnetic disk drive, and / or optical disk drive. The storage device 1340 can include an internal storage device, an attached storage device (including detachable and non-detachable storage devices), and / or a network accessible storage device, as non-limiting examples.

[0094] System 1300 includes an encoder / decoder module 1330 configured, for example, to process data to provide an encoded video or decoded video, and the encoder / decoder module 1330 can include its own processor and memory. The encoder / decoder module 1330 represents module(s) that can be included in a device to perform the encoding and / or decoding functions. As is known, a device can include one or both of the encoding and decoding modules. Additionally, encoder / decoder module 1330 can be implemented as a separate element of system 1300 or can be incorporated within processor 1310 as a combination of hardware and software as known to those skilled in the art.

[0095] Program code to be loaded onto processor 1310 or encoder / decoder 1330 to perform the various aspects described in this document can be stored in storage device 1340 and subsequently loaded onto memory 1320 for execution by processor 1310. In accordance withvarious embodiments, one or more of processor 1310, memory 1320, storage device 1340, and encoder / decoder module 1330 can store one or more of various items during the performance of the processes described in this document. Such stored items can include, but are not limited to, the input point cloud, the decoded point cloud or portions of the decoded point cloud, the bitstream, matrices, variables, and intermediate or final results from the processing of equations, formulas, operations, and operational logic.

[0096] In some embodiments, memory inside of the processor 1310 and / or the encoder / decoder module 1330 is used to store instructions and to provide working memory for processing that is needed during encoding or decoding. In other embodiments, however, a memory external to the processing device (for example, the processing device can be either the processor 1310 or the encoder / decoder module 1330) is used for one or more of these functions. The external memory can be the memory 1320 and / or the storage device 1340, for example, a dynamic volatile memory and / or a non-volatile flash memory. In several embodiments, an external non-volatile flash memory is used to store the operating system of, for example, a television. In at least one embodiment, a fast external dynamic volatile memory such as a RAM is used as working memory for video coding and decoding operations, such as for MPEG-2 (MPEG refers to the Moving Picture Experts Group, MPEG-2 is also referred to as ISO / IEC 13818, and 13818-1 is also known as H.222, and 13818-2 is also known as H.262), HEVC (HEVC refers to High Efficiency Video Coding, also known as H.265 and MPEG-H Part 2), or WC (Versatile Video Coding, a new standard being developed by JVET, the Joint Video Experts Team).

[0097] The input to the elements of system 1300 can be provided through various input devices as indicated in block 1332. Such input devices include, but are not limited to, (i) a radio frequency (RF) portion that receives an RF signal transmitted, for example, over the air by a broadcaster, (ii) a Component (COMP) input terminal (or a set of COMP input terminals), (iii) a Universal Serial Bus (USB) input terminal, and / or (iv) a High Definition Multimedia Interface (HDMI) input terminal. Other examples include composite video.

[0098] In various embodiments, the input devices of block 1332 have associated respective input processing elements as known in the art. For example, the RF portion can be associated with elements suitable for (i) selecting a desired frequency (also referred to as selecting a signal, or band-limiting a signal to a band of frequencies), (ii) downconverting the selected signal, (iii) band-limiting again to a narrower band of frequencies to select (for example) a signal frequency band which can be referred to as a channel in certain embodiments, (iv) demodulating the downconverted and band-limited signal, (v) performing error correction, and (vi) demultiplexing to select the desired stream of data packets. The RF portion of various embodiments includes one or more elements to perform these functions, for example,frequency selectors, signal selectors, band-limiters, channel selectors, filters, downconverters, demodulators, error correctors, and demultiplexers. The RF portion can include a tuner that performs various of these functions, including, for example, downconverting the received signal to a lower frequency (for example, an intermediate frequency or a near-baseband frequency) or to baseband. In one set-top box embodiment, the RF portion and its associated input processing element receives an RF signal transmitted over a wired (for example, cable) medium, and performs frequency selection by filtering, downconverting, and filtering again to a desired frequency band. Various embodiments rearrange the order of the above-described (and other) elements, remove some of these elements, and / or add other elements performing similar or different functions. Adding elements can include inserting elements in between existing elements, such as, for example, inserting amplifiers and an analog-to-digital converter. In various embodiments, the RF portion includes an antenna.

[0099] Additionally, the USB and / or HDMI terminals can include respective interface processors for connecting system 1300 to other electronic devices across USB and / or HDMI connections. It is to be understood that various aspects of input processing, for example, Reed-Solomon error correction, can be implemented, for example, within a separate input processing IC or within processor 1310 as necessary. Similarly, aspects of USB or HDMI interface processing can be implemented within separate interface ICs or within processor 1310 as necessary. The demodulated, error corrected, and demultiplexed stream is provided to various processing elements, including, for example, processor 1310, and encoder / decoder 1330 operating in combination with the memory and storage elements to process the datastream as necessary for presentation on an output device.

[0100] Various elements of system 1300 can be provided within an integrated housing, Within the integrated housing, the various elements can be interconnected and transmit data therebetween using suitable connection arrangement 1342, for example, an internal bus as known in the art, including the I nter-IC (I2C) bus, wiring, and printed circuit boards.

[0101] The system 1300 includes communication interface 1350 that enables communication with other devices via communication channel 1360. The communication interface 1350 can include, but is not limited to, a transceiver configured to transmit and to receive data over communication channel 1360. The communication interface 1350 can include, but is not limited to, a modem or network card and the communication channel 1360 can be implemented, for example, within a wired and / or a wireless medium.

[0102] Data is streamed, or otherwise provided, to the system 1300, in various embodiments, using a wireless network such as a Wi-Fi network, for example IEEE 802.11 (IEEE refers to the Institute of Electrical and Electronics Engineers). The Wi-Fi signal of these embodimentsis received over the communications channel 1360 and the communications interface 1350 which are adapted for Wi-Fi communications. The communications channel 1360 of these embodiments is typically connected to an access point or router that provides access to external networks including the Internet for allowing streaming applications and other over- the-top communications. Other embodiments provide streamed data to the system 1300 using a set-top box that delivers the data over the HDMI connection of the input block 1332. Still other embodiments provide streamed data to the system 1300 using the RF connection of the input block 1332. As indicated above, various embodiments provide data in a non-streaming manner. Additionally, various embodiments use wireless networks other than Wi-Fi, for example a cellular network or a Bluetooth network.

[0103] The system 1300 can provide an output signal to various output devices, including a display 1302, speakers 1312, and other peripheral devices 1322. The display 1302 of various embodiments includes one or more of, for example, a touchscreen display, an organic lightemitting diode (OLED) display, a curved display, and / or a foldable display. The display 1302 can be for a television, a tablet, a laptop, a cell phone (mobile phone), or other device. The display 1302 can also be integrated with other components (for example, as in a smart phone), or separate (for example, an external monitor for a laptop). The other peripheral devices 1322 include, in various examples of embodiments, one or more of a stand-alone digital video disc (or digital versatile disc) (DVR, for both terms), a disk player, a stereo system, and / or a lighting system. Various embodiments use one or more peripheral devices 1322 that provide a function based on the output of the system 1300. For example, a disk player performs the function of playing the output of the system 1300.

[0104] In various embodiments, control signals are communicated between the system 1300 and the display 1302, speakers 1312, or other peripheral devices 1322 using signaling such as AV.Link, Consumer Electronics Control (CEC), or other communications protocols that enable device-to-device control with or without user intervention. The output devices can be communicatively coupled to system 1300 via dedicated connections through respective interfaces 1370, 1380, and 1390. Alternatively, the output devices can be connected to system 1300 using the communications channel 1360 via the communications interface 1350. The display 1302 and speakers 1312 can be integrated in a single unit with the other components of system 1300 in an electronic device such as, for example, a television. In various embodiments, the display interface 1370 includes a display driver, such as, for example, a timing controller (T Con) chip.

[0105] The display 1302 and speaker 1312 can alternatively be separate from one or more of the other components, for example, if the RF portion of input 1332 is part of a separate set- top box. In various embodiments in which the display 1302 and speakers 1312 are externalcomponents, the output signal can be provided via dedicated output connections, including, for example, HDMI ports, USB ports, or COMP outputs.

[0106] The embodiments can be carried out by computer software implemented by the processor 1310 or by hardware, or by a combination of hardware and software. As a nonlimiting example, the embodiments can be implemented by one or more integrated circuits. The memory 1320 can be of any type appropriate to the technical environment and can be implemented using any appropriate data storage technology, such as optical memory devices, magnetic memory devices, semiconductor-based memory devices, fixed memory, and removable memory, as non-limiting examples. The processor 1310 can be of any type appropriate to the technical environment, and can encompass one or more of microprocessors, general purpose computers, special purpose computers, and processors based on a multi-core architecture, as non-limiting examples.Further embodiments

[0107] A method according to some embodiments comprises: at a first endpoint, obtaining information describing at least a first sub-model of a split-inferencing machine learning model; in communication with a second endpoint, selecting a tensor indexing algorithm; executing the first sub-model to obtain at least one tensor; and sending the tensor to the second endpoint, wherein each tensor is identified by a respective reference determined according to the selected tensor indexing algorithm.

[0108] An apparatus according to some embodiments comprises one or more processors configured to perform at least: at a first endpoint, obtaining information describing at least a first sub-model of a split-inferencing machine learning model; in communication with a second endpoint, selecting a tensor indexing algorithm; executing the first sub-model to obtain at least one tensor; and sending the tensor to the second endpoint, wherein each tensor is identified by a respective reference determined according to the selected tensor indexing algorithm.

[0109] In some embodiments, the selected tensor indexing algorithm assigns an integer to each tensor.

[0110] In some embodiments, the selected tensor indexing algorithm performs a loop through each tensor output by each node of the first sub-model and sequentially assigns an integer to each of the tensors.

[0111] In some embodiments, the selected tensor indexing algorithm assigns a string including at least one integer to each tensor.

[0112] In some embodiments, the selected tensor indexing algorithm assigns to each tensor a reference that includes an array or a pair of integers.

[0113] In some embodiments, a first integer in the array or pair identifies a node in the first sub-model of which the respective tensor is an output, and a second integer in the array or pair identifies the respective tensor from among all outputs of the same node.

[0114] In some embodiments, selecting the tensor indexing algorithm comprises sending to the second endpoint, or receiving from the second endpoint, a tensor name encoding algorithm identifier.

[0115] A method according to some embodiments comprises: at a second endpoint, obtaining information describing at least a second sub-model of a split-inferencing machine learning model; in communication with a first endpoint, selecting a tensor indexing algorithm; receiving at least one tensor from the first endpoint, wherein each tensor is identified by a respective reference determined according to the selected tensor indexing algorithm; and executing the second sub-model on the at least one tensor.

[0116] An apparatus according to some embodiments comprises one or more processors configured to perform at least: at a second endpoint, obtaining information describing at least a second sub-model of a split-inferencing machine learning model; in communication with a first endpoint, selecting a tensor indexing algorithm; receiving at least one tensor from the first endpoint, wherein each tensor is identified by a respective reference determined according to the selected tensor indexing algorithm; and executing the second sub-model on the at least one tensor.

[0117] Some embodiments further comprise obtaining information describing a first submodel of the split-inferencing machine learning model, wherein the reference of the at least one tensor is determined based at least in part on the information describing the first submodel.

[0118] In some embodiments, the selected tensor indexing algorithm performs a loop through each tensor output by each node of the first sub-model and sequentially assigns an integer to each of the tensors.

[0119] In some embodiments, the selected tensor indexing algorithm assigns to each tensor a reference that includes an array or a pair of integers, and wherein a first integer in the array or pair identifies a node in the first sub-model of which the respective tensor is an output, and a second integer in the array or pair identifies the respective tensor from among all tensors that are outputs of the same node.

[0120] In some embodiments, the selected tensor indexing algorithm assigns an integer to each tensor.

[0121] In some embodiments, selecting the tensor indexing algorithm comprises sending to the first endpoint, or receiving from the second endpoint, a tensor name encoding algorithm identifier.

[0122] One or more embodiments provide a computer program comprising instructions which when executed by one or more processors cause such processors to perform the encoding and / or decoding methods according to any of the embodiments described above. One or more embodiments also provide a computer readable storage medium having stored thereon instructions for encoding or decoding video data according to the methods described above.

[0123] One or more embodiments provide a computer readable storage medium having stored thereon video data generated according to the methods described above. One or more embodiments also provide a method and apparatus for transmitting or receiving video data generated according to the methods described above.

[0124] The embodiments described herein may be implemented in, for example, a method or a process, an apparatus, a software program, a data stream, or a signal. Even if only discussed in the context of a single form of implementation (e.g., as a method), the implementation of such features may also be implemented in other forms. An apparatus may be implemented in, for example, appropriate hardware, software, and firmware. Corresponding methods may be implemented in, for example, a processor.

[0125] Various numeric values are used in the present application. Such specific values are for example purposes and the embodiments described are not limited to these specific values.

[0126] Various methods are described herein, and such methods comprise one or more steps or actions for achieving the described method. Unless a specific order of steps or actions is required for the proper operation of the method, the order and / or use of specific steps and / or actions may be modified or combined. Additionally, terms such as “first”, “second”, etc. may be used in various embodiments to modify an element, component, step, operation, etc., for example, a “first decoding” and a “second decoding”. Use of such terms does not imply an order to the operations unless specifically required.

[0127] The present disclosure may refer to “determining” various pieces of information. Determining information may include one or more of, for example, estimating, calculating, predicting, or retrieving (e.g., from memory) the information.

[0128] The present disclosure may refer to “accessing” various pieces of information. Accessing information may include one or more of, for example, receiving, retrieving (e.g., from memory), storing, moving, copying, calculating, determining, predicting, or estimating the information. Similarly, the present disclosure may refer to “receiving” various pieces ofinformation. Receiving information may include one or more of, for example, accessing or retrieving (e.g., from memory) the information.

[0129] It is to be understood that use of any of the following“and / or”, and “at least one of’ is intended to encompass all possible selections of listed items, taken either individually or in any combination thereof.

[0130] While specific embodiments have been described in the foregoing description in connection with the accompanying drawings, it should be understood that embodiments described herein are examples only and should not be taken as limiting the scope of the present disclosure or the following claims. Although features and elements are described herein in particular combinations, those of ordinary skill in the art will appreciate that such features or elements may be used alone or in any combination with the other features and elements. It is understood, therefore, that the overall teachings of the present disclosure are not limited to the particular embodiments, implementations, and examples disclosed herein, but are intended to cover variations, modifications, and alternatives as defined by the appended claims and any and all equivalents thereof.

Claims

CLAIMS1. A method performed at a first endpoint computing apparatus, comprising: obtaining information describing at least a first sub-model of a split-inferencing machine learning model; in communication with a second endpoint computing apparatus, selecting a tensor indexing algorithm; executing the first sub-model to obtain at least one tensor; and sending the at least one tensor to the second endpoint computing apparatus, wherein each tensor is identified by a respective reference determined according to the selected tensor indexing algorithm.

2. A first endpoint computing apparatus comprising one or more processors configured to perform at least: obtaining information describing at least a first sub-model of a split-inferencing machine learning model; in communication with a second endpoint computing apparatus, selecting a tensor indexing algorithm; executing the first sub-model to obtain at least one tensor; and sending the at least one tensor to the second endpoint computing apparatus, wherein each tensor is identified by a respective reference determined according to the selected tensor indexing algorithm.

3. The method of claim 1 , or the apparatus of claim 2, wherein the selected tensor indexing algorithm assigns an integer to each tensor.

4. The method of claim 1 , or the apparatus of claim 2, wherein the selected tensor indexing algorithm performs a loop through each tensor output by each node of the first sub-model and sequentially assigns an integer to each of the tensors.

5. The method of claim 1 , or the apparatus of claim 2, wherein the selected tensor indexing algorithm assigns a string including at least one integer to each tensor.

6. The method of claim 1 , or the apparatus of claim 2, wherein the selected tensor indexing algorithm assigns to each tensor a reference that includes an array or a pair of integers.

7. The method of claim 6 as it depends from claim 1 , or the apparatus of claim 6 as it depends from claim 2, wherein a first integer in the array or pair identifies a node in the first sub-model of which the respective tensor is an output, and a second integer in the array or pair identifies the respective tensor from among all outputs of the same node.

8. The method of claim 1 , or claims 3-7 as they depend from claim 1 , or the apparatus of claim 2, or claims 3-7 as they depend from claim 2, wherein selecting the tensor indexing algorithm comprises sending to the second endpoint computing apparatus, or receiving from the second endpoint computing apparatus, a tensor name encoding algorithm identifier.

9. A method performed at a second endpoint computing apparatus, comprising: obtaining information describing at least a second sub-model of a split-inferencing machine learning model; in communication with a first endpoint computing apparatus, selecting a tensor indexing algorithm; receiving at least one tensor from the first endpoint computing apparatus, wherein each tensor is identified by a respective reference determined according to the selected tensor indexing algorithm; and executing the second sub-model on the at least one tensor.

10. A second endpoint computing apparatus comprising one or more processors configured to perform at least: obtaining information describing at least a second sub-model of a split-inferencing machine learning model; in communication with a first endpoint computing apparatus, selecting a tensor indexing algorithm; receiving at least one tensor from the first endpoint computing apparatus, wherein each tensor is identified by a respective reference determined according to the selected tensor indexing algorithm; and executing the second sub-model on the at least one tensor.

11. The method of claim 9, or the apparatus of claim 10, further comprising obtaining information describing a first sub-model of the split-inferencing machine learning model, wherein the reference of the at least one tensor is determined based at least in part on the information describing the first sub-model.

12. The method of claim 11 as it depends from claim 9, or the apparatus of claim 11 as it depends from claim 10, wherein the selected tensor indexing algorithm performs a loop through each tensor output by each node of the first sub-model and sequentially assigns an integer to each of the tensors.

13. The method of claim 11 as it depends from claim 9, or the apparatus of claim 11 as it depends from claim 10, wherein the selected tensor indexing algorithm assigns to each tensor a reference that includes an array or a pair of integers, and wherein a first integer in the array or pair identifies a node in the first sub-model of which the respective tensor is an output, and a second integer in the array or pair identifies the respective tensor from among all tensors that are outputs of the same node.

14. The method of claim 9, or the apparatus of claim 10, wherein the selected tensor indexing algorithm assigns an integer to each tensor.

15. The method of claim 9, or claims 11-14 as they depend from claim 9, or the apparatus of claim 10, or claims 11-14 as they depend from claim 10, wherein selecting the tensor indexing algorithm comprises sending to the first endpoint computing apparatus, or receiving from the first endpoint computing apparatus, a tensor name encoding algorithm identifier.

Images