在装有 NVidia GeForce 820M 的 Windows 10 PC 上，我成功安装了 CUDA 9.2 和 cudnn 7.1，然后使用 pytorch.org 上的说明安装了 PyTorch。

具体我使用了命令

pip install torch==1.4.0+cu92 torchvision==0.5.0+cu92 -f https://download.pytorch.org/whl/torch_stable.html

因为我使用 pip 而不是 Anaconda。

但我得到以下

>>> import torch
>>> torch.cuda.is_available()
False

为什么会这样？

该代码的构建如下：我的机器人拍摄一张照片，一些 tf 计算机视觉模型计算目标对象在图片中的起始位置。该信息（x1 和 x2 坐标）被传递到 pytorch 模型。它应该学会预测正确的运动激活，以便更接近目标。执行运动后，机器人再次拍照，tf cv 模型应计算电机激活是否使机器人更接近所需状态（x1 为 10，x2 坐标为 at31）

然而，每次我运行代码时，pytorch 都无法计算梯度。

我想知道这是否是某种数据类型问题，或者是否是一个更普遍的问题：如果不直接从 pytorch 网络的输出计算损失，是否无法计算梯度？

任何帮助和建议将不胜感激。

#define policy model (model to learn a policy for my robot)
import torch
import torch.nn as nn
import torch.nn.functional as F 
class policy_gradient_model(nn.Module):
    def __init__(self):
        super(policy_gradient_model, self).__init__()
        self.fc0 = nn.Linear(2, 2)
        self.fc1 = nn.Linear(2, 32)
        self.fc2 = nn.Linear(32, 64)
        self.fc3 = nn.Linear(64,32)
        self.fc4 = nn.Linear(32,32)
        self.fc5 = nn.Linear(32, 2)
    def forward(self,x):
        x = self.fc0(x)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x)) …

我想要计算floor(log(n,b))哪里n和b都是整数.直接实现甚至稍微大的值此函数失败n和b

# direct implementation
def floor_log(n,b):
    return math.floor(math.log(n,b))

例如,floor_log(100**3, 100)求2值而不是正确的值3.

我能够提出一个反复划分的工作功能,直到什么都没有

# loop based implementation
def floor_log(n,b):
    val = 0
    n = n // b
    while n > 0:
        val += 1
        n = n // b
    return val

是否有更快或更优雅的方式来获得此解决方案？也许使用内置功能？

我正在使用 OpenCV-Python。

我已经使用cv2.cornerHarris. 输出类型为dst。

我需要计算角点的 SIFT 特征。输入sift.compute()必须是 类型KeyPoint。

我无法弄清楚如何使用cv2.KeyPoint().

我该怎么做呢？

假设我有以下内容：

• 具有 4 个 GPU 的系统。
• 一个函数，foo在每个 GPU 上最多可以同时运行 2 次。
• files需要foo按任何顺序处理的列表。但是，每个文件都需要不可预测的时间来处理。

我想处理所有文件，通过确保foo在任何给定时间始终有 8 个运行实例（每个 GPU 上 2 个实例），直到剩下的文件少于 8 个，从而使所有 GPU 尽可能忙碌。

调用 GPU 的实际细节不是我的问题。我想弄清楚的是如何编写并行化，以便我可以保持 8 个foo运行实例，但以某种方式确保始终使用每个 GPU ID 中的 2 个。

我想出了一种使用 解决这个问题的方法multiprocessing.Pool，但该解决方案非常脆弱，并且依赖于（AFAIK）未记录的功能。它依赖于一个事实，即内部流程Pool的格式命名FormPoolWorker-%d，其中%d是一个与池中的进程数之间的数字。我取这个值并用 GPU 的数量修改它，这给了我一个有效的 GPU id。但是，如果我能以某种方式将 GPU id 直接提供给每个进程（可能是在初始化时），而不是依赖于进程名称的字符串格式，那就更好了。

我考虑过的一件事是，如果 允许一个列表的initializer和initargs参数，以便每个进程都可以使用不同的参数集进行初始化，那么问题就没有实际意义了。不幸的是，这似乎不起作用。Pool.__init__initargs

任何人都可以推荐一个更健壮或pythonic的解决方案来解决这个问题吗？

黑客解决方案（Python 3.7）：

from multiprocessing import Pool, current_process

def foo(filename):
    # Hacky …

我正在寻找一种方法来保存 pytorch 模型，并在没有模型定义的情况下加载它。我的意思是我想保存我的模型，包括模型定义。

例如，我想要两个脚本。第一个将定义、训练和保存模型。第二个将加载和预测模型而不包括模型定义。

使用的方法torch.save(), torch.load()要求我在预测脚本中包含模型定义，但我想找到一种方法来加载模型而不在脚本中重新定义它。

在处理更复杂的事情之前，我知道我必须实现自己的backward通行证，我想尝试一些简单而美好的事情。因此，我尝试使用 PyTorch 进行均方误差损失的线性回归。当我定义自己的backward方法时出错了（参见下面的第三个实现选项），我怀疑这是因为我没有很清楚地考虑我需要将 PyTorch 作为渐变发送什么。所以，我怀疑我需要的是关于 PyTorch 希望我在这里以何种形式提供的一些解释/澄清/建议。

