Numpy切片数组内存消耗
Numpy是一个用于科学计算的Python库，它提供了高效的多维数组对象和各种用于操作数组的函数。在Numpy中，切片是一种常用的操作，它允许我们从数组中选择特定的元素子集。
在Numpy中，切片操作并不会创建新的数组，而是返回原始数组的一个视图。这意味着切片操作不会占用额外的内存空间，因为它们与原始数组共享相同的数据存储区域。因此，切片数组的内存消耗非常小。
切片数组的内存消耗主要取决于以下几个因素：
- 数组的大小：切片操作涉及的元素数量越多，内存消耗就越大。
- 数据类型：不同的数据类型在内存中占用的空间不同。例如，一个包含64位浮点数的数组比一个包含32位整数的数组占用的内存更多。
- 切片操作的方式：不同的切片操作可能会导致不同的内存消耗。例如，基于步长的切片操作可能会创建一个新的数组，而不是返回一个视图。
总的来说，Numpy切片数组的内存消耗通常是非常小的，因为它们只是返回原始数组的一个视图，而不是创建新的数组。这使得Numpy成为处理大规模数据集和进行高性能科学计算的理想选择。
腾讯云提供了一系列与Numpy相关的产品和服务，例如云服务器、云数据库、云存储等，可以满足不同用户的需求。具体产品和服务的介绍可以参考腾讯云官方网站：https://cloud.tencent.com/
相关·内容
我很难理解代码中的内存泄漏。我想我的错误与numpy数组是可变的有关，因为它可以使用.copy()解决。
但我不明白为什么会这样。下面是内存泄漏的代码的一个最小示例，该代码在内存中使用大约1600 is：
import numpy as np
import sys
k_neighbours = 5
np.random.seed(42)
data = np.random.rand(10000)
for _ in range(3):
closest_neighbours = [
# get indices of k closest neighbours
浏览 1提问于2020-02-06得票数 2
回答已采纳
2回答
我有一个Cython函数，它接受整数的2d nd.array (numpy数组)，并返回长度与输入2d数组相同的一维numpy数组。
import numpy as np
cimport numpy as np
np.import_array()
cimport cython
def func(np.ndarray[np.float_t, dim=2] input_arr):
cdef np.ndarray[np.float_t, ndim=1] new_arr = ...
# do stuff
return new_arr
在程序的另一个循环中，我想调用func，但是传递
浏览 2提问于2014-02-24得票数 2
回答已采纳
1回答
我有过 int[,,,] arr = new int[5, 6, 7, 8]; // c#
arr = np.zeros((5, 6, 7, 8)) # Python 具有5 * 6 * 7 * 8单元的4d阵列。 我想把它切成c#，就像numpy那样 var mySlice = arr[2:4, 0, :2, :]; // Won't work in C#, but looking for a way to do this. return type should be int[,,] A 3d array with 2 * 1 * 2 * 8 cells.
my_slice = a
浏览 34提问于2020-07-09得票数 0
1回答
为什么numpy.array在切片时的行为与Python的列表和默认数组不同？请考虑以下例子：
1)使用list :语句b = a[1:3]创建一个新的list对象，而修改b不修改a。
>>> a = [1,2,3,4]
>>> b = a[1:3]
>>> print(b)
[2, 3]
>>> b[0] = -17
>>> print(b)
[-17, 3]
>>> print(a)
[1, 2, 3, 4]
2)使用array.array：语句b = a[1:3]再次创建一个新的数
浏览 3提问于2017-06-28得票数 0
回答已采纳
下面的代码填满了我所有的内存：
from sys import getsizeof
import numpy
# from http://stackoverflow.com/a/2117379/272471
def getSize(array):
return getsizeof(array) + len(array) * getsizeof(array[0])
class test():
def __init__(self):
pass
def t(self):
temp = numpy.zeros([200,100,100])
浏览 3提问于2013-06-13得票数 2
回答已采纳
1回答
嗯，我是python的新手，最近我开始做一些简单的介绍。从numpy和list的比较开始，numpy占用的内存空间更少。但是，在我尝试了那些无所事事的外壳之后，我感到困惑。以下是我所做的
list1=[1,2,3]
sys.getsizeof(list1)
48
a=np.array([1,2,3])
sys.getsizeof(a)
60
为什么我创建的numpy数组比list对象占用更大的空间？
浏览 1提问于2018-09-10得票数 2
回答已采纳
我有一个大的多维矩阵，其中一个指数实际上包含一个数字的实部和虚部。
下面是我想优化的代码：
import numpy as np
big_matrix = np.random.random((8,160,23,3,23,80)) # 1240M
tmp1 = np.zeros((8,80,23,3,23,80)) # 620M
tmp2 = np.zeros((8,80,23,3,23,80)) # 620M
for ii in np.arange(80):
tmp1[:,ii,:,:,:,:] = big_matrix[:,2*ii,:,:,:,:]
tmp2[:,ii,:,:
浏览 5提问于2014-10-06得票数 1
回答已采纳
一个扁平的numpy一维阵列的大小(nbytes)是否可能为16568 (~16.5kb)，但当保存到磁盘时，其大小为>2 mbs？
我使用numpy的numpy.save方法保存数组。数组的D类型是'O' (或object)。
此外，如何将平面数组保存到磁盘，以便在磁盘上保存时获得与nbytes相似的大小？谢谢
浏览 0提问于2018-09-03得票数 0
1回答
考虑以下代码：
a = numpy.array([1,2,3,4])
b = numpy.array([5,6,7,8])
# here a new array (b*2) will be created and name 'a' will be assigned to it
a = b * 2
因此，numpy可以直接将b*2的结果写入已分配给a的内存，而无需分配新的数组吗？
浏览 2提问于2015-08-01得票数 3
回答已采纳
range()的这种实现非常快：
RANGE = []; for (var i=0; i<65536; ++i) RANGE.push(i-32768);
range = function(a,b){ return RANGE.slice(a+32768,b+32768); };
使用这种方法有什么坏处吗？
浏览 0提问于2012-11-23得票数 0
1回答
我在cython中创建了一个输入内存视图，并希望将其乘以一个标量：
import numpy as np
import math
cimport numpy as np
def foo():
N = 10
cdef np.double_t [:, :] A = np.ones(shape=(N,N),dtype=np.double_)
cdef int i,j
cdef double pi = math.pi
for i in range(N):
for j in range(N):
A[i,j] *= pi
浏览 3提问于2021-02-09得票数 2
回答已采纳
我使用ray.put(large_2d_array)存储一个大的numpy 2D布尔数组，然后在工作过程中，我从这个共享的numpy数组中获取一个列，并将它传递给cython函数，然后通过cdef cnp.npy_bool view = &sliced_array[0]创建一个平面缓冲区视图。使用此视图，我可以修改基础缓冲区(将一些索引设置为True)。
由于等离子存储对象是不可变的，因此我可能面临哪些未知的问题？
如果有人能对此有所了解，我会很高兴的。
代码模板：
import numpy as np
# ray init code
......
large_2d_array =
浏览 2提问于2021-04-26得票数 0
我有一个NumPy数组，我们称它为A。我不清楚以下代码的行为：
b = A[3,:];
A[3,:] = 0;
第三行必须保存在b中，但令人惊讶的是，b也变成了零！
有什么帮助吗？
浏览 0提问于2012-11-28得票数 4
回答已采纳
1回答
下面是一些代码，您可以准确地再现问题。本质上，这将使你的内存从90 so左右爆炸到超过5GB，如果你不灭它的话。随着内存消耗的增加，CPU也将受到限制。
在排序函数退出后，内存也将保持不变。
我似乎只有当我从一个大主数据开始，切片，然后进行排序时，才会发现这个问题。如果我构建了一堆独立的数据文件，这是不可能的。
def test_sorting(df_list):
counter = 0
total = len(df_list)
for i in range(0,total):
df_list[i].sort_index(inplace=True
浏览 0提问于2018-08-29得票数 1
回答已采纳
我有一个包含2940个元素的列表-每个元素都是一个(60,2094) numpy数组。
print('DataX:')
print('len:')
print(len(dataX))
print('shape:')
for i in range(5):
print(dataX[i].shape)
print('dtype:')
print(dataX[0].dtype)
print('size',sys.getsizeof(dataX)/1000000)
在以下方面的成果：
DataX:
len:
294
浏览 0提问于2018-02-11得票数 2
我被Python中复制Numpy数组的方式弄糊涂了。我从以下几点开始：
import numpy as np
p = np.array([1.0, 0.0, 1.0, 0.3])
然后，我尝试使用以下三种方法“复制”p：
q = p
q1 = p[:]
q2 = p.copy()
现在我执行q1[2] = 0.2，然后检查q、q1和q2的值。我惊讶地发现p、q和q1都更改为array([1.0, 0.0, 0.2, 0.3])，而只有q2保持不变。我还使用id()检查了所有四个变量(p、q、q1、q2)的地址，并确认了id(p) = id(q)，但id(q1) != id(p)。
我的问题是，
浏览 1提问于2020-03-26得票数 8
1回答
我确信这是一个复制品，但我真的在别处找不到答案。
我的主要问题是，我在代码中使用numpy boolean索引，并且正在对其进行优化。
我做了一些类似的事情：
y_ind = ~isnan(y)
otheThing = y[t,y_ind[t,:]]
我将这个切片保存在otherThing中的原因是，我使用它进行了多次计算，这样就避免了每次都重新切片。
我的解决方案是在y和otherThing中使用内存视图而不是np.ndarray。
问题是boolean索引在cython中不起作用，所以我尝试用一个整数列表对其进行切片。就像我们在numpy中所做的那样，例如：
x = np.random.r
浏览 3提问于2017-08-29得票数 0
回答已采纳
1回答
写入共享内存制作副本？
、、、、
我正在尝试并行化一个程序，该程序使用共享内存通过网络读取分块的numpy数组。它似乎起作用了(我的数据从另一边出来)，但是我的所有子进程的内存正在膨胀到大约共享内存的大小(每个进程大约100-250MB)，当我写它的时候就会发生这种情况。有什么方法可以避免创建这些副本吗？它们似乎是不必要的，因为数据会传播回实际的共享内存阵列。
下面是我如何使用posix_ipc、mmap和numpy (Np)设置我的数组：
shared = posix_ipc.SharedMemory(vol.uuid, flags=O_CREAT, size=int(nbytes))
array_like = mmap.m
浏览 10提问于2018-02-24得票数 0
回答已采纳
与使用list (或更高维度的list of list等)相比，使用dtype='o'将Python对象存储在list中的优缺点是什么？
在这种情况下，numpy数组是否更有效？(它们似乎无法避免间接性，但在多维情况下可能更有效。)
浏览 1提问于2013-04-11得票数 18
回答已采纳
3回答
我有点困惑：
据我所知，h5py的.value方法读取整个数据集并将其转储到数组中，这既缓慢又不鼓励(通常应该由[()]代替。正确的方法是使用粗制滥造的切片。
但是，我得到了令人恼火的结果(使用h5py 2.2.1)：
import h5py
import numpy as np
>>> file = h5py.File("test.hdf5",'w')
# Just fill a test file with a numpy array test dataset
>>> file["test"] = np.a
浏览 4提问于2014-02-13得票数 18
回答已采纳
我有一些图像以numpy数组的形式存储在80个块中。 trainImages.shape
# (715, 80, 96, 96, 3) 例如，trainImages有715个块，每个块有80个大小的图像(96,96,3)。 这个数组是dtype=float32的，所以它占用了内存中相当多的空间，大约6 6GB。 我用这段代码打乱了方块 shuffler = np.random.permutation(trainImages.shape[0])
trainImages = trainImages[shuffler] 我注意到RAM使用率下降到几乎为0。形状仍然是一样的，我可以显示图像。所有的数
浏览 19提问于2021-01-30得票数 0
1回答
为了我的研究，我正在处理由复杂数据组成的大型numpy数组。
arr = np.empty((15000, 25400), dtype='complex128')
np.save('array.npy'), arr)
当存储时，它们每个大约是3GB。加载这些数组是一个耗时的过程，这让我想知道是否有方法加快这个过程。
我正在考虑的事情之一是将数组分割成复杂而真实的部分：
arr_real = arr.real
arr_im = arr.imag
并分别保存每一部分。然而，这似乎并没有显著提高处理速度。有一些关于使用大型数组的文档，但我还没有找到关于处理复杂数据的
浏览 2提问于2017-05-17得票数 0
回答已采纳
1回答
我的清单：
a=[1,2,3,4,5]
b=a[:]
id(a)
>>2181314756864
id(b)
>>2181314855232 (different as slicing creates a new object)
id(a[0])
>>140734633334432
id(b[0])
>>140734633334432 (same)
b[0]=-1
b
>>[-1,2,3,4,5]
a
>>[1,2,3,4,5] --perfectly fine
但是在numpy的情况下：
import
浏览 0提问于2021-05-17得票数 0
我必须处理大型的3D数据立方体。我想将它们存储在HDF5文件中(使用h5py或pytables)。我通常只想对这些立方体的一部分进行分析。此部分太大，无法保存在内存中。我希望对我感兴趣的切片有一个numpy样式的视图，而不是将数据复制到内存中(类似于您可以使用numpy memmap所做的操作)。这个是可能的吗？据我所知，使用h5py执行切片时，会在内存中得到一个numpy数组。
有人问我为什么要这样做，因为数据无论如何都要进入内存。出于需要，我的代码已经对这些立方体中的数据进行了分段运行，一次将一小部分数据拖入内存。如果这些函数只是简单地迭代传递给它们的整个数据集，那么它们是最简单的。如果我
浏览 1提问于2015-01-07得票数 10
1回答
我需要读取存储在内存映射文件中的巨大numpy数组的一部分，处理数据并对数组的另一部分重复。整个numpy数组大约占用50 GB，而我的机器有8 GB的RAM。
我最初使用numpy.memmap创建内存映射文件，方法是读取大量较小的文件并处理它们的数据，然后将处理后的数据写入内存映射文件。在创建memmap文件的过程中，我没有遇到内存问题(我定期使用memmap.flush() )。下面是我创建内存映射文件的方法：
mmapData = np.memmap(mmapFile,mode='w+', shape=(large_no1,large_no2))
for i1 in n
浏览 3提问于2014-10-05得票数 6
3回答
我有一个很大的文件，第一行是一个字符串，其他行代表整数。列数是可变的，取决于一行。A有一个全局列表，其中保存了我的中间结果。arr_of_arr是一个浮点数列表。arr_of_arr的长度约为5000。这个数组的每个元素(也是一个数组)的长度从100.000到10.000.000。元素的最大长度可能会有所不同，因此我不能在创建arr_of_arr时提前扩展每个元素。
在我处理完整个文件之后，我人为地添加了计算每个全局数组和绘图元素的平均值。max_size_arr是数组中最长元素的长度(当我迭代文件中的各行时，我会竞争它)
arr = [x+[0]*(max_size_arr - len(x)
浏览 1提问于2015-12-14得票数 3
似乎有两种方法可以尝试通过片(fn a)或直接(fn b)将向量转换为数组：
use std::array::TryFromSliceError;
use std::convert::TryInto;
type Input = Vec<u8>;
type Output = [u8; 1000];
// Rust 1.47
pub fn a(vec: Input) -> Result<Output, TryFromSliceError> {
vec.as_slice().try_into()
}
// Rust 1.48
pub fn b(vec: I
浏览 0提问于2020-12-09得票数 5
回答已采纳
2回答
使用Cython，我尝试这样做：
cpdef myFun(double[:] array):
cdef int[:] sortIndices = np.argsort(array, kind='mergesort')
array = array[sortIndices]
编译器抱怨：
指定内存视图的无效索引，输入int
如何使用某种整数数组索引这个内存视图？只允许切片吗？我可以很容易地使用基于“数组”的索引和旧的NumPy数组缓冲区支持。(我只是修改了我的代码，以便使用内存视图来查看它是否会提高性能，但它实际上破坏了.)
浏览 0提问于2018-12-18得票数 3
2回答
假设我有一个包含10个元素的列表a
a = [1,2,3,4,5,6,7,8,9,0]
我只想取N元素的平均值，比如4，也就是说，average of [1,2,3,4]如何使用Numpy来实现这一点？
通常，我可以迭代一个列表，但这将花费我不想使用invest的额外列表。
文档没有给我提供任何东西。
浏览 2提问于2013-11-20得票数 2
回答已采纳
1回答
我正在尝试从由Numpy数组表示的图像中删除行或列。我的图像是uint16类型和2560x2176。例如，假设我想删除前16列，将其设置为2560 x 2160。
我是一个MATLAB-to-Numpy的转换程序，在MATLAB中我会使用这样的东西：
A = rand(2560, 2196);
A(:, 1:16) = [];
据我所知，这会删除适当的列，并且不会复制到新的数组中，从而节省了大量时间。
对于Numpy，之前的帖子使用了numpy.delete等命令。但是，文档清楚地表明这将返回一个副本，因此我必须将该副本重新分配给A。这似乎会浪费大量的复制时间。
import numpy as
浏览 1提问于2012-12-29得票数 2
回答已采纳
我想知道在分割Python数组时逗号的用途是什么-我有一个看起来可以工作的示例，但对我来说看起来奇怪的代码行是
p = 20*numpy.log10(numpy.abs(numpy.fft.rfft(data[:2048, 0])))
现在，我知道在对数组进行切片时，第一个数字是start，下一个是end，最后一个是step，但是end数字后面的逗号表示什么？谢谢。
浏览 40提问于2012-04-02得票数 62
3回答
如果我有一个有一个无用列的非常大的numpy数组，我如何才能在不创建原始数组副本的情况下删除它呢？
np.delete(my_np_array, 0, 1)
上述代码将返回数组的副本，而不带第零列.但是，我想简单地从my_np_array中删除该列，因为我不需要它。对于非常大的数据集，内存管理变得非常重要，复制可能不是一种选择。
浏览 17提问于2013-12-14得票数 8
回答已采纳
可以使用整数或布尔索引对numpy数组进行部分分配，如下所示：
import numpy as np
x = np.arange(5)
x[[2,4]]=0
x
## array([0., 0., 1., 0., 1.])
x[[True]*2+[False]*3]=2
x
## array([2., 2., 1., 0., 1.])
然而，即使x[[2,4]]在此上下文中处于lvalue中，也不能将lvalue赋值给另一个变量，因为在这种情况下，赋值是由__setitem__完成的，而__getitem__在传递整数或布尔列表时会创建一个副本：
x = np.arange(5)
y = x[
浏览 1提问于2019-10-18得票数 7
回答已采纳
请参阅以下处决-
import sys
_list = [2,55,87]
print(f'1 - Memory used by Python List - {sys.getsizeof(_list)}')
narray = np.array([2,55,87])
size = narray.size * narray.itemsize
print(f'2 - Memory usage of np array using itemsize - {size}')
print(f'3 - Memory usage of np array u
浏览 16提问于2021-11-27得票数 8
回答已采纳
6回答
为什么这不管用？
package main
import "fmt"
type name struct {
X string
}
func main() {
var a [3]name
a[0] = name{"Abbed"}
a[1] = name{"Ahmad"}
a[2] = name{"Ghassan"}
nameReader(a)
}
func nameReader(array []name) {
for i := 0; i < len(array
浏览 10提问于2014-02-12得票数 61
回答已采纳
1回答
我刚刚开始学习Rust，并将这个工作的MergeSort实现组装在一起。想知道我忽略了什么以及我能改进什么。
我想不出一个更干净的方法来处理迭代器返回的Option类型，只需要检查值不是None，然后对结果进行.unwrap()，但我真的很希望得到任何建议。
包括工作测试用例。如果有我漏掉的案子告诉我。
pub fn merge_sort(mut input: Vec<usize>) -> Vec<usize> {
let length = input.len();
// Base case
if length < 2 {
浏览 0提问于2018-03-11得票数 7
回答已采纳
1回答
我使用numpy.mgrid生成“坐标索引数组”
y, x = np.mgrid[0:3, 0:2]
print x
array([[0, 1],
[0, 1],
[0, 1]])
在许多情况下，我会对这些数组(例如x[0, :])进行切片，并丢弃其余的数据。有时，这些切片比原始数组小得多，而原始数组的计算成本很高(即np.mgrid[0:512, 0:512, 0:512])。numpy是否提供了一个与不生成大型中间数组的[coord[view] for coord in np.mgrid[0:512, 0:512, 0:512]等价的值？
我意识到这个解决方案对
浏览 3提问于2012-08-20得票数 5
回答已采纳
1回答
读取大型.h5文件时内存错误
、、、、
我已经从numpy数组创建了一个.h5。
h5f = h5py.File('/data/debo/jetAnomaly/AtlasData/dijets/mergedRoot/miniTrees/JZ3W.h5', 'w')
h5f.create_dataset('JZ3WPpxpypz', data=all, compression="gzip")
HDF5数据集"JZ3WPpxpypz"：shape (19494500,376)，键入"f8“
但是，当我将.h5文件读取到numpy数组时，我得到了一个内
浏览 1提问于2019-11-24得票数 1
回答已采纳
下面生成一个C连续的numpy数组：
import numpy
a = numpy.ones((1024,1024,5))
现在，如果我对它进行切片，结果可能不再相同。例如：
bn = a[:, :, n]
n从0到4。我的问题是我需要bn是C连续的，并且我需要对a的许多实例执行此操作。我只需要每个bn一次，并且希望避免这样做
bn = bn.copy(order='C')
我也不想重写我的代码
a = numpy.ones((5,1024,1024))
有没有比复制更快、更便宜的方式获得bn？
背景：
我想要对每个a的每个片段进行散列，使用
import hashlib
浏览 2提问于2015-04-29得票数 20
回答已采纳
2回答
在我的应用程序中，生成了100个numpy数组(每个1000个复杂元素)，并填充了数据。然后经过多次迭代，数组元素被一次又一次地修改。在初始生成之后，系统监视器报告大约50 Mb的RAM使用率。虽然我没有生成任何新的数组，但每次迭代占用的空间都在以大约40Mb的速度增长。
我学到了，垃圾收集器不处理numpy数组。因此，我假设我生成的一些用于操作数据的临时数组没有正确收集。
不幸的是，说guppy.hpy().heap()并不能帮助分析numpy。
我如何识别问题的根源，并在理想情况下使消耗在任意次数的迭代中保持恒定？
我怀疑我在分配中描述的数组元素时可能会生成副本，然后这些数组元素就不会被垃
浏览 2提问于2012-09-14得票数 8
回答已采纳
当使用rasterio时，我可以通过以下任何一种方法获得光栅的单个波段：
import rasterio
import numpy as np
dataset = rasterio.open('filepath')
# note that if you have the full dataset read in with image = dataset.read() you can do:
image = dataset.read()
print(image.shape)
red_band = image[2, :, :] # this
print(red_band.sh
浏览 0提问于2018-12-27得票数 1
回答已采纳
我有像[1, -13, 9, 6, -21, 125]这样的数字片段。我想找到小于零的元素，然后删除它们。
这可以通过简单的方式来完成:只需迭代通过切片，如果元素小于零->，则删除它。但它的计算代价很高，因为每一步都可能改变切片。
有没有像numpy.where(array, condition)和numpy.delete这样优雅的方式
浏览 0提问于2018-01-06得票数 3
回答已采纳
2回答
在分配给Python中的一个片段之前，迭代器被消耗了吗？所谓“在分配之前使用”，我的意思是在片分配发生之前，在内存中同时创建元素(放入列表或元组)。另一种方法是将迭代器中的元素一个接一个地放入片中，这样元素就不会同时在内存中创建。
例如，让我们考虑以下代码：
from itertools import islice
from heapq import merge
c = [0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5] + list(range(10))
lo, mid, hi = 0, 10, 20
c[lo:hi] = merge(is
浏览 1提问于2018-11-13得票数 5
回答已采纳
我想对一个NumPy n×n数组进行切片。我想提取该数组的m行和m列的任意选择(即没有任何行数/列数模式)，使其成为一个新的mxm数组。在本例中，假设数组为4x4，我想从中提取一个2x2数组。
下面是我们的数组：
from numpy import *
x = range(16)
x = reshape(x,(4,4))
print x
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
要删除的行和列是相同的。最简单的情况是，当我想提取一个位于开头或结尾的2x2子矩阵时，即：
In [33]: x[0:2,0:2]
Ou
浏览 134提问于2010-11-23得票数 181
回答已采纳
我有三个Python列表：x = [x0, x1, x2, ..., xn]，y = [y0, y1, y2, ..., yn]和v = [v0, v1, v2, ..., vn]，我需要做的是通过创建一个热图来可视化数据，其中在坐标(x[k], y[k])处，值v[k]是可视化的，结果可能类似于中的结果。由于系统限制，我无法使用除numpy和matplotlib之外的其他第三方工具。
我找到了一些相关的主题(，)，但似乎没有解决相同的问题。
浏览 1提问于2016-06-15得票数 0
我的代码涉及到将432x432x400数组切成1,000万次，以生成用于神经网络训练的批量数据。由于这些是相当大的数组(9200万个数据点/300 on )，我希望使用CuPy (甚至可能通过在同一个GPU上生成数据来加速训练)，但发现它实际上使代码慢了5倍。
这是由于CuPy间接费用引起的预期行为，还是我遗漏了什么？
代码复制：
import cupy as cp
import numpy as np
import timeit
cp_arr = cp.zeros((432, 432, 400), dtype=cp.float32)
np_arr = np.zeros((432, 432,
浏览 4提问于2020-03-31得票数 1
我有一个python列表，每个元素都是一个2dNumpy数组，大小为(20, 22)。我需要将列表转换为numpy数组，但是执行np.array(my_list)实际上就是在消耗内存，np.asarray(my_list)也是如此。 这个列表大约有7M个样本，我在想，与其把我的列表转换成numpy数组，不如先从numpy数组开始，然后继续追加另一个2d numpy数组。 我找不到一种使用numpy的方法，我的目标是从这样的东西开始： numpy_array = np.array([])
df_values = df.to_numpy() # faster than df.values
fo
浏览 32提问于2021-10-04得票数 0
回答已采纳
1回答
我想将numpy数组转换为python2.7中的字节串。假设我的numpy数组a是一个简单的2x2数组，如下所示：
[[1,10],
[16,255]]
我的问题是，如何将该数组转换为字节字符串或字节数组，输出如下所示：
\x01\x0A\x10\xff
或者同样好：
bytearray(b'\x01\x0A\x10\xff')
浏览 2提问于2015-10-14得票数 1
回答已采纳
2回答
我用python列表编写了以下代码
# python lists
vc = [1,2,3,4]
print('original array')
print(hex(id(vc)))
print([hex(id(vc[i])) for i in range(len(vc))])
print(vc)
# --
g = vc[1:3]
print('array slice')
print(hex(id(g)))
print([hex(id(g[i])) for i in range(len(g))])
print(g)
# --
g[:] = [-1,-2]
prin
浏览 0提问于2019-09-14得票数 0
回答已采纳
1回答
卷积中心差分
、、、
所以基本上我试着在二维数组上做有限差分，而不是做太多的for循环。我想要得到数组的Hessian矩阵和梯度。所以我需要数组的一阶和二阶导数。 这可以通过对数组上的以下方程求值来实现。 ? 为了处理边界，我们只计算内点的边界，因此这个派生函数的代码可能如下所示 arr = np.random.rand(16).reshape(4,4)
result = np.zeros_like(arr)
w, h = arr.shape
for i in range(1, w-1):
for j in range(1, h-1):
result[i,j] = (arr[i+1,
浏览 14提问于2020-04-29得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
