小编tal*_*ies的帖子

如其他帖子所指出的,NxN可以O(n^3)使用2-d kadane算法及时查找矩阵中的最大和子矩形.但是,如果矩阵稀疏,特别是O(n)非零条目,是O(n^3)时候可以打败？

如果它有帮助,对于我感兴趣的当前应用程序,只需要一个解决方案就足以在矩阵的每一行和每一列中假定最多一个非零值.然而,在我未来的应用程序中,这个假设可能不合适(只是稀疏性会持续),无论如何,我的数学直觉是可能存在简单利用稀疏性的良好解决方案,并且不会进一步利用矩阵的事实.对角线和置换矩阵的乘积.

我在Ubuntu 12.04上使用OpenCV master branch(3.0.0.dev)和CUDA,并尝试使用gpu代码编译以下opencv:

#include <iostream>
#include "opencv2/opencv.hpp"
#include "opencv2/core.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/gpu/gpu.hpp"

using namespace cv;

int main (int argc, char* argv[])
{
    try
    {
        cv::Mat src_host = cv::imread("file.png", CV_LOAD_IMAGE_GRAYSCALE);
        cv::gpu::GpuMat dst, src;
        src.upload(src_host);

        cv::gpu::threshold(src, dst, 128.0, 255.0, CV_THRESH_BINARY);

        cv::Mat result_host = dst;
        cv::imshow("Result", result_host);
        cv::waitKey();
    }
    catch(const cv::Exception& ex)
    {
        std::cout << "Error: " << ex.what() << std::endl;
    }
    return 0;
}

编译命令是:

g++ testgpu.cpp -o test `pkg-config --cflags --libs opencv` -lopencv_gpu

它有以下编译错误:

testgpu.cpp: In function ‘int main(int, …

这篇博客文章解释了内存库冲突如何破坏转置函数的性能.

现在我不禁要问:在"普通"cpu(在多线程上下文中)是否会发生同样的情况？或者这是特定于CUDA/OpenCL？或者它甚至没有出现在现代CPU中,因为它们的缓存大小相对较大？

我有一个用PyTorch编写的神经网络,它a在GPU上输出一些Tensor .我想继续a使用高效的TensorFlow层进行处理.

据我所知,唯一的方法是a从GPU内存转移到CPU内存,转换为numpy,然后将其输入TensorFlow.一个简化的例子:

import torch
import tensorflow as tf

# output of some neural network written in PyTorch
a = torch.ones((10, 10), dtype=torch.float32).cuda()

# move to CPU / pinned memory
c = a.to('cpu', non_blocking=True)

# setup TensorFlow stuff (only needs to happen once)
sess = tf.Session()
c_ph = tf.placeholder(tf.float32, shape=c.shape)
c_mean = tf.reduce_mean(c_ph)

# run TensorFlow
print(sess.run(c_mean, feed_dict={c_ph: c.numpy()}))

这可能有点牵强,但有没有一种方法可以做到这一点

1. a 永远不会留下GPU内存,或者
2. a 从GPU内存到固定内存到GPU内存.

我尝试2.在上面使用的代码中使用,non_blocking=True但我不确定它是否符合我的预期(即将其移至固定内存).

理想情况下,我的TensorFlow图将直接在PyTorch张量占用的内存上运行,但我认为这是不可能的？

我已经能够使用nvidia-smi 418.39，驱动程序版本418.39和CUDA 10.1成功设置Ubuntu 18.04服务器。

我现在有一个想要运行TensorFlow的用户，但坚持认为它与CUDA 10.1不兼容，仅与CUDA 10不兼容。我在任何可以找到的地方都没有在线确认此声明的内容，TF的任何发行补丁说明中也没有。因为设置此系统有点麻烦，所以我有点犹豫，尝试只降级一个版本。

是否有人可以验证TensorFlow 1.12是否可以与CUDA 10.1一起使用？

这是Jupyter的摘录：

在[1]：

import torch, numpy as np, datetime
cuda = torch.device('cuda')

在[2]：

ac = torch.randn(10000, 10000).to(cuda)
bc = torch.randn(10000, 10000).to(cuda)
%time cc = torch.matmul(ac, bc)
print(cc[0, 0], torch.sum(ac[0, :] * bc[:, 0]))

挂墙时间：349毫秒

张量（17.0374，device ='cuda：0'）张量（17.0376，device ='cuda：0'）

时间很短，但仍然很合理（1e12乘法的时间为0.35秒）

但是，如果我们重复同样的话：

ac = torch.randn(10000, 10000).to(cuda)
bc = torch.randn(10000, 10000).to(cuda)
%time cc = torch.matmul(ac, bc)
print(cc[0, 0], torch.sum(ac[0, :] * bc[:, 0]))

壁挂时间：999 µs

张量（-78.7172，device ='cuda：0'）张量（-78.7173，device ='cuda：0'）

1e12乘法1ms？！

为什么时间从349ms变为1ms？

信息：

• 在GeForce RTX 2070上测试；
• 可以在Google Colab上复制。

我使用 Pytorch 在 GPU 上训练网络。然而，最多 3 个 epoch 后，代码会停止并显示一条消息：

Killed

没有给出其他错误消息。我监控了内存和GPU的使用情况，运行期间仍然有空间。我查看了 /var/sys/dmesg 以找到与此相关的详细消息，但是没有输入带有“kill”的消息。可能是什么问题？

Cuda版本：9.0 Pytorch版本：1.1.0

我想在我的 win 11 机器上使用 python 本地使用 llama 2 7B。我安装了带有 cuda 和 pytorch 的 conda venv，并支持 cuda 和 python 3.10。所以我准备出发了。

这里的文件是从 meta: 文件夹 llama-2-7b-chat 本地下载的：

• 检查表.chk
• 综合.00.pth
• 参数.json

现在我想与模型进行交互。但我只找到从 Huggingface 下载模型的代码片段，这在我的情况下是不需要的。

有人可以给我提供几行代码来通过 Python 与模型交互吗？

我正在开发一个在Fermi卡上运行的CUDA 4.0应用程序.根据规范,Fermi具有Compute Capability 2.0,因此应该支持非内联函数调用.

我在一个不同的obj文件中用nvcc 4.0编译我的每个类.然后,我用g ++ - 4.4将它们全部链接起来.

请考虑以下代码:

[文件A.cuh]

#include <cuda_runtime.h>

struct A
{
    __device__ __host__ void functionA();
};

[文件B.cuh]

#include <cuda_runtime.h>

struct B
{
    __device__ __host__ void functionB();
};

[File A.cu]

#include "A.cuh"
#include "B.cuh"

void A::functionA()
{
    B b;
    b.functionB();
}

试图编译A.cu与nvcc -o A.o -c A.cu -arch=sm_20输出Error: External calls are not supported (found non-inlined call to _ZN1B9functionBEv).

我一定做错了什么,但是什么？

今天我开始使用 CUDA 和 GPU 处理。我找到了这个教程：https : //www.geeksforgeeks.org/running-python-script-on-gpu/

不幸的是，我第一次尝试运行 GPU 代码失败了：

from numba import jit, cuda 
import numpy as np 
# to measure exec time 
from timeit import default_timer as timer 

# normal function to run on cpu 
def func(a):                                 
    for i in range(10000000): 
        a[i]+= 1    

# function optimized to run on gpu 
@jit(target ="cuda")                         
def func2(a): 
    for i in range(10000000): 
        a[i]+= 1
if __name__=="__main__": 
    n = 10000000                            
    a = np.ones(n, dtype = np.float64) 
    b = np.ones(n, dtype = np.float32) …