我正在使用 PyTorch 1.7.0，因此一堆旧示例不再有效（使用文档中描述的用户定义的 autograd 函数的不同方式）。

第一种方法（标准 PyTorch MSE 损失函数）

让我们首先在没有自定义损失函数的情况下使用标准方法：

import torch
import torch.nn as nn
import torch.nn.functional as F

# Let's generate some fake data
torch.manual_seed(42)
resid = torch.rand(100)    
inputs = torch.tensor([ [ xx ] for xx in range(100)] , dtype=torch.float32)
labels = torch.tensor([ (2 + 0.5*yy + resid[yy]) for yy in range(100)], dtype=torch.float32)

# Now we define a linear regression model
class linearRegression(torch.nn.Module):
    def __init__(self, …

我正在使用Pytorch处理线性回归问题。
我在单变量情况下取得了成功，但是当我执行多变量线性回归时，出现以下错误。如何使用多个变量进行线性回归？

（）中的TypeError Traceback（最近一次调用最后一次）（9）Optimizer.zero_grad（）＃梯度10输出=模型（输入）＃输出---> 11损失=标准（输出，目标）＃损失函数12 loss.backward（） ＃向后传播13 Optimizer.step（）＃1步优化（gradeint下降）

/anaconda/envs/tensorflow/lib/python3.6/site-packages/torch/nn/modules/module.py在调用中（self，* input，** kwargs）204205 def 调用（self，* input，** kwargs）：-> 206 result = self.forward（* input，** kwargs）207 for self中的hook._forward_hooks.values（）：208 hook_result = hook（self，input，result）

/anaconda/envs/tensorflow/lib/python3.6/site-packages/torch/nn/modules/loss.py in forward（自身，输入，目标）22 _assert_no_grad（目标）23 backend_fn = getattr（self._backend，类型（self .. name）---> 24 return backend_fn（self.size_average）（input，target）25 26

/anaconda/envs/tensorflow/lib/python3.6/site-packages/torch/nn/_functions/thnn/auto.py in forward（自己，输入，目标）39 output = input.new（1）40 getattr（self ._backend，update_output.name）（self._backend.library_state，input，target，---> 41 output，* self.additional_args）42返回输出43

TypeError：FloatMSECriterion_updateOutput接收到无效的参数组合-得到（int，torch.FloatTensor，torch.DoubleTensor，torch.FloatTensor，bool），但是是预期的（int状态，torch.FloatTensor输入，torch.FloatTensor目标，torch.Float布尔值（平均）

这是代码

#import
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
from torch.autograd import Variable

#input_size = 1
input_size = …

我想编写一个使用牛顿方法的程序:

估计这个积分的x:

其中X是总距离.

我有函数计算通过使用梯形方法进行数值积分到达一定距离所需的时间.不使用trapz.

function T = time_to_destination(x, route, n)
h=(x-0)/n;
dx = 0:h:x;
y = (1./(velocity(dx,route)));

Xk = dx(2:end)-dx(1:end-1); 
Yk = y(2:end)+y(1:end-1);

T = 0.5*sum(Xk.*Yk);
end

它通过一组数据点之间的三次样条插值的ppval获取其速度值.外推值不应该是可取的.

function [v] = velocity(x, route)
load(route);

if all(x >= distance_km(1))==1 & all(x <= distance_km(end))==1
    estimation = spline(distance_km, speed_kmph);
    v = ppval(estimation, x);
else
    error('Bad input, please choose a new value')
end
end

速度样条曲线的绘图如果您对此感兴趣,请评估:

dx= 1:0.1:65

现在我想编写一个函数,可以解决在给定时间之后行进的距离,使用没有fzero/fsolve的newton方法.但我不知道如何解决积分的上界.

根据微积分的基本定理,我认为积分的导数是积分内的函数,这是我试图重新创建的Time_to_destination /(1/velocity)我添加了我想要解决的常数到时间目的地所以它

(Time_to_destination - (输入时间))/(1 /速度)

不确定我是否正确行事.

编辑:重写我的代码,现在效果更好,但我对Newton Raphson的停止条件似乎没有收敛到零.我也试图从梯形积分(ET)实现错误,但不确定我是否应该打扰实现它.还可以在底部找到路径文件.

牛顿方法的停止条件和误差计算:

梯形误差估计:

Function x = distance(T, route) …

我有一个问题,我试图解决,创建一个Nx1单元格,其中存储的数据总是N个2x2矩阵.

例:

N = 2
mycell = cell(N,1); 
for i =1:N;
    mycell{i} = randi([0, 10], 2);
end 

newmatrix = zeros (N+1); 

所以说mycell {1}看起来像:

[3 5
 2 1]

和mycell {2}看起来像:

[6 9;
 3 2]

我新的零矩阵看起来像:

[0 0 0
 0 0 0
 0 0 0]

我想让它看起来像这样(在这种对角线设置中加入第一个单元格的最后一个元素与下一个单元格的第一个元素):

[3 5 0
 2 7 9
 0 3 2]

有没有一种简单的方法可以做到这一点或任何可能有帮助的内置Matlab函数？

谢谢.