小编Rav*_*euk的帖子

偶尔我会看到一些模型正在使用SpatialDropout1D而不是Dropout.例如,在词性标注神经网络中,他们使用:

model = Sequential()
model.add(Embedding(s_vocabsize, EMBED_SIZE,
                    input_length=MAX_SEQLEN))
model.add(SpatialDropout1D(0.2)) ##This
model.add(GRU(HIDDEN_SIZE, dropout=0.2, recurrent_dropout=0.2))
model.add(RepeatVector(MAX_SEQLEN))
model.add(GRU(HIDDEN_SIZE, return_sequences=True))
model.add(TimeDistributed(Dense(t_vocabsize)))
model.add(Activation("softmax"))

根据Keras的文件,它说:

此版本执行与Dropout相同的功能,但它会丢弃整个1D功能图而不是单个元素.

但是,我无法理解entrie 1D功能的含义.更具体地说,我无法SpatialDropout1D在quora中解释的相同模型中进行可视化.有人可以使用与quora相同的模型来解释这个概念吗？

另外,在什么情况下我们会用SpatialDropout1D而不是Dropout？

在机器翻译中，我们总是需要在注释和预测中切出第一个时间步（SOS 标记）。

使用 时batch_first=False，切掉第一个时间步仍然保持张量连续。

import torch
batch_size = 128
seq_len = 12
embedding = 50

# Making a dummy output that is `batch_first=False`
batch_not_first = torch.randn((seq_len,batch_size,embedding))
batch_not_first = batch_first[1:].view(-1, embedding) # slicing out the first time step

但是，如果我们batch_first=True在切片后使用 , ，张量就不再连续。我们需要先使其连续，然后才能执行不同的操作，例如view.

batch_first = torch.randn((batch_size,seq_len,embedding))
batch_first[:,1:].view(-1, embedding) # slicing out the first time step

