blob: 312e8f35b6d0888ff3e72ebef6ee76ead1d8f88c [file] [log] [blame]
Tim Hall79d07d22020-04-27 18:20:16 +01001# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
2#
3# SPDX-License-Identifier: Apache-2.0
4#
5# Licensed under the Apache License, Version 2.0 (the License); you may
6# not use this file except in compliance with the License.
7# You may obtain a copy of the License at
8#
9# www.apache.org/licenses/LICENSE-2.0
10#
11# Unless required by applicable law or agreed to in writing, software
12# distributed under the License is distributed on an AS IS BASIS, WITHOUT
13# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14# See the License for the specific language governing permissions and
15# limitations under the License.
Tim Hall79d07d22020-04-27 18:20:16 +010016# Description:
17# Internal representation of a Neural Network Tensor.
Tim Hall79d07d22020-04-27 18:20:16 +010018import enum
Tim Hall79d07d22020-04-27 18:20:16 +010019import uuid
Diego Russoea6111a2020-04-14 18:41:58 +010020
21import numpy as np
22
23from . import numeric_util
Michael McGeagh5778ffd2020-08-06 17:31:02 +010024from .data_type import DataType
Dwight Lidmana9390f72020-05-13 12:00:08 +020025from .ethos_u55_regs.ethos_u55_regs import resampling_mode
Michael McGeagh5778ffd2020-08-06 17:31:02 +010026from .operation import Operation
Diego Russoe8a10452020-04-21 17:39:10 +010027from .range_set import MemoryRangeSet
Tim Hall79d07d22020-04-27 18:20:16 +010028
29
Patrik Gustavssoneca2e952020-05-27 09:15:11 +020030class MemType(enum.IntFlag):
31 Unknown = 0
32 Permanent_NPU = 1
33 Permanent_CPU = 2
34 Scratch = 3
35 Scratch_fast = 4
36 Size = Scratch_fast + 1
37
38 def display_name(self):
39 return ("Unknown", "Permanent_NPU", "Permanent_CPU", "Scratch", "Scratch_fast", "Size")[self.value]
40
41 def identifier_name(self):
42 return ("unknown", "permanent_npu", "permanent_cpu", "scratch", "scratch_fast", "size")[self.value]
43
44 def all():
45 return (MemType.Permanent_NPU, MemType.Permanent_CPU, MemType.Scratch, MemType.Scratch_fast)
46
47 def __str__(self):
48 return self.name
49
50
Tim Hall79d07d22020-04-27 18:20:16 +010051class MemArea(enum.IntFlag):
52 Unknown = 0
53 Sram = 1
54 Dram = 2
55 OnChipFlash = 3
56 OffChipFlash = 4
Louis Verhaard0b8268a2020-08-05 16:11:29 +020057 Shram = 5 # for LUT
58 Size = Shram + 1
Tim Hall79d07d22020-04-27 18:20:16 +010059
60 def display_name(self):
Louis Verhaard0b8268a2020-08-05 16:11:29 +020061 return ("Unknown", "SRAM", "DRAM", "On-chip Flash", "Off-chip Flash", "SHRAM", "Size")[self.value]
Tim Hall79d07d22020-04-27 18:20:16 +010062
63 def identifier_name(self):
Louis Verhaard0b8268a2020-08-05 16:11:29 +020064 return ("unknown", "sram", "dram", "on_chip_flash", "off_chip_flash", "shram", "size")[self.value]
Tim Hall79d07d22020-04-27 18:20:16 +010065
66 def all():
Louis Verhaard0b8268a2020-08-05 16:11:29 +020067 return (MemArea.Sram, MemArea.Dram, MemArea.OnChipFlash, MemArea.OffChipFlash, MemArea.Shram)
Tim Hall79d07d22020-04-27 18:20:16 +010068
69 def __str__(self):
70 return self.name
71
72
73class TensorPurpose(enum.IntFlag):
74 Unknown = 0
75 Weights = 1
76 FeatureMap = 2
77 Scratch = 3
Fredrik Svedberga0c36242020-06-03 15:43:31 +020078 LUT = 4
79 Size = 5
Tim Hall79d07d22020-04-27 18:20:16 +010080
81 def display_name(self):
Fredrik Svedberga0c36242020-06-03 15:43:31 +020082 return ("Unknown", "Weights", "FeatureMap", "Scratch", "LUT", "Size")[self.value]
Tim Hall79d07d22020-04-27 18:20:16 +010083
84 def identifier_name(self):
Fredrik Svedberga0c36242020-06-03 15:43:31 +020085 return ("unknown", "weights", "feature_map", "scratch", "lut", "size")[self.value]
Tim Hall79d07d22020-04-27 18:20:16 +010086
87 def all():
88 return (TensorPurpose.Weights, TensorPurpose.FeatureMap)
89
90
91class TensorSubPurpose(enum.Enum):
92 Standard = 0
93 DoubleBuffer = 1
94 RollingBufferX = 2
95 RollingBufferY = 3
96 RollingBufferXY = 4
97
98 def display_name(self):
99 return ("Standard", "Double Buffer", "Rolling Buffer X", "Rolling Buffer Y", "Rolling Buffer XY")[self.value]
100
101 def identifier_name(self):
102 return ("standard", "double_buffer", "rolling_buffer_x", "rolling_buffer_y", "rolling_buffer_xy")[self.value]
103
104 def all():
105 return (
106 TensorSubPurpose.Standard,
107 TensorSubPurpose.DoubleBuffer,
108 TensorSubPurpose.RollingBufferX,
109 TensorSubPurpose.RollingBufferY,
110 TensorSubPurpose.RollingBufferXY,
111 )
112
113
114class TensorFormat(enum.Flag):
115 Unknown = 0
116 WeightsCompressed = 1
117 NHWC = 2
118 NHCWB16 = 3
119
120 def __str__(self):
121 return self.name
122
123
124class TensorBlockTraversal(enum.Enum):
125 Default = 0
126 DepthWise = 1
127 DepthFirst = 2
128 PartKernelFirst = 3
129
130
131def shape_num_elements(shp):
132 elems = 1
133 if shp is None:
134 return None
135 for d in shp:
136 if d is None:
137 return None
138 elems *= d
139 return elems
140
141
142def shape_fully_defined(shp):
143 if shp is None:
144 return False
145 for d in shp:
146 if d is None:
147 return False
148 return True
149
150
151def shape_round_to_quantum(shp, quantum):
152 new_shp = list(shp)
153
154 # Traverse backwards using length of shape since there may be more rounding quantums than shape elements
155 for i in range(-1, -len(shp) - 1, -1):
156 if new_shp[i] is not None:
157 new_shp[i] = numeric_util.round_up(new_shp[i], quantum[i])
158 return new_shp
159
160
161class QuantizationParameters:
162 __slots__ = "min", "max", "num_bits", "narrow_range", "scale_f32", "zero_point", "quant_min", "quant_max"
163
164 def __init__(self, min=None, max=None, num_bits=None, narrow_range=None):
165 self.min = min
166 self.max = max
167
168 self.num_bits = num_bits
169 self.narrow_range = narrow_range
170
171 self.scale_f32 = None
172 self.zero_point = None
173 self.quant_min = None
174 self.quant_max = None
175
176 def __str__(self):
177 return "<nng.QuantizationParameters min=%s max=%s, num_bits=%s, scale=%s, zero_point=%s>" % (
178 self.min,
179 self.max,
180 self.num_bits,
181 self.scale_f32,
182 self.zero_point,
183 )
184
185 __repr__ = __str__
186
Dwight Lidmanebe26c72020-06-09 11:40:54 +0200187 def __eq__(self, other):
188 if other is None:
189 return False
190 if not isinstance(other, QuantizationParameters):
191 return False
192
193 pairs = ((getattr(self, s), getattr(other, s)) for s in QuantizationParameters.__slots__)
194
195 return all(np.array_equal(a, b) for a, b in pairs)
196
197 def __ne__(self, other):
198 return not self == other
199
Tim Hall79d07d22020-04-27 18:20:16 +0100200 def clone(self):
201 res = QuantizationParameters()
202 res.min = self.min
203 res.max = self.max
204
205 res.num_bits = self.num_bits
206 res.narrow_range = self.narrow_range
207
208 res.scale_f32 = self.scale_f32
209 res.zero_point = self.zero_point
210 res.quant_min = self.quant_min
211 res.quant_max = self.quant_max
212 return res
213
214 def dequantize(self, values):
215 if self.zero_point.size == 1 and self.scale_f32.size == 1:
216 # same scale is used for all values
217 res = (values.astype(np.float64) - self.zero_point) * self.scale_f32
218 else:
219 # a different scale is used for different sets of values
220 values_as_float = values.astype(np.float64)
221
222 # this is not compatible with the format of depthwise weights,
223 # where input is at index 3 (Output, Kh, Kw, Input)
224 # return the quantized values
225 return np.ndarray((values_as_float.shape))
226
227 shape = values_as_float.shape[0]
228 assert self.zero_point.size == self.scale_f32.size == shape
229 res = np.ndarray(values_as_float.shape)
230 for i in range(shape):
231 res[i] = (values_as_float[i] - self.zero_point[i]) * self.scale_f32[i]
232
233 return res
234
235
Michael McGeagh5778ffd2020-08-06 17:31:02 +0100236def create_const_tensor(name, shape, dtype, values, value_dtype=None, purpose=TensorPurpose.Unknown, quantization=None):
237 # Tensor
238 const_tensor = Tensor(shape, dtype, name + "_0")
239 const_tensor.purpose = purpose
240 const_tensor.quantization = quantization
241 const_tensor.values = np.array(values, dtype=value_dtype)
242 const_tensor.quant_values = np.frombuffer(const_tensor.values.tobytes(), dtype=np.uint8)
243 # Operator
244 const_op = Operation("Const", name)
245 const_op.set_output_tensor(const_tensor)
246 return const_tensor
247
248
249def create_reshape_tensor(tens, shape, ifm_reshape=True):
250 if shape == tens.shape:
251 return tens
252 # Tensors
253 name = tens.name + "_reshape"
254 reshape_ifm = tens
255 reshape_ofm = tens.clone("_reshaped")
256 reshape_ofm.set_all_shapes(shape)
257 if not ifm_reshape:
258 reshape_ifm, reshape_ofm = reshape_ofm, reshape_ifm
259 # Operator
260 reshape_op = Operation("Reshape", name)
261 reshape_op.attrs["new_shape"] = shape
262 reshape_op.add_input_tensor(reshape_ifm)
263 reshape_op.add_input_tensor(create_const_tensor(name + "_shape", [1], DataType.int32, shape))
264 reshape_op.set_output_tensor(reshape_ofm)
265 return reshape_ofm if ifm_reshape else reshape_ifm
266
267
Tim Hall79d07d22020-04-27 18:20:16 +0100268class Tensor:
269 __slots__ = (
270 "shape",
271 "storage_shape",
272 "bandwidth_shape",
273 "dtype",
274 "name",
275 "ops",
276 "consumer_list",
277 "values",
278 "quant_values",
279 "compressed_values",
Tim Hallf7e810a2020-06-25 15:04:31 +0100280 "compressed_values_substream_offsets",
Tim Hall79d07d22020-04-27 18:20:16 +0100281 "mem_area",
Patrik Gustavssoneca2e952020-05-27 09:15:11 +0200282 "mem_type",
Tim Hall79d07d22020-04-27 18:20:16 +0100283 "format",
284 "purpose",
285 "sub_purpose",
286 "alignment",
287 "weight_transpose_depthwise",
288 "storage_compression_scale",
289 "bandwidth_compression_scale",
290 "compression_scale_for_worst_weight_stream",
291 "weight_compression_scales",
292 "weight_compression_config",
293 "storage_rounding_quantum",
294 "brick_size",
295 "address",
296 "quantization",
297 "weight_compressed_offsets",
298 "element_size_bytes",
Tim Hall79d07d22020-04-27 18:20:16 +0100299 "block_traversal",
Tim Hall79d07d22020-04-27 18:20:16 +0100300 "cpu_tensor",
301 "npu_tensor",
302 "equivalence_id",
Dwight Lidmana9390f72020-05-13 12:00:08 +0200303 "resampling_mode",
Patrik Gustavsson458a2082020-08-13 13:41:05 +0200304 "avoid_NHCWB16",
Tim Hall79d07d22020-04-27 18:20:16 +0100305 )
306 AllocationQuantum = 16
307
308 def __init__(self, shape, dtype, name):
309 self.shape = shape
310 self.storage_shape = shape
311 self.bandwidth_shape = shape
312 self.dtype = dtype
313 self.name = name
314 self.equivalence_id = uuid.uuid4()
315
316 self.ops = []
317 self.consumer_list = []
318 # Below attributes are only set if a tensor has been cloned,
319 # either from Cpu -> Npu or vice versa. Needed for offline allocation
320 self.cpu_tensor = None # reference to the corresponding Cpu tensor
321 self.npu_tensor = None # reference to the corresponding Npu tensor
322
323 self.values = None
324 self.quant_values = None
325 self.compressed_values = None
Tim Hallf7e810a2020-06-25 15:04:31 +0100326 self.compressed_values_substream_offsets = None
Tim Hall79d07d22020-04-27 18:20:16 +0100327 self.mem_area = MemArea.Unknown
Patrik Gustavssoneca2e952020-05-27 09:15:11 +0200328 self.mem_type = MemType.Unknown
Tim Hall79d07d22020-04-27 18:20:16 +0100329 self.format = TensorFormat.Unknown
330 self.purpose = TensorPurpose.Unknown
331 self.sub_purpose = TensorSubPurpose.Standard
332 self.alignment = Tensor.AllocationQuantum
333 self.weight_transpose_depthwise = False
334
335 self.storage_compression_scale = 1.0
336 self.bandwidth_compression_scale = 1.0
337 self.compression_scale_for_worst_weight_stream = 1.0
338 self.weight_compression_scales = None
339 self.weight_compression_config = None
340 self.weight_compressed_offsets = []
341 self.storage_rounding_quantum = (1, 1, 1, 1)
342 self.brick_size = (1, 1, 1, 1)
Charles Xu04ce34c2020-06-23 12:42:28 +0200343 self.address = None # start address of tensor. will be filled in by tensor allocator
Tim Hall79d07d22020-04-27 18:20:16 +0100344 self.element_size_bytes = 0
345
346 # quantization parameters
347 self.quantization = None
Tim Hall79d07d22020-04-27 18:20:16 +0100348 self.block_traversal = TensorBlockTraversal.Default
Dwight Lidmana9390f72020-05-13 12:00:08 +0200349 self.resampling_mode = resampling_mode.NONE
Tim Hall79d07d22020-04-27 18:20:16 +0100350
Patrik Gustavsson458a2082020-08-13 13:41:05 +0200351 self.avoid_NHCWB16 = False
352
Tim Hall79d07d22020-04-27 18:20:16 +0100353 def element_size(self):
354 if self.element_size_bytes == 0:
355 return self.dtype.size_in_bits() / 8
356 return self.element_size_bytes
357
358 def clone(self, suffix="_clone"):
359 res = Tensor(self.shape, self.dtype, self.name + suffix)
360 res.storage_shape = list(self.storage_shape)
361 res.bandwidth_shape = list(self.bandwidth_shape)
362
363 res.ops = []
364 res.consumer_list = []
365 res.equivalence_id = self.equivalence_id
366
367 res.values = self.values
368 res.quant_values = self.quant_values
Tim Hall79d07d22020-04-27 18:20:16 +0100369 res.mem_area = self.mem_area
Patrik Gustavssoneca2e952020-05-27 09:15:11 +0200370 res.mem_type = self.mem_type
Tim Hall79d07d22020-04-27 18:20:16 +0100371 res.format = self.format
372 res.purpose = self.purpose
373 res.sub_purpose = self.sub_purpose
374 res.alignment = self.alignment
Tim Hall79d07d22020-04-27 18:20:16 +0100375 res.bandwidth_compression_scale = self.bandwidth_compression_scale
Tim Hall79d07d22020-04-27 18:20:16 +0100376 res.storage_rounding_quantum = self.storage_rounding_quantum
Charles Xu04ce34c2020-06-23 12:42:28 +0200377 res.address = None
Tim Hall79d07d22020-04-27 18:20:16 +0100378
379 if self.quantization is not None:
380 res.quantization = self.quantization.clone()
381 else:
382 res.quantization = None
383
Dwight Lidmana9390f72020-05-13 12:00:08 +0200384 res.resampling_mode = self.resampling_mode
385
Louis Verhaard3c07c972020-05-07 08:12:58 +0200386 res.copy_compressed_weight_info(self)
Patrik Gustavsson458a2082020-08-13 13:41:05 +0200387 res.avoid_NHCWB16 = self.avoid_NHCWB16
Tim Hall79d07d22020-04-27 18:20:16 +0100388 return res
389
390 def clone_into_fast_storage(self, arch):
391 res = self.clone(suffix="_fast_storage")
392 res.mem_area = arch.fast_storage_mem_area
Patrik Gustavssoneca2e952020-05-27 09:15:11 +0200393 res.mem_type = MemType.Scratch_fast
Tim Hall79d07d22020-04-27 18:20:16 +0100394 return res
395
Louis Verhaard3c07c972020-05-07 08:12:58 +0200396 def copy_compressed_weight_info(self, src_tens):
397 # Copies compressed values + all related weight compression info from the given tensor
398 self.compressed_values = src_tens.compressed_values
Tim Hallf7e810a2020-06-25 15:04:31 +0100399 self.compressed_values_substream_offsets = src_tens.compressed_values_substream_offsets
Louis Verhaard3c07c972020-05-07 08:12:58 +0200400 self.storage_shape = src_tens.storage_shape
401 self.brick_size = src_tens.brick_size
402 self.weight_compression_scales = src_tens.weight_compression_scales
403 self.weight_compressed_offsets = src_tens.weight_compressed_offsets
404 self.weight_transpose_depthwise = src_tens.weight_transpose_depthwise
405 self.compression_scale_for_worst_weight_stream = src_tens.compression_scale_for_worst_weight_stream
406 self.storage_compression_scale = src_tens.storage_compression_scale
407 self.block_traversal = src_tens.block_traversal
408 self.weight_compression_config = src_tens.weight_compression_config
409
Tim Hall79d07d22020-04-27 18:20:16 +0100410 def set_format(self, fmt, arch):
411 self.format = fmt
412 shape_len = 0
413 try:
414 shape_len = len(self.shape)
415 except TypeError:
416 pass
417
418 self.storage_rounding_quantum = arch.storage_rounding_quantums[self.format]
419 self.storage_rounding_quantum = self.storage_rounding_quantum[-shape_len:]
Tim Hall79d07d22020-04-27 18:20:16 +0100420 self.brick_size = arch.brick_sizes[self.format]
421 self.brick_size = self.brick_size[-shape_len:]
422 if self.shape is None:
423 return
424
425 self.bandwidth_shape = shape_round_to_quantum(self.shape, self.brick_size)
426 self.storage_shape = shape_round_to_quantum(self.shape, self.storage_rounding_quantum)
427
428 if fmt == TensorFormat.WeightsCompressed:
429 compression_ratio = 5 / 8
430 self.storage_compression_scale = compression_ratio
431 self.bandwidth_compression_scale = compression_ratio
432 self.compression_scale_for_worst_weight_stream = compression_ratio
433
434 def storage_elements(self):
435 elems = shape_num_elements(self.storage_shape)
436 if elems is None:
437 return 0
438 return elems
439
440 def elements(self):
441 elems = shape_num_elements(self.shape)
442 if elems is None:
443 return 0
444 return elems
445
446 def has_fully_defined_shape(self):
447 return shape_fully_defined(self.shape)
448
449 def storage_size(self):
450 raw_size = self.storage_elements() * self.element_size()
451 if raw_size == 0:
452 raw_size = 1 # force it to take up space
453 rounded_size = numeric_util.round_up(numeric_util.round_up_to_int(raw_size), self.alignment)
454 return rounded_size
455
456 def storage_size_for_sub_purpose(self, sub_purpose, param_a=None, param_b=None):
457 alt_shape = self.storage_shape_for_sub_purpose(sub_purpose, param_a, param_b)
458 elems = shape_num_elements(alt_shape)
459 if elems is None:
460 return 0
461 if sub_purpose == TensorSubPurpose.DoubleBuffer:
462 raw_size = elems * self.element_size() * self.compression_scale_for_worst_weight_stream
463 else:
464 raw_size = elems * self.element_size() * self.storage_compression_scale
465 rounded_size = numeric_util.round_up(numeric_util.round_up_to_int(raw_size), self.alignment)
466 return rounded_size
467
468 def storage_shape_for_sub_purpose(self, sub_purpose, param_a, param_b):
Tim Hall79d07d22020-04-27 18:20:16 +0100469 if sub_purpose == TensorSubPurpose.DoubleBuffer:
Jacob Bohline843d332020-06-23 12:12:56 +0200470 shp = list(self.shape)
Tim Hall79d07d22020-04-27 18:20:16 +0100471 assert len(shp) >= 2
472 shp[-1] = min(shp[-1], param_a * 2)
Tim Hall79d07d22020-04-27 18:20:16 +0100473 else:
Jacob Bohline843d332020-06-23 12:12:56 +0200474 shp = list(self.storage_shape)
475 if sub_purpose == TensorSubPurpose.RollingBufferX:
476 assert len(shp) == 4
477 shp[0] = 1
478 shp[2] = min(shp[2], param_a)
479 elif sub_purpose == TensorSubPurpose.RollingBufferY:
480 assert len(shp) == 4
481 shp[0] = 1
482 shp[1] = min(shp[1], param_a)
483 elif sub_purpose == TensorSubPurpose.RollingBufferXY:
484 assert len(shp) == 4
485 shp[0] = 1
486 shp[2] = min(shp[2], param_a)
487 shp[1] = min(shp[1], param_b)
488 elif sub_purpose == TensorSubPurpose.Standard:
489 pass
490 else:
491 assert 0, "did not expect new sub purpose %s" % (sub_purpose,)
492
Tim Hall79d07d22020-04-27 18:20:16 +0100493 return shp
494
495 def set_new_sub_purpose(self, sub_purpose, param_a=None, param_b=None):
496 self.storage_shape = self.storage_shape_for_sub_purpose(sub_purpose, param_a, param_b)
497 self.sub_purpose = sub_purpose
498 if sub_purpose == TensorSubPurpose.DoubleBuffer:
499 self.storage_compression_scale = self.compression_scale_for_worst_weight_stream
500
501 def bandwidth(self):
502 elems = shape_num_elements(self.bandwidth_shape)
503 if elems is None:
504 return 0
505 return elems * self.element_size() * self.bandwidth_compression_scale
506
507 def consumers(self):
508 return self.consumer_list
509
510 def get_address_ranges_for_coordinates(self, start_coord, end_coord):
511 if self.sub_purpose in set(
512 (TensorSubPurpose.RollingBufferX, TensorSubPurpose.RollingBufferY, TensorSubPurpose.RollingBufferXY)
513 ):
514 # build dummy coordinates that cover the entire buffer
515 start_coord = [0] * len(start_coord)
516 end_coord = [min(self.storage_shape[i], self.shape[i]) for i in range(len(end_coord))]
517
518 start = self.address_for_coordinate(start_coord, is_top_box=False)
519 end = self.address_for_coordinate(end_coord, is_top_box=True)
520 return MemoryRangeSet(self.mem_area, start, end)
521
522 def addresses_for_rolling_buffer(self, start_coord, end_coord):
523 # returns ( box_height0, box_height1, box_width, [address_tl, address_tr, address_bl, address_br] )
524
525 if len(start_coord) < 4:
526 box_height0 = 1
527 box_width = 1
528
529 if len(start_coord) >= 2:
530 box_width = end_coord[-2] - start_coord[-2]
531
532 return box_height0, box_height0, box_width, [self.address_for_coordinate(start_coord), None, None, None]
533
534 crossing_y = numeric_util.round_up(start_coord[1] + 1, self.storage_shape[1])
535 crossing_x = numeric_util.round_up(start_coord[2] + 1, self.storage_shape[2])
536
537 crossing_y = min(crossing_y, end_coord[1])
538 crossing_x = min(crossing_x, end_coord[2])
539
540 box_height0 = crossing_y - start_coord[1]
541 box_width = crossing_x - start_coord[2]
542
543 addresses = [None] * 4
544 addresses[0] = self.address_for_coordinate(start_coord)
545
546 if end_coord[2] > crossing_x:
547 addresses[1] = self.address_for_coordinate([start_coord[0], start_coord[1], crossing_x, start_coord[3]])
548 raise Exception("Striping in vertical direction is not supported")
549 if end_coord[1] > crossing_y:
550 addresses[2] = self.address_for_coordinate([start_coord[0], crossing_y, start_coord[2], start_coord[3]])
551 if end_coord[1] > crossing_y and end_coord[2] > crossing_x:
552 addresses[3] = self.address_for_coordinate([start_coord[0], crossing_y, crossing_x, start_coord[3]])
553
554 return box_height0, box_height0, box_width, addresses
555
556 def address_for_coordinate(self, coord, is_top_box=False):
557 return self.address + self.address_offset_for_coordinate(coord, is_top_box)
558
559 def get_strides_and_coord(self, coord=None):
560 if coord is None:
561 coord = [0] * len(self.storage_shape)
562
563 augmented_coord = coord
564 augmented_shape = self.storage_shape
565 while len(augmented_shape) < 4:
566 augmented_shape = [1] + augmented_shape
567
568 while len(augmented_coord) < 4:
569 augmented_coord = [0] + augmented_coord
570
571 assert len(augmented_coord) == len(augmented_shape)
572
573 if self.format == TensorFormat.NHWC:
574 augmented_shape = [augmented_shape[0], augmented_shape[3]] + augmented_shape[1:3] + [1]
575 augmented_coord = [augmented_coord[0], augmented_coord[3]] + augmented_coord[1:3] + [0]
576 stride_order = [4, 1, 3, 2, 0]
577
578 elif self.format == TensorFormat.NHCWB16:
Patrik Gustavsson2213e902020-05-05 17:49:35 +0200579 channel_divisor = 16
Tim Hall79d07d22020-04-27 18:20:16 +0100580 augmented_shape = augmented_shape[0:4] + [1]
581 augmented_coord = (
582 [augmented_coord[0], augmented_coord[3] // channel_divisor]
583 + augmented_coord[1:3]
584 + [augmented_coord[3] % channel_divisor]
585 )
586
587 if augmented_shape[1] == 0:
588 augmented_shape[1] = 1
589
590 else:
591 assert self.format in set((TensorFormat.Unknown, TensorFormat.WeightsCompressed))
592 return None, None
593
594 strides = [0] * len(augmented_shape)
595 stride = self.element_size() * self.storage_compression_scale
596
597 if self.format != TensorFormat.NHCWB16:
598 for i in stride_order:
599 strides[i] = stride
600 stride *= augmented_shape[i]
601 else:
602 assert len(strides) == 5
Tim Hall79d07d22020-04-27 18:20:16 +0100603 strides[4] = stride
Patrik Gustavsson2213e902020-05-05 17:49:35 +0200604 strides[3] = 16 * stride # STRIDE_X
Tim Hall79d07d22020-04-27 18:20:16 +0100605 strides[1] = strides[3] * augmented_shape[2] # STRIDE_C
Louis Verhaardb2fb2122020-06-04 15:51:24 +0200606 strides[2] = augmented_shape[2] * augmented_shape[3] * stride # STRIDE_Y
Tim Hall79d07d22020-04-27 18:20:16 +0100607 strides[0] = strides[2] * augmented_shape[1] # STRIDE_N
608
609 return strides, augmented_coord
610
611 def get_strides(self):
612 strides, _ = self.get_strides_and_coord()
613
614 return strides
615
Louis Verhaard3c07c972020-05-07 08:12:58 +0200616 def needs_dma(self):
617 return len(self.ops) == 1 and self.ops[0].type == "DMA"
618
619 def get_dma_src_tensor(self):
620 # For weight tensors that need DMA: returns the source tensor in Flash, else None
621 # Note: for DMA ops, Pass.weight_tensor is referring to the SRAM weight tensor
622 return self.ops[0].inputs[0] if self.needs_dma() else None
623
Louis Verhaardb2fb2122020-06-04 15:51:24 +0200624 def find_npu_op(self):
625 # Returns the NPU operator that uses this tensor, excluding DMA operators.
626 for op in self.consumers():
627 if op.type == "DMA":
628 return op.outputs[0].find_npu_op()
629 if "npu_block_type" in op.attrs:
630 return op
631 return None
632
Tim Hall79d07d22020-04-27 18:20:16 +0100633 def compressed_stream_index_from_coord(self, coord):
634 assert self.format == TensorFormat.WeightsCompressed
635 assert len(self.compressed_values) > 0
636 assert len(self.compressed_values) + 1 == len(self.weight_compressed_offsets)
637
638 depth = coord[-1]
639 brick_depth = self.brick_size[-1]
640 # Clamp position at final element index
641 if depth > self.shape[-1]:
642 depth = self.shape[-1]
643
644 # Always round up to next boundary
Michael McGeagh8d3216f2020-08-10 11:35:57 +0100645 index = numeric_util.round_up_divide(depth, brick_depth)
Tim Hall79d07d22020-04-27 18:20:16 +0100646
647 # Check boundaries on all but last weight set (which may be shorter
648 # than the brick we divided it up into)
649 if index < len(self.weight_compressed_offsets) - 1:
650 # There are no half-way points in the weights
651 if (depth % brick_depth) != 0:
652 raise Exception("Offset into weights must be aligned to a brick")
653
654 return index
655
656 def size_of_compressed_stream(self, index):
657 assert 0 <= index < len(self.compressed_values)
658 return len(self.compressed_values[index])
659
660 def is_last_index_in_compressed_stream(self, index):
661 assert 0 <= index < len(self.compressed_values)
662 return index == len(self.compressed_values) - 1
663
664 def address_offset_for_coordinate(self, orig_coord, is_top_box=False):
665 address_offset = 0
666 coord = orig_coord
667
668 coord = coord[-len(self.storage_shape) :]
669
670 if self.sub_purpose == TensorSubPurpose.Standard:
671 for idx, c in enumerate(coord):
672 if is_top_box:
673 assert c > 0 and c <= self.shape[idx]
674 else:
675 assert c >= 0 and c < self.shape[idx]
676
677 if self.format == TensorFormat.WeightsCompressed:
678 if len(self.weight_compressed_offsets) == 0:
679 return 0
680
Louis Verhaard3c07c972020-05-07 08:12:58 +0200681 if self.needs_dma() and self.sub_purpose == TensorSubPurpose.DoubleBuffer:
Tim Hall79d07d22020-04-27 18:20:16 +0100682 depth = orig_coord[-1]
683 brick_depth = self.brick_size[-1]
684 # Clamp position at final element index
685 if depth > self.shape[-1]:
686 depth = self.shape[-1]
687
688 # Always round up to next boundary
Michael McGeagh8d3216f2020-08-10 11:35:57 +0100689 index = numeric_util.round_up_divide(depth, brick_depth)
Tim Hall79d07d22020-04-27 18:20:16 +0100690 index = index % 2
691
692 if len(self.compressed_values) <= 2:
693 if is_top_box and index == 0:
694 for cv in self.compressed_values:
695 address_offset += len(cv)
696 else:
697 address_offset = index * len(self.compressed_values[0])
698 else:
699 if is_top_box and index == 0:
700 address_offset = self.storage_shape[-1]
701 else:
702 address_offset = index * (self.storage_shape[-1] // 2)
703 else:
704 index = self.compressed_stream_index_from_coord(orig_coord)
705 assert index < len(self.weight_compressed_offsets)
706 address_offset = self.weight_compressed_offsets[index]
707 else:
708 if is_top_box:
709 coord = [c - 1 for c in coord]
710
711 # handle wraparound for partial buffers. make sure to do this after subtracting top box:
712 coord = [c % self.storage_shape[idx] for idx, c in enumerate(coord)]
713
714 strides, augmented_coord = self.get_strides_and_coord(coord)
715 if strides is None:
716 return None
717
718 if is_top_box:
719 address_offset += 1 * strides[-1] # one element
720
721 address_offset += np.dot(augmented_coord, strides)
722
723 assert address_offset >= 0
724 assert address_offset <= self.storage_size()
725 return address_offset
726
Patrik Gustavssoneca2e952020-05-27 09:15:11 +0200727 def is_allocated_in_tensor_arena(self, scratch_tensor_mem_area):
728 if self.mem_area == scratch_tensor_mem_area and (self.mem_type in set((MemType.Scratch, MemType.Scratch_fast))):
729 return True
730 return False
731
Louis Verhaard0b8268a2020-08-05 16:11:29 +0200732 def equivalent(self, tens):
733 return self.equivalence_id == tens.equivalence_id
734
Michael McGeagh6a8d4242020-07-28 12:17:59 +0100735 def set_all_shapes(self, shape):
736 self.shape = shape
737 self.storage_shape = shape
738 self.bandwidth_shape = shape
739
Michael McGeagh5778ffd2020-08-06 17:31:02 +0100740 def get_full_shape(self):
741 d = len(self.shape)
742 if d in (1, 3):
Michael McGeagh8d3216f2020-08-10 11:35:57 +0100743 return numeric_util.full_shape(4, self.shape, 1)
Michael McGeagh5778ffd2020-08-06 17:31:02 +0100744 elif d == 2:
745 return [self.shape[0], 1, 1, self.shape[1]]
746 else:
747 return self.shape
748
Tim Hall79d07d22020-04-27 18:20:16 +0100749 def __str__(self):
750 return "<nng.Tensor '%s' shape=%s dtype=%s>" % (self.name, self.shape, self.dtype)
751
752 __repr__ = __str__