小编Mat*_*att的帖子

对于一个班级,我的老师提出的问题是将矩阵乘以其转置的算法成本.使用标准的3循环矩阵乘法算法,效率为O(N ^ 3),我想知道是否有办法操纵或利用矩阵*矩阵转置来获得更快的算法.我知道当你将矩阵乘以它的转置时,你必须计算较少的矩阵,因为它是对称的,但我想不出如何操作一个可能小于O(n ^ 3)的算法.

我知道像Coppensmith和Straussen这样的算法是更快的通用矩阵乘法算法,但任何人都可以提供有关如何计算利用转置的任何提示或见解？

谢谢

最近,对于数据结构类,我被问到一个问题,即如何删除懒惰(即,首先标记需要删除的项目的删除,然后在某个时候删除所有标记的项目)将是有利的/不利于数组,链表或二叉树.以下是我的想法:

• 这将有助于数组,因为每次删除索引时都会节省移动数组所花费的时间,尽管在需要遍历数组的算法中,可能效率低下.
• 这对链接列表没有帮助,因为您需要遍历O(n)以标记要删除的项目.
• 我不完全确定二叉树,但如果它是一个链表实现,我会想象它就像链表？

在CI中学习K&R书有一些关于复杂指针声明和指针数组关系的问题.

1)究竟有什么区别

char amessage[] = "this is a string";

和

char *pmessage
pmessage = "this is a string"

什么时候你会使用其中一个？

根据我的理解,第一个根据字符串的大小分配一些内存,然后将字符存储在内存中.然后,当您访问amessage []时,您只需直接访问您正在寻找的任何字符.对于第二个,您还可以分配内存,只需在需要时通过指针访问数据.这是正确的看待方式吗？

2)书中说,传递给函数时的数组被视为指向数组的第一个索引的指针,因此即使你仍然可以执行类似[i]的语法,你也可以通过操纵指针来操作数组.如果您刚刚在某处创建了一个数组并且想要访问它,或者只有将数组传入函数时才是真的吗？例如:

char amessage[]= "hi";
char x = *(amessage + 1); // can I do this?

3)书中说静态的使用在这个特定的功能中是很好的:

/* month_name:  return name of n-th month */
char *month_name(int n)
{
    static char *name[] = {
       "Illegal month",
       "January", "February", "March",
       "April", "May", "June",
       "July", "August", "September",
       "October", "November", "December"
   };
   return (n < 1 || n > 12) ? name[0] : …

我正在使用tqdm库并且它没有给我进度条,而是它给我输出看起来像这样它只是告诉我迭代:

251it [01:44, 2.39it/s]

知道为什么代码会这样做吗？我以为这可能是因为我把它传给了一台发电机但是我曾经使用过去曾经使用过的发电机.我以前从来没有真正搞过tdqm格式.以下是源代码的一部分:

train_iter = zip(train_x, train_y) #train_x and train_y are just lists of elements
....
def train(train_iter, model, criterion, optimizer):
    model.train()
    total_loss = 0
    for x, y in tqdm(train_iter):
        x = x.transpose(0, 1)
        y = y.transpose(0, 1)
        optimizer.zero_grad()
        bloss = model.forward(x, y, criterion)   
        bloss.backward()
        torch.nn.utils.clip_grad_norm(model.parameters(), args.clip)
        optimizer.step()        
        total_loss += bloss.data[0]
    return total_loss

我从概念上理解最大/总和池中发生的CNN层操作是什么,但是我看到这个术语"随时间推移的最大池",或者"随时间推移的总和池"(例如,"句子分类的卷积神经网络") Yoon Kim的论文).有什么不同？

所以我有一行代码:

packed_embeddings = pack_padded_sequence(input=embeddings,
                                                 lengths=lengths,
                                                 batch_first=True)

这引发了我这个错误:

  File "/Users/kwj/anaconda3/lib/python3.6/site-packages/torch/onnx/__init__.py", line 130, in might_trace
    first_arg = args[0]

IndexError: tuple index out of range

但如果我拿出"输入",神奇地修复自己:

    packed_embeddings = pack_padded_sequence(embeddings,
                                             lengths=lengths,
                                             batch_first=True)

这是PyTorch文档中的函数规范:

https://pytorch.org/docs/stable/_modules/torch/nn/utils/rnn.html#pack_padded_sequence

我正在使用Python3和PyTorch 0.4.我错过了一些非常基本的东西吗 不确定这是我的问题,还是PyTorch特定的问题......在这里很困惑.

谢谢

我正在尝试使用Flask + PyTorch运行一个基本应用程序，并将其托管在Heroku上。但是，我遇到的问题是，免费版本的最大子弹大小为500mb，而PyTorch本身约为500mb。

在Google进行一些搜索之后，有人写了一篇关于找到仅CPU版本的PyTorch的文章，并使用它，在这里要小得多。。

但是，我对如何完成此操作非常迷惑，而该人员根本没有记录在案。任何建议表示赞赏，谢谢。

编辑：

为了更具体地说明我的问题，据我所知，我尝试安装torch by，其中包括require.txt，其中将torch列为依赖项。当前我有：火炬== 0.4.1。但是，这不起作用的大小。

我的问题是，您是否知道我可以在需求文件中写些什么来获得较小的仅用于cpu的割炬版本，或者，如果requirements.txt不适用于该版本，我会怎么做，以便获取CPU版本。

编辑:我根据人们的建议改变了我的程序,但我无法修复内存泄漏.另外,我需要在不使用argc的情况下释放它们,所以我需要以某种方式跟踪数组长度,因此我将最后一个元素标记为null.

目前我正在编写一个C程序,它将命令行参数复制到动态分配的数组中.我的代码看起来像:

char **array;                                                                                                                                                                                     
int j;                                                                                                                                                                                        

array = malloc(sizeof(char*) * (argc + 1));                                                                                                                                                       
int i;                                                                                                                                                                                            
int index = 0;                                                                                                                                                                                    

for(i = 0; i < (argc); i++){                                                                                                                                                                      
    int length = strlen(*(argv + i));                                                                                                                                                             
    array[i] = malloc((length + 1) * sizeof(char));                                                                                                                                                                                                                                                                                                                                    
        // Cycle through all the chars and copy them in one by one                                                                                                                                
    for(j = 0; j <= length; j++){                                                                                                                                                                 
        array[i][j] = toupper(argv[i][j]);                                                                                                                                                        
    }                                                                                                                                                                                             
}      
array[i + 1] = NULL;                                                                                                                                                                                           

return array;      

后来,我试着释放记忆:

char** array_copy = array;
while(*array_copy != NULL){
    free(*array_copy++); …

我看到很多关于 CEL 或二元交叉熵损失的解释，其中基本事实是 0 或 1，然后你会得到一个如下函数：

def CrossEntropy(yHat, y):
    if yHat == 1:
      return -log(y)
    else:
      return -log(1 - y)

然而，当你的 yHat 不是离散的 0 或 1 时，我对 BCE 如何工作感到困惑。例如，如果我想查看 MNIST 数字的重建损失，其中我的基本事实是 0 < yHat < 1，并且我的预测是也在同一范围内，这如何改变我的功能？

编辑：

抱歉，让我为我的困惑提供更多背景信息。在关于 VAE 的 PyTorch 教程中，他们使用 BCE 来计算重建损失，其中 yhat （据我所知，不是离散的）。看：

https://github.com/pytorch/examples/blob/master/vae/main.py

该实现有效......但我不明白在这种情况下如何计算 BCE 损失。