output>>>
"""
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-8-a9bd590a1679> in <module>
----> 1 batch_first[:,1:].view(-1, embedding) # slicing out the first time …

根据该网站,深度信念网络只是将多个RBM堆叠在一起,使用先前RBM的输出作为下一个RBM的输入.

在scikit-learn 文档中,有一个使用RBM对MNIST数据集进行分类的示例.他们将a RBM和a LogisticRegression放在一个管道中以获得更好的准确性.

因此,我想知道是否可以将多个RBM添加到该管道中以创建深度信任网络,如以下代码所示.

from sklearn.neural_network import BernoulliRBM
import numpy as np
from sklearn import linear_model, datasets, metrics
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline

digits = datasets.load_digits()
X = np.asarray(digits.data, 'float32')
Y = digits.target
X = (X - np.min(X, 0)) / (np.max(X, 0) + 0.0001)  # 0-1 scaling

X_train, X_test, Y_train, Y_test = train_test_split(X, Y,
                                                    test_size=0.2,
                                                    random_state=0)

logistic = linear_model.LogisticRegression(C=100)
rbm1 = BernoulliRBM(n_components=100, learning_rate=0.06, n_iter=100, verbose=1, random_state=101)
rbm2 = BernoulliRBM(n_components=80, learning_rate=0.06, …

当我通过使用以下代码使用matplotlib中的plt.specgram时，生成的频谱图是正确的

import matplotlib.pyplot as plt
from scipy import signal
from scipy.io import wavfile
import numpy as np

sample_rate, samples = wavfile.read('.\\Wav\\test.wav')

Pxx, freqs, bins, im = plt.specgram(samples[:,1], NFFT=1024, Fs=44100, noverlap=900)

但是，如果我通过使用scipy页面中给出的示例代码和以下代码来生成频谱图，则会得到以下内容：

import matplotlib.pyplot as plt
from scipy import signal
from scipy.io import wavfile
import numpy as np

sample_rate, samples = wavfile.read('.\\Wav\\test.wav')

frequencies, times, spectrogram = signal.spectrogram(samples[:,1],sample_rate,nfft=1024,noverlap=900, nperseg=1024)

plt.pcolormesh(times, frequencies, spectrogram)
plt.ylabel('Frequency [Hz]')
plt.xlabel('Time [sec]')

要调试这是怎么回事，我尝试使用Pxx，freqs，bins，通过第一种方法生成的，然后使用第二种方法绘制出来的数据：

plt.pcolormesh(bins, freqs, Pxx)
plt.ylabel('Frequency [Hz]') …

我试图skipgrams()通过使用以下代码来了解keras 中的功能

from keras.preprocessing.text import *
from keras.preprocessing.sequence import skipgrams

text = "I love money" #My test sentence
tokenizer = Tokenizer()
tokenizer.fit_on_texts([text])
word2id = tokenizer.word_index
wids = [word2id[w] for w in text_to_word_sequence(text)]
pairs, labels = skipgrams(wids, len(word2id),window_size=1)

for i in range(len(pairs)): #Visualizing the result
    print("({:s} , {:s} ) -> {:d}".format(
          id2word[pairs[i][0]], 
          id2word[pairs[i][1]], 
          labels[i]))

对于句子“我爱钱”，我希望以下(context, word)对的窗口大小为 1，如 keras 中所定义：

([i, money], love)
([love], i)
([love], money)

根据我在 Keras 文档中的理解，它将输出 1 if(word, word in the same window) …

我正在尝试使用以下代码绘制一些数据

from sklearn.datasets import make_blobs\nimport seaborn as sns\nimport numpy as np\n\nX, y = make_blobs(n_samples=1000, n_features=2, centers=10, cluster_std=1.0, center_box=(-10.0, 10.0), shuffle=True, random_state=None)\n\npalette = np.array(sns.color_palette("bright", 10))  #Chossing color  \nsns.scatterplot(X[:,0],X[:,1],legend=\'full\',c=palette[y])\n

颜色很漂亮，但缺少图例。\n当我检查文档时，我看到：

\n

如何绘制图例。如果\xe2\x80\x9cbrief\xe2\x80\x9d，数字hue和size变量\n ....

\n

所以看来我还需要包含参数hue。\n但是当我hue使用以下代码尝试参数时，会创建以下图表......

sns.scatterplot(X[:,0],X[:,1],legend=\'full\',hue=y,c=palette[y])\n

图例正在显示，但颜色不是我想要的。添加hue参数后，它似乎覆盖了调色板参数。不管我选择什么调色板，颜色仍然很难看......

我的问题是： \n如何在保持我想要的颜色的同时显示图例？

原图

我正在尝试使用以下代码绘制下图：

from sklearn.datasets import make_blobs
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

X,y = make_blobs(n_samples=21,centers=7,shuffle=False)

palette = sns.color_palette("bright", 7)

fig, ax = plt.subplots(figsize=(4,4))
p1 = sns.scatterplot(X[:,0],X[:,1],palette=palette, hue=y,legend='full')

我未能实现的情节

现在，除了不同标签的不同颜色外，我还想要不同的形状。但是，即使我添加了markers参数，也没有任何改变。

marker_list = ['.', ',', 'o', 'v', '^', '<', '>']

fig, ax = plt.subplots(figsize=(4,4))
p1 = sns.scatterplot(X[:,0],X[:,1],palette=palette, hue=y,legend='full',markers=marker_list)

为什么marker论证不起作用？

Librosa 和 Scipy 都有这个fft功能，但是，即使输入相同的信号，它们也会给我不同的频谱图输出。

西比

我正在尝试使用以下代码获取频谱图

import numpy as np                                       # fast vectors and matrices
import matplotlib.pyplot as plt                          # plotting
from scipy import fft      

X = np.sin(np.linspace(0,1e10,5*44100))

fs = 44100          # assumed sample frequency in Hz
window_size = 2048  # 2048-sample fourier windows
stride = 512        # 512 samples between windows
wps = fs/float(512) # ~86 windows/second
Xs = np.empty([int(2*wps),2048])

for i in range(Xs.shape[0]):
    Xs[i] = np.abs(fft(X[i*stride:i*stride+window_size]))

fig = plt.figure(figsize=(20,7))
plt.imshow(Xs.T[0:150],aspect='auto')
plt.gca().invert_yaxis()
fig.axes[0].set_xlabel('windows (~86Hz)')
fig.axes[0].set_ylabel('frequency')
plt.show()

然后我得到以下频谱图 …

考虑下面的代码

import numpy as np
import matplotlib.pyplot as plt
from librosa import cqt

s = np.linspace(0,1,44100)
x = np.sin(2*np.pi*1000*s)
fmin=500

cq_lib = cqt(x,sr=44100, fmin=fmin, n_bins=40)

plt.imshow(abs(cq_lib),aspect='auto', origin='lower')
plt.xlabel('Time Steps')
plt.ylabel('Freq bins')

它会给出这样的频谱图

当您仔细观察频谱图的开头和结尾时，您会发现那里存在一些缺陷。

当仅绘制第一个和最后一个时间步长时，您可以看到频率不正确。

第一帧

plt.plot(abs(cq_lib)[:,0])
plt.ylabel('Amplitude')
plt.xlabel('Freq bins')
plt.tick_params(labelsize=16)

最后一帧和第二最后一帧比较

plt.plot(abs(cq_lib)[:,-1])
plt.plot(abs(cq_lib)[:,-2])
plt.legend(['last step', '2nd last step'], fontsize=16)
plt.ylabel('Amplitude')
plt.xlabel('Freq bins')
plt.tick_params(labelsize=16)

我尝试解决它

据我所知，应该是因为padding，把stft窗口放在了中心。但似乎cqt并不支持这个论点center=False。

cq_lib = cqt(x,sr=44100, fmin=fmin, n_bins=40,center=False)

类型错误：cqt() 得到意外的关键字参数“center”

我做错了什么吗？如何center=False制作cqt？

我有超过 1000 个音频文件（这只是一个初步的开发，将来会有更多的音频文件），并且想将它们转换为 melspectrogram。

由于我的工作站有一个 Intel® Xeon® 处理器 E5-2698 v3，它有 32 个线程，我想使用多线程来完成我的工作。

我的代码

import os
import librosa
from librosa.display import specshow
from natsort import natsorted
import numpy as np
import sys 
# Libraries for multi thread
from multiprocessing.dummy import Pool as ThreadPool
import subprocess
pool = ThreadPool(20) 

songlist = os.listdir('../opensmile/devset_2015/')
songlist= natsorted(songlist)

def get_spectrogram(song):
    print("start")
    y, sr = librosa.load('../opensmile/devset_2015/' + song)

    ## Add some function to cut y
    y_list = y
    ##

    for i, y_i in enumerate([y_list]): # can remove …

我对Pytorch如何处理一键向量感到非常困惑。在本教程中，神经网络将生成一个热向量作为其输出。据我了解，本教程中神经网络的示意图结构应类似于：

但是，labels它们不是一站式矢量格式。我得到以下size

print(labels.size())
print(outputs.size())

output>>> torch.Size([4]) 
output>>> torch.Size([4, 10])

神奇的是，我将outputs和传递labels给criterion=CrossEntropyLoss()，完全没有错误。

loss = criterion(outputs, labels) # How come it has no error?

我的假设：

也许pytorch会自动将其转换labels为一键式矢量形式。因此，在将标签传递给损失函数之前，我尝试将标签转换为单热矢量。

def to_one_hot_vector(num_class, label):
    b = np.zeros((label.shape[0], num_class))
    b[np.arange(label.shape[0]), label] = 1

    return b

labels_one_hot = to_one_hot_vector(10,labels)
labels_one_hot = torch.Tensor(labels_one_hot)
labels_one_hot = labels_one_hot.type(torch.LongTensor)

loss = criterion(outputs, labels_one_hot) # Now it gives me error

但是，出现以下错误

RuntimeError：/opt/pytorch/pytorch/aten/src/THCUNN/generic/ClassNLLCriterion.cu:15不支持多目标

因此，Pytorch？中不支持一键向量。如何Pytorch计算cross entropy两个张量outputs = …

如果我的模型仅包含nn.DataParallelnn.Module等层nn.Linear，则 nn.DataParallel 工作正常。

x = torch.randn(100,10)

class normal_model(torch.nn.Module):
    def __init__(self):
        super(normal_model, self).__init__()
        self.layer = torch.nn.Linear(10,1)

    def forward(self, x):
        return self.layer(x)

model = normal_model()
model = nn.DataParallel(model.to('cuda:0'))
model(x)

但是，当我的模型包含如下张量运算时

class custom_model(torch.nn.Module):
    def __init__(self):
        super(custom_model, self).__init__()
        self.layer = torch.nn.Linear(10,5)
        self.weight = torch.ones(5,1, device='cuda:0')
    def forward(self, x):
        return self.layer(x) @ self.weight

model = custom_model()
model = torch.nn.DataParallel(model.to('cuda:0'))
model(x) 

它给了我以下错误

RuntimeError：在设备 1 上的副本 1 中捕获 RuntimeError。原始回溯（最近一次调用最后）：文件“/opt/conda/lib/python3.6/site-packages/torch/nn/parallel/parallel_apply.py”，第 60 行，在 _worker 输出 = module(*input, **kwargs) 文件“/opt/conda/lib/python3.6/site-packages/torch/nn/modules/module.py”中，第 541 行，在调用 结果 = self …

在这个博客后，他实现了Kears层外的三重损失。他从网络中获取anchor_out,pos_out和neg_out，然后将它们传递给triplet_loss()他定义的函数。

我想知道是否可以通过定义我自己的Lambda层来计算 Keras 层内的triplet_loss 。

这是我的网络设计：

margin=1

anchor_input = Input((600, ), name='anchor')
positive_input = Input((600, ), name='positive_input')
negative_input = Input((600, ), name='negative_input')

# Shared embedding layer for positive and negative items
Shared_DNN = Dense(300)

encoded_anchor = Shared_DNN(anchor_input)
encoded_positive = Shared_DNN(positive_input)
encoded_negative = Shared_DNN(negative_input)

DAP = Lambda(lambda tensors:K.sum(K.square(tensors[0] - tensors[1]),axis=1,keepdims=True),name='DAP_loss') #Distance for Anchor-Positive pair
DAN = Lambda(lambda tensors:K.sum(K.square(tensors[0] - tensors[1]),axis=1,keepdims=True),name='DAN_loss') #Distance for Anchor-Negative pair
Triplet_loss = Lambda(lambda loss:K.max([(loss[0] - …