Hướng dẫn what does uint8 mean in python? - uint8 có nghĩa là gì trong python?
def parse_data(path, dataset, flatten):
if dataset != 'train' and dataset != 't10k':
raise NameError('dataset must be train or t10k')
label_file = os.path.join(path, dataset + '-labels-idx1-ubyte')
with open(label_file, 'rb') as file:
_, num = struct.unpack(">II", file.read(8))
labels = np.fromfile(file, dtype=np.int8) # int8
new_labels = np.zeros((num, 10))
new_labels[np.arange(num), labels] = 1
img_file = os.path.join(path, dataset + '-images-idx3-ubyte')
with open(img_file, 'rb') as file:
_, num, rows, cols = struct.unpack(">IIII", file.read(16))
imgs = np.fromfile(file, dtype=np.uint8).reshape(num, rows, cols) # uint8
imgs = imgs.astype(np.float32) / 255.0
if flatten:
imgs = imgs.reshape([num, -1])
return imgs, new_labels 2 là một số nguyên 8 bit không dấu có thể biểu thị các giá trị 0..255. def parse_data(path, dataset, flatten):
if dataset != 'train' and dataset != 't10k':
raise NameError('dataset must be train or t10k')
label_file = os.path.join(path, dataset + '-labels-idx1-ubyte')
with open(label_file, 'rb') as file:
_, num = struct.unpack(">II", file.read(8))
labels = np.fromfile(file, dtype=np.int8) # int8
new_labels = np.zeros((num, 10))
new_labels[np.arange(num), labels] = 1
img_file = os.path.join(path, dataset + '-images-idx3-ubyte')
with open(img_file, 'rb') as file:
_, num, rows, cols = struct.unpack(">IIII", file.read(16))
imgs = np.fromfile(file, dtype=np.uint8).reshape(num, rows, cols) # uint8
imgs = imgs.astype(np.float32) / 255.0
if flatten:
imgs = imgs.reshape([num, -1])
return imgs, new_labels 3 Mặt khác thường là số nguyên có chữ ký 32 bit. Khi bạn tạo mảng bằng dtype = int, mỗi phần tử trong đó sẽ mất 4 byte. OpenCV rõ ràng mong đợi mảng sẽ được làm bằng các bộ dữ liệu 8 bit đại diện cho màu đỏ, xanh lá cây và xanh dương. Vì vậy, khi bạn vượt qua mảng số nguyên, bộ nhớ sẽ chứa một cái gì đó như thế này: Show
OpenCV nào diễn giải như:
Tôi đoán là những gì bạn có hình ảnh rất tối, khi kiểm tra kỹ hơn sẽ hiển thị các pixel màu đỏ, xanh lá cây và xanh lam rất mờ. Khi bạn thay đổi loại thành UINT8, mảng của bạn sẽ trông như thế này:
Sau đó được OpenCV giải thích là các giá trị RGB màu xám:
Chuyển đổi UINT8 thành gấp đôi trong Python với các ví dụ mã Trong phiên này, chúng tôi sẽ cố gắng giải quyết UINT8 để nhân đôi trong câu đố Python bằng cách sử dụng ngôn ngữ máy tính. Mã theo sau phục vụ như một minh họa của điểm này. # to create an x-bit point with numpy, use np.intx # to create an unsigned x-bit point with numpy, use np.uintx # examples: import numpy as np a = np.int16(10000) # 10000 stored as a 16-bit number (can store numbers from -32768 to 32767) b = np.uint(10000) # 10000 stored as an unsigned 16-bit number (can store numbers from 0 to 65535) Vấn đề với chuyển đổi UINT8 thành gấp đôi trong Python có thể được giải quyết theo nhiều cách khác nhau, tất cả đều được nêu trong danh sách sau đó. # to create an x-bit point with numpy, use np.intx # to create an unsigned x-bit point with numpy, use np.uintx # examples: import numpy as np a = np.float64 (0.27745873 ) # 10000 stored as a 16-bit number (can store numbers from -32768 to 32767) b = np.unit8 (a) # 10000 stored as an unsigned 16-bit number (can store numbers from 0 to 65535) Bằng cách nghiên cứu một loạt các ví dụ khác nhau, chúng tôi đã có thể tìm ra cách sửa chữa UINT8 chuyển đổi thành gấp đôi trong Python. Làm thế nào để bạn chuyển đổi một số thành một cú đúp trong Python?Sử dụng phương thức float () hoặc phương thức thập phân () để chuyển đổi chuỗi thành gấp đôi trong python. Chuyển đổi chuỗi thành Double giống như chuyển đổi chuỗi thành float.18-NOV-2021 Uint8 là gì trong Python?Uint8. Số nguyên không dấu (0 đến 255) Phạm vi của loại dữ liệu đơn vị 8 trong Numpy là gì?Numpy với Python Làm thế nào để bạn chuyển đổi float thành int in python?Giá trị phao có thể được chuyển đổi thành giá trị INT không lớn hơn đầu vào bằng cách sử dụng toán học. Hàm sàn (), trong khi nó cũng có thể được chuyển đổi thành giá trị INT là số nguyên nhỏ nhất lớn hơn đầu vào sử dụng toán học. Hàm trần (). Mô-đun toán học sẽ được nhập để sử dụng các phương pháp này.16-JUL-2022 Làm thế nào để bạn có được 2 vị trí thập phân trong Python?Sử dụng str. Định dạng () với trên {:. 2f} trực tiếp dưới dạng chuỗi và float dưới dạng một số để hiển thị 2 vị trí thập phân trong Python. Cuộc gọi in và nó sẽ hiển thị phao với 2 vị trí thập phân trong bảng điều khiển.27-OCT-2021 Làm thế nào để bạn làm tròn đến 2 chữ số thập phân ở Python?Khoa học dữ liệu thực tế sử dụng hàm vòng () của Python Python đòi hỏi hai đối số. Đầu tiên là số được làm tròn. Đối số thứ hai quyết định số lượng vị trí thập phân mà nó được làm tròn. Để làm tròn số đến 2 số thập phân, đưa ra đối số thứ hai là 2.02-mar-2020 Làm thế nào để bạn nhân đôi trong Python?Python không có loại dữ liệu kép tích hợp nhưng nó có loại float chỉ định số điểm nổi. Bạn có thể đếm gấp đôi trong Python là giá trị float được chỉ định với một điểm thập phân. Tất cả các nền tảng đại diện cho các giá trị Float Python là các giá trị chính xác kép 64 bit, theo tiêu chuẩn của IEEE 754.24-SEPT-2022 Kiểu dữ liệu UINT8 là gì?Số nguyên không dấu của 8 bit. Kiểu dữ liệu UINT8 chứa tất cả các số toàn bộ từ 0 đến 255. Như với tất cả các số không dấu, các giá trị phải không âm. Uint8 chủ yếu được sử dụng trong đồ họa (màu sắc luôn không âm). Phạm vi của Uint8 là gì?0 đến 255 thập phân Làm cách nào để thay đổi dtype trong python?Để thay đổi DTYPE của đối tượng mảng đã cho, chúng tôi sẽ sử dụng Numpy. hàm astype (). Hàm có một đối số là kiểu dữ liệu đích.23-Jun-2021 Sau đây là 30 ví dụ mã của numpy.uint8 (). Bạn có thể bỏ phiếu cho những người bạn thích hoặc bỏ phiếu cho những người bạn không thích và đi đến dự án gốc hoặc tệp nguồn bằng cách theo các liên kết trên mỗi ví dụ. Bạn cũng có thể muốn kiểm tra tất cả các chức năng/lớp có sẵn của mô -đun Numpy hoặc thử chức năng tìm kiếm.30 code examples of numpy.uint8(). You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may also want to check out all available functions/classes of the module numpy, or try the search function Ví dụ 1 def test_bitmap_mask_resize():
# resize with empty bitmap masks
raw_masks = dummy_raw_bitmap_masks((0, 28, 28))
bitmap_masks = BitmapMasks(raw_masks, 28, 28)
resized_masks = bitmap_masks.resize((56, 72))
assert len(resized_masks) == 0
assert resized_masks.height == 56
assert resized_masks.width == 72
# resize with bitmap masks contain 1 instances
raw_masks = np.diag(np.ones(4, dtype=np.uint8))[np.newaxis, ...]
bitmap_masks = BitmapMasks(raw_masks, 4, 4)
resized_masks = bitmap_masks.resize((8, 8))
assert len(resized_masks) == 1
assert resized_masks.height == 8
assert resized_masks.width == 8
truth = np.array([[[1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]])
assert (resized_masks.masks == truth).all() Ví dụ #2 def parse_data(path, dataset, flatten):
if dataset != 'train' and dataset != 't10k':
raise NameError('dataset must be train or t10k')
label_file = os.path.join(path, dataset + '-labels-idx1-ubyte')
with open(label_file, 'rb') as file:
_, num = struct.unpack(">II", file.read(8))
labels = np.fromfile(file, dtype=np.int8) # int8
new_labels = np.zeros((num, 10))
new_labels[np.arange(num), labels] = 1
img_file = os.path.join(path, dataset + '-images-idx3-ubyte')
with open(img_file, 'rb') as file:
_, num, rows, cols = struct.unpack(">IIII", file.read(16))
imgs = np.fromfile(file, dtype=np.uint8).reshape(num, rows, cols) # uint8
imgs = imgs.astype(np.float32) / 255.0
if flatten:
imgs = imgs.reshape([num, -1])
return imgs, new_labels Ví dụ #3 def show():
"""Output the contents of the buffer to Unicorn HAT HD."""
setup()
if _addressing_enabled:
for address in range(8):
display = _displays[address]
if display.enabled:
if _buffer_width == _buffer_height or _rotation in [0, 2]:
window = display.get_buffer_window(numpy.rot90(_buf, _rotation))
else:
window = display.get_buffer_window(numpy.rot90(_buf, _rotation))
_spi.xfer2([_SOF + 1 + address] + (window.reshape(768) * _brightness).astype(numpy.uint8).tolist())
time.sleep(_DELAY)
else:
_spi.xfer2([_SOF] + (numpy.rot90(_buf, _rotation).reshape(768) * _brightness).astype(numpy.uint8).tolist())
time.sleep(_DELAY) Ví dụ #4 def draw_heatmap(img, heatmap, alpha=0.5):
"""Draw a heatmap overlay over an image."""
assert len(heatmap.shape) == 2 or \
(len(heatmap.shape) == 3 and heatmap.shape[2] == 1)
assert img.dtype in [np.uint8, np.int32, np.int64]
assert heatmap.dtype in [np.float32, np.float64]
if img.shape[0:2] != heatmap.shape[0:2]:
heatmap_rs = np.clip(heatmap * 255, 0, 255).astype(np.uint8)
heatmap_rs = ia.imresize_single_image(
heatmap_rs[..., np.newaxis],
img.shape[0:2],
interpolation="nearest"
)
heatmap = np.squeeze(heatmap_rs) / 255.0
cmap = plt.get_cmap('jet')
heatmap_cmapped = cmap(heatmap)
heatmap_cmapped = np.delete(heatmap_cmapped, 3, 2)
heatmap_cmapped = heatmap_cmapped * 255
mix = (1-alpha) * img + alpha * heatmap_cmapped
mix = np.clip(mix, 0, 255).astype(np.uint8)
return mix Ví dụ #5 def wer(self, r, h):
# initialisation
d = np.zeros((len(r)+1)*(len(h)+1), dtype=np.uint8)
d = d.reshape((len(r)+1, len(h)+1))
for i in range(len(r)+1):
for j in range(len(h)+1):
if i == 0:
d[0][j] = j
elif j == 0:
d[i][0] = i
# computation
for i in range(1, len(r)+1):
for j in range(1, len(h)+1):
if r[i-1] == h[j-1]:
d[i][j] = d[i-1][j-1]
else:
substitution = d[i-1][j-1] + 1
insertion = d[i][j-1] + 1
deletion = d[i-1][j] + 1
d[i][j] = min(substitution, insertion, deletion)
return d[len(r)][len(h)] Ví dụ #6 def draw_bounding_boxes(image, gt_boxes, im_info):
num_boxes = gt_boxes.shape[0]
gt_boxes_new = gt_boxes.copy()
gt_boxes_new[:,:4] = np.round(gt_boxes_new[:,:4].copy() / im_info[2])
disp_image = Image.fromarray(np.uint8(image[0]))
for i in range(num_boxes):
this_class = int(gt_boxes_new[i, 4])
disp_image = _draw_single_box(disp_image,
gt_boxes_new[i, 0],
gt_boxes_new[i, 1],
gt_boxes_new[i, 2],
gt_boxes_new[i, 3],
'N%02d-C%02d' % (i, this_class),
FONT,
color=STANDARD_COLORS[this_class % NUM_COLORS])
image[0, :] = np.array(disp_image)
return image Ví dụ #7 def z_color(self, z):
z = float(z)
alpha = 1.0
if z <= self.mid_z:
ns = lerp(z, self.near_z, self.mid_z)
color = (1.0 - ns) * self.near_color + ns * self.mid_color
else: # z must be between self.mid_z and FAR_Z
fs = lerp(z, self.mid_z, self.far_z)
color = (1.0 - fs) * self.mid_color + fs * self.far_color
alpha = 1.0 - lerp(z, self.min_z, self.max_z)
if z <= -self.min_z:
alpha = 0.0
# gl_FragColor = vec4(color, alpha) * texture2D( texture, gl_PointCoord )
return (color * alpha).astype(np.uint8).tolist() Ví dụ #8 def add_image(self, img):
if self.print_progress and self.cur_images % self.progress_interval == 0:
print('%d / %d\r' % (self.cur_images, self.expected_images), end='', flush=True)
sys.stdout.flush()
if self.shape is None:
self.shape = img.shape
self.resolution_log2 = int(np.log2(self.shape[1]))
assert self.shape[0] in [1, 3]
assert self.shape[1] == self.shape[2]
assert self.shape[1] == 2**self.resolution_log2
tfr_opt = tf.python_io.TFRecordOptions(tf.python_io.TFRecordCompressionType.NONE)
for lod in range(self.resolution_log2 - 1):
tfr_file = self.tfr_prefix + '-r%02d.tfrecords' % (self.resolution_log2 - lod)
self.tfr_writers.append(tf.python_io.TFRecordWriter(tfr_file, tfr_opt))
assert img.shape == self.shape
for lod, tfr_writer in enumerate(self.tfr_writers):
if lod:
img = img.astype(np.float32)
img = (img[:, 0::2, 0::2] + img[:, 0::2, 1::2] + img[:, 1::2, 0::2] + img[:, 1::2, 1::2]) * 0.25
quant = np.rint(img).clip(0, 255).astype(np.uint8)
ex = tf.train.Example(features=tf.train.Features(feature={
'shape': tf.train.Feature(int64_list=tf.train.Int64List(value=quant.shape)),
'data': tf.train.Feature(bytes_list=tf.train.BytesList(value=[quant.tostring()]))}))
tfr_writer.write(ex.SerializeToString())
self.cur_images += 1 Ví dụ #9 # to create an x-bit point with numpy, use np.intx # to create an unsigned x-bit point with numpy, use np.uintx # examples: import numpy as np a = np.float64 (0.27745873 ) # 10000 stored as a 16-bit number (can store numbers from -32768 to 32767) b = np.unit8 (a) # 10000 stored as an unsigned 16-bit number (can store numbers from 0 to 65535)0 Ví dụ #10 # to create an x-bit point with numpy, use np.intx # to create an unsigned x-bit point with numpy, use np.uintx # examples: import numpy as np a = np.float64 (0.27745873 ) # 10000 stored as a 16-bit number (can store numbers from -32768 to 32767) b = np.unit8 (a) # 10000 stored as an unsigned 16-bit number (can store numbers from 0 to 65535)1 Ví dụ #11 # to create an x-bit point with numpy, use np.intx # to create an unsigned x-bit point with numpy, use np.uintx # examples: import numpy as np a = np.float64 (0.27745873 ) # 10000 stored as a 16-bit number (can store numbers from -32768 to 32767) b = np.unit8 (a) # 10000 stored as an unsigned 16-bit number (can store numbers from 0 to 65535)2 Ví dụ #12 # to create an x-bit point with numpy, use np.intx # to create an unsigned x-bit point with numpy, use np.uintx # examples: import numpy as np a = np.float64 (0.27745873 ) # 10000 stored as a 16-bit number (can store numbers from -32768 to 32767) b = np.unit8 (a) # 10000 stored as an unsigned 16-bit number (can store numbers from 0 to 65535)3 Ví dụ #13 # to create an x-bit point with numpy, use np.intx # to create an unsigned x-bit point with numpy, use np.uintx # examples: import numpy as np a = np.float64 (0.27745873 ) # 10000 stored as a 16-bit number (can store numbers from -32768 to 32767) b = np.unit8 (a) # 10000 stored as an unsigned 16-bit number (can store numbers from 0 to 65535)4 Ví dụ #14 # to create an x-bit point with numpy, use np.intx # to create an unsigned x-bit point with numpy, use np.uintx # examples: import numpy as np a = np.float64 (0.27745873 ) # 10000 stored as a 16-bit number (can store numbers from -32768 to 32767) b = np.unit8 (a) # 10000 stored as an unsigned 16-bit number (can store numbers from 0 to 65535)5 Ví dụ #15 # to create an x-bit point with numpy, use np.intx # to create an unsigned x-bit point with numpy, use np.uintx # examples: import numpy as np a = np.float64 (0.27745873 ) # 10000 stored as a 16-bit number (can store numbers from -32768 to 32767) b = np.unit8 (a) # 10000 stored as an unsigned 16-bit number (can store numbers from 0 to 65535)6 Ví dụ #16 # to create an x-bit point with numpy, use np.intx # to create an unsigned x-bit point with numpy, use np.uintx # examples: import numpy as np a = np.float64 (0.27745873 ) # 10000 stored as a 16-bit number (can store numbers from -32768 to 32767) b = np.unit8 (a) # 10000 stored as an unsigned 16-bit number (can store numbers from 0 to 65535)7 Ví dụ #17 # to create an x-bit point with numpy, use np.intx # to create an unsigned x-bit point with numpy, use np.uintx # examples: import numpy as np a = np.float64 (0.27745873 ) # 10000 stored as a 16-bit number (can store numbers from -32768 to 32767) b = np.unit8 (a) # 10000 stored as an unsigned 16-bit number (can store numbers from 0 to 65535)8 Ví dụ #18 # to create an x-bit point with numpy, use np.intx # to create an unsigned x-bit point with numpy, use np.uintx # examples: import numpy as np a = np.float64 (0.27745873 ) # 10000 stored as a 16-bit number (can store numbers from -32768 to 32767) b = np.unit8 (a) # 10000 stored as an unsigned 16-bit number (can store numbers from 0 to 65535)9 Ví dụ #19 def test_bitmap_mask_resize():
# resize with empty bitmap masks
raw_masks = dummy_raw_bitmap_masks((0, 28, 28))
bitmap_masks = BitmapMasks(raw_masks, 28, 28)
resized_masks = bitmap_masks.resize((56, 72))
assert len(resized_masks) == 0
assert resized_masks.height == 56
assert resized_masks.width == 72
# resize with bitmap masks contain 1 instances
raw_masks = np.diag(np.ones(4, dtype=np.uint8))[np.newaxis, ...]
bitmap_masks = BitmapMasks(raw_masks, 4, 4)
resized_masks = bitmap_masks.resize((8, 8))
assert len(resized_masks) == 1
assert resized_masks.height == 8
assert resized_masks.width == 8
truth = np.array([[[1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]])
assert (resized_masks.masks == truth).all() 0Ví dụ #20 def test_bitmap_mask_resize():
# resize with empty bitmap masks
raw_masks = dummy_raw_bitmap_masks((0, 28, 28))
bitmap_masks = BitmapMasks(raw_masks, 28, 28)
resized_masks = bitmap_masks.resize((56, 72))
assert len(resized_masks) == 0
assert resized_masks.height == 56
assert resized_masks.width == 72
# resize with bitmap masks contain 1 instances
raw_masks = np.diag(np.ones(4, dtype=np.uint8))[np.newaxis, ...]
bitmap_masks = BitmapMasks(raw_masks, 4, 4)
resized_masks = bitmap_masks.resize((8, 8))
assert len(resized_masks) == 1
assert resized_masks.height == 8
assert resized_masks.width == 8
truth = np.array([[[1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]])
assert (resized_masks.masks == truth).all() 1Ví dụ #21 def test_bitmap_mask_resize():
# resize with empty bitmap masks
raw_masks = dummy_raw_bitmap_masks((0, 28, 28))
bitmap_masks = BitmapMasks(raw_masks, 28, 28)
resized_masks = bitmap_masks.resize((56, 72))
assert len(resized_masks) == 0
assert resized_masks.height == 56
assert resized_masks.width == 72
# resize with bitmap masks contain 1 instances
raw_masks = np.diag(np.ones(4, dtype=np.uint8))[np.newaxis, ...]
bitmap_masks = BitmapMasks(raw_masks, 4, 4)
resized_masks = bitmap_masks.resize((8, 8))
assert len(resized_masks) == 1
assert resized_masks.height == 8
assert resized_masks.width == 8
truth = np.array([[[1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]])
assert (resized_masks.masks == truth).all() 0Ví dụ #22 def test_bitmap_mask_resize():
# resize with empty bitmap masks
raw_masks = dummy_raw_bitmap_masks((0, 28, 28))
bitmap_masks = BitmapMasks(raw_masks, 28, 28)
resized_masks = bitmap_masks.resize((56, 72))
assert len(resized_masks) == 0
assert resized_masks.height == 56
assert resized_masks.width == 72
# resize with bitmap masks contain 1 instances
raw_masks = np.diag(np.ones(4, dtype=np.uint8))[np.newaxis, ...]
bitmap_masks = BitmapMasks(raw_masks, 4, 4)
resized_masks = bitmap_masks.resize((8, 8))
assert len(resized_masks) == 1
assert resized_masks.height == 8
assert resized_masks.width == 8
truth = np.array([[[1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]])
assert (resized_masks.masks == truth).all() 3Ví dụ #23 def test_bitmap_mask_resize():
# resize with empty bitmap masks
raw_masks = dummy_raw_bitmap_masks((0, 28, 28))
bitmap_masks = BitmapMasks(raw_masks, 28, 28)
resized_masks = bitmap_masks.resize((56, 72))
assert len(resized_masks) == 0
assert resized_masks.height == 56
assert resized_masks.width == 72
# resize with bitmap masks contain 1 instances
raw_masks = np.diag(np.ones(4, dtype=np.uint8))[np.newaxis, ...]
bitmap_masks = BitmapMasks(raw_masks, 4, 4)
resized_masks = bitmap_masks.resize((8, 8))
assert len(resized_masks) == 1
assert resized_masks.height == 8
assert resized_masks.width == 8
truth = np.array([[[1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]])
assert (resized_masks.masks == truth).all() 4Ví dụ #24 def test_bitmap_mask_resize():
# resize with empty bitmap masks
raw_masks = dummy_raw_bitmap_masks((0, 28, 28))
bitmap_masks = BitmapMasks(raw_masks, 28, 28)
resized_masks = bitmap_masks.resize((56, 72))
assert len(resized_masks) == 0
assert resized_masks.height == 56
assert resized_masks.width == 72
# resize with bitmap masks contain 1 instances
raw_masks = np.diag(np.ones(4, dtype=np.uint8))[np.newaxis, ...]
bitmap_masks = BitmapMasks(raw_masks, 4, 4)
resized_masks = bitmap_masks.resize((8, 8))
assert len(resized_masks) == 1
assert resized_masks.height == 8
assert resized_masks.width == 8
truth = np.array([[[1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]])
assert (resized_masks.masks == truth).all() 5Ví dụ #25 def test_bitmap_mask_resize():
# resize with empty bitmap masks
raw_masks = dummy_raw_bitmap_masks((0, 28, 28))
bitmap_masks = BitmapMasks(raw_masks, 28, 28)
resized_masks = bitmap_masks.resize((56, 72))
assert len(resized_masks) == 0
assert resized_masks.height == 56
assert resized_masks.width == 72
# resize with bitmap masks contain 1 instances
raw_masks = np.diag(np.ones(4, dtype=np.uint8))[np.newaxis, ...]
bitmap_masks = BitmapMasks(raw_masks, 4, 4)
resized_masks = bitmap_masks.resize((8, 8))
assert len(resized_masks) == 1
assert resized_masks.height == 8
assert resized_masks.width == 8
truth = np.array([[[1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]])
assert (resized_masks.masks == truth).all() 6Ví dụ #26 def test_bitmap_mask_resize():
# resize with empty bitmap masks
raw_masks = dummy_raw_bitmap_masks((0, 28, 28))
bitmap_masks = BitmapMasks(raw_masks, 28, 28)
resized_masks = bitmap_masks.resize((56, 72))
assert len(resized_masks) == 0
assert resized_masks.height == 56
assert resized_masks.width == 72
# resize with bitmap masks contain 1 instances
raw_masks = np.diag(np.ones(4, dtype=np.uint8))[np.newaxis, ...]
bitmap_masks = BitmapMasks(raw_masks, 4, 4)
resized_masks = bitmap_masks.resize((8, 8))
assert len(resized_masks) == 1
assert resized_masks.height == 8
assert resized_masks.width == 8
truth = np.array([[[1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]])
assert (resized_masks.masks == truth).all() 7Ví dụ #27 def test_bitmap_mask_resize():
# resize with empty bitmap masks
raw_masks = dummy_raw_bitmap_masks((0, 28, 28))
bitmap_masks = BitmapMasks(raw_masks, 28, 28)
resized_masks = bitmap_masks.resize((56, 72))
assert len(resized_masks) == 0
assert resized_masks.height == 56
assert resized_masks.width == 72
# resize with bitmap masks contain 1 instances
raw_masks = np.diag(np.ones(4, dtype=np.uint8))[np.newaxis, ...]
bitmap_masks = BitmapMasks(raw_masks, 4, 4)
resized_masks = bitmap_masks.resize((8, 8))
assert len(resized_masks) == 1
assert resized_masks.height == 8
assert resized_masks.width == 8
truth = np.array([[[1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]])
assert (resized_masks.masks == truth).all() 8Ví dụ #28 def test_bitmap_mask_resize():
# resize with empty bitmap masks
raw_masks = dummy_raw_bitmap_masks((0, 28, 28))
bitmap_masks = BitmapMasks(raw_masks, 28, 28)
resized_masks = bitmap_masks.resize((56, 72))
assert len(resized_masks) == 0
assert resized_masks.height == 56
assert resized_masks.width == 72
# resize with bitmap masks contain 1 instances
raw_masks = np.diag(np.ones(4, dtype=np.uint8))[np.newaxis, ...]
bitmap_masks = BitmapMasks(raw_masks, 4, 4)
resized_masks = bitmap_masks.resize((8, 8))
assert len(resized_masks) == 1
assert resized_masks.height == 8
assert resized_masks.width == 8
truth = np.array([[[1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1]]])
assert (resized_masks.masks == truth).all() 9Ví dụ #29 def parse_data(path, dataset, flatten):
if dataset != 'train' and dataset != 't10k':
raise NameError('dataset must be train or t10k')
label_file = os.path.join(path, dataset + '-labels-idx1-ubyte')
with open(label_file, 'rb') as file:
_, num = struct.unpack(">II", file.read(8))
labels = np.fromfile(file, dtype=np.int8) # int8
new_labels = np.zeros((num, 10))
new_labels[np.arange(num), labels] = 1
img_file = os.path.join(path, dataset + '-images-idx3-ubyte')
with open(img_file, 'rb') as file:
_, num, rows, cols = struct.unpack(">IIII", file.read(16))
imgs = np.fromfile(file, dtype=np.uint8).reshape(num, rows, cols) # uint8
imgs = imgs.astype(np.float32) / 255.0
if flatten:
imgs = imgs.reshape([num, -1])
return imgs, new_labels 0Ví dụ #30 def parse_data(path, dataset, flatten):
if dataset != 'train' and dataset != 't10k':
raise NameError('dataset must be train or t10k')
label_file = os.path.join(path, dataset + '-labels-idx1-ubyte')
with open(label_file, 'rb') as file:
_, num = struct.unpack(">II", file.read(8))
labels = np.fromfile(file, dtype=np.int8) # int8
new_labels = np.zeros((num, 10))
new_labels[np.arange(num), labels] = 1
img_file = os.path.join(path, dataset + '-images-idx3-ubyte')
with open(img_file, 'rb') as file:
_, num, rows, cols = struct.unpack(">IIII", file.read(16))
imgs = np.fromfile(file, dtype=np.uint8).reshape(num, rows, cols) # uint8
imgs = imgs.astype(np.float32) / 255.0
if flatten:
imgs = imgs.reshape([num, -1])
return imgs, new_labels 1
Uint8 có nghĩa là gì?Một UINT8 là một số nguyên không dấu 8 bit (phạm vi: 0 đến 255 thập phân). Bởi vì UINT8 không được ký, bit đầu tiên của nó (bit đáng kể nhất (MSB)) không được dành riêng để ký.an 8-bit unsigned integer (range: 0 through 255 decimal). Because a UINT8 is unsigned, its first bit (Most Significant Bit (MSB)) is not reserved for signing.
NP Uint8 làm gì trong Python?Mã ký tự 'B' bí danh trên nền tảng này (Linux x86_64) Numpy.UINT8: Số nguyên không dấu 8 bit (0 đến 255).Thông thường, điều này được sử dụng cho các mảng đại diện cho hình ảnh, với 3 kênh màu có giá trị số nguyên nhỏ (0 đến 255).used for arrays representing images, with the 3 color channels having small integer values (0 to 255).
Int64 là gì trong Python?Bạn sẽ thường thấy loại dữ liệu Int64 trong Python là viết tắt của số nguyên 64 bit.64 đề cập đến bộ nhớ được phân bổ để lưu trữ dữ liệu trong mỗi ô có hiệu quả liên quan đến số lượng nó có thể lưu trữ trong mỗi ô.Phân bổ không gian trước thời hạn cho phép máy tính tối ưu hóa hiệu quả lưu trữ và xử lý.64 bit integer. The 64 refers to the memory allocated to store data in each cell which effectively relates to how many digits it can store in each “cell”. Allocating space ahead of time allows computers to optimize storage and processing efficiency.
Phạm vi của loại dữ liệu đơn vị 8 trong Numpy là gì?Vì vậy, điều tôi muốn nói là nếu bạn làm việc với một số khoảng từ 100 đến 200, bạn có thể sử dụng kiểu dữ liệu Unit8 vì nó bao gồm tất cả các số nguyên từ 0 đến 255.0 to 255. |
