使用torch.Storage共享多个张量的相同存储以及将torch.Tensor转化为torch.Storage - pytorch中文网
使用torch.Storage共享多个张量的相同存储以及将torch.Tensor转化为torch.Storage
o 180 次浏览 o 0 个回复 o 日
torch.Storage是单个数据类型的连续的一维数组，每个torch.Tensor都具有相同数据类型的相应存储。他是torch.tensor底层数据结构,他除了像Tensor一样定义数值，还可以直接把文件映射到内存中进行操作，如果你使用的是pytorch神经网络，你不需要直接使用它们。中文文档地址
注意：任何比一维数组更复杂的都需要用到张量。
torch.Storage主要有以下几种类型：
torch.FloatStorage([1,2,3,4,5])
torch.ByteStorage([1,2,3,4,5])
torch.ShortStorage([1,2,3,4,5])
torch.IntStorage([1,2,3,4,5])
torch.LongStorage([1,2,3,4,5])
torch.FloatStorage([1,2,3,4,5])
torch.DoubleStorage([1,2,3,4,5])
torch.ShortStorage([1,2,3,4,5])
一、构造函数
你可以使用torch.FloatStorage()构造一个空的Storage，构造函数的数值是随机初始化的。
我们可以使用2种方法来构造torch.FloatStorage()并把它存入内存中
# 通过数组
torch.FloatStorage([1,2,3,4,5])
# 随机生成一个Storage
torch.FloatStorage(5)
二、torch.Storage的操作以及类型的转变
torch.Storage包含多种操作例如：size()返回此存储转的大小,tolist()返回一个包含此存储中元素的列表等等，具体参考文档
torch.FloatStorage()类型之间的转换,其实文档里有介绍，我这里给个例子：
a = torch.FloatTensor([1,2,3,4])
print a.char()
print a.long()
三、torch.Storage与torch.Tensor之间的转化
将Tensor转换为Storage非常简单，只需要storage()函数即可
import torch
a = torch.FloatTensor([1,2,3,4])
print a.storage()
它没有其他高级的用法，它是张量的一层。它可以共享多个张量的相同存储。或者更有效地处理一些操作。
原创文章，转载请注明 ：
原文出处：
/news/52.html
问题交流群 ：
本站主要用于提供Pytorch,Torch等深度学习框架分享交流使用,本站包括Pytorch/Torch最新资讯，中文文档，中文交流社区。如有问题，大家可在社区交流讨论！谢谢大家！
扫码加入QQ群
手机浏览社区点击阅读原文
理解情感 ：从 Keras 移植到 pyTorch
3 天前 发布，来源：
导语：情感情绪检测是自然语言理解的关键要素。最近，我们将原来的项目迁移到了新的集成系统上，该系统基于麻省理工学院媒体实验室推出的NLP模型搭建而成。
情感情绪检测是自然语言理解的关键要素。最近，我们将原来的项目迁移到了新的集成系统上，该系统基于麻省理工学院媒体实验室推出的NLP模型搭建而成。
代码已经开源了！（详见GitHub： ）
该模型最初的设计使用了TensorFlow、Theano和Keras，接着我们将其移植到了pyTorch上。与Keras相比，pyTorch能让我们更自由地开发和测试各种定制化的神经网络模块，并使用易于阅读的numpy风格来编写代码。在这篇文章中，我将详细说明在移植过程中出现的几个有趣的问题：
如何使用自定义激活功能定制pyTorch LSTM
PackedSequence对象的工作原理及其构建
如何将关注层从Keras转换成pyTorch
如何在pyTorch中加载数据：DataSet和Smart Batching
如何在pyTorch中实现Keras的权重初始化
首先，我们来看看torchMoji/DeepMoji的模型。它是一个相当标准而强大的人工语言处理神经网络，具有两个双LSTM层，其后是关注层和分类器：
torchMoji/DeepMoji模型
如何构建一个定制化的pyTorch LSTM模块
DeepMoji有一个很不错的特点：Bjarke Felbo及其协作者能够在一个拥有16亿条记录的海量数据集上训练该模型。因此，预先训练的模型在此训练集中具有非常丰富的情感和情绪表征，我们可以很方便地使用这个训练过的模型。
该模型是使用针对LSTM的回归内核的Theano/Keras默认激活函数训练的，而pyTorch是基于库建模的，这样，可获得的GPU加速与标准的sigmoid回归激活函数：
Keras默认的LSTM和pyTorch默认的LSTM因此，我写了一个具有hard sigmoid回归激活函数的自定义LSTM层：
def LSTMCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None):
A modified LSTM cell with hard sigmoid activation on the input, forget and output gates.
hx, cx = hidden
gates = F.linear(input, w_ih, b_ih) + F.linear(hx, w_hh, b_hh)
ingate, forgetgate, cellgate, outgate = gates.chunk(4, 1)
ingate = hard_sigmoid(ingate)
forgetgate = hard_sigmoid(forgetgate)
cellgate = F.tanh(cellgate)
outgate = hard_sigmoid(outgate)
cy = (forgetgate * cx) + (ingate * cellgate)
hy = outgate * F.tanh(cy)
return hy, cy
def hard_sigmoid(x):
Computes element-wise hard sigmoid of x.
See e.g. /Theano/Theano/blob/master/theano/tensor/nnet/sigm.py#L279
x = (0.2 * x) + 0.5
x = F.threshold(-x, -1, -1)
x = F.threshold(-x, 0, 0)
这个LSTM单元必须集成在一个完整的模块中，这样才可以使用pyTorch所有的功能。这个集成相关的代码很长，建议直接引用到Github中的。
Keras和pyTorch中的关注层
模型的关注层是一个有趣的模块，我们可以分别在Keras和pyTorch的代码中进行比较：
class Attention(Module):
Computes a weighted average of channels across timesteps (1 parameter pr. channel).
def __init__(self, attention_size, return_attention=False):
""" Initialize the attention layer
# Arguments:
attention_size: Size of the attention vector.
return_attention: If true, output will include the weight for each input token
used for the prediction
super(Attention, self).__init__()
self.return_attention = return_attention
self.attention_size = attention_size
self.attention_vector = Parameter(torch.FloatTensor(attention_size))
def __repr__(self):
s = '{name}({attention_size}, return attention={return_attention})'
return s.format(name=self.__class__.__name__, **self.__dict__)
def forward(self, inputs, input_lengths):
""" Forward pass.
# Arguments:
inputs (Torch.Variable): Tensor of input sequences
input_lengths (torch.LongTensor): Lengths of the sequences
Tuple with (representations and attentions if self.return_attention else None).
logits = inputs.matmul(self.attention_vector)
unnorm_ai = (logits - logits.max()).exp()
# Compute a mask for the attention on the padded sequences
# See e.g. https://discuss.pytorch.org/t/self-attention-on-words-and-masking/5671/5
max_len = unnorm_ai.size(1)
idxes = torch.arange(0, max_len, out=torch.LongTensor(max_len)).unsqueeze(0)
if torch.cuda.is_available():
idxes = idxes.cuda()
mask = Variable((idxes & input_lengths.unsqueeze(1)).float())
# apply mask and renormalize attention scores (weights)
masked_weights = unnorm_ai * mask
att_sums = masked_weights.sum(dim=1, keepdim=True)
# sums per sequence
attentions = masked_weights.div(att_sums)
# apply attention weights
weighted = torch.mul(inputs, attentions.unsqueeze(-1).expand_as(inputs))
# get the final fixed vector representations of the sentences
representations = weighted.sum(dim=1)
return (representations, attentions if self.return_attention else None)
class AttentionWeightedAverage(Layer):
Computes a weighted average of the different channels across timesteps.
Uses 1 parameter pr. channel to compute the attention value for a single timestep.
def __init__(self, return_attention=False, **kwargs):
self.init = initializers.get('uniform')
self.supports_masking = True
self.return_attention = return_attention
super(AttentionWeightedAverage, self).__init__(** kwargs)
def build(self, input_shape):
self.input_spec = [InputSpec(ndim=3)]
assert len(input_shape) == 3
self.W = self.add_weight(shape=(input_shape[2], 1),
name='{}_W'.format(self.name),
initializer=self.init)
self.trainable_weights = [self.W]
super(AttentionWeightedAverage, self).build(input_shape)
def call(self, x, mask=None):
# computes a probability distribution over the timesteps
# uses 'max trick' for numerical stability
# reshape is done to avoid issue with Tensorflow
# and 1-dimensional weights
logits = K.dot(x, self.W)
x_shape = K.shape(x)
logits = K.reshape(logits, (x_shape[0], x_shape[1]))
ai = K.exp(logits - K.max(logits, axis=-1, keepdims=True))
# masked timesteps have zero weight
if mask is not None:
mask = K.cast(mask, K.floatx())
ai = ai * mask
att_weights = ai / K.sum(ai, axis=1, keepdims=True)
weighted_input = x * K.expand_dims(att_weights)
result = K.sum(weighted_input, axis=1)
if self.return_attention:
return [result, att_weights]
return result
def get_output_shape_for(self, input_shape):
return pute_output_shape(input_shape)
def compute_output_shape(self, input_shape):
output_len = input_shape[2]
if self.return_attention:
return [(input_shape[0], output_len), (input_shape[0], input_shape[1])]
return (input_shape[0], output_len)
def compute_mask(self, input, input_mask=None):
if isinstance(input_mask, list):
return [None] * len(input_mask)
return None
如你所见，主要的算法大致相同，但PyTorch代码中的大部分都是注释，而Keras则需要编写几个附加函数并进行调用。
在编写和调试自定义模块和层时，pyTorch是一个更快的选择；而对于快速训练和测试由标准层构建的模型时，Keras显然更加合适。
PackedSequence对象的工作原理
Keras有一个不错的掩码功能可以用来处理可变长度序列。那么在pyTorch中又该如何处理这个呢？可以使用PackedSequences！ pyTorch文档中有关的介绍并不是很详细，所以这里会详细描述它的细节。
一个拥有5个序列18个令牌的典型NLP批次
假设我们有一批可变长度的序列（在NLP应用中通常就是这样的）。为了在GPU上并行计算这样一个批次，我们希望：
尽可能多地并行处理这个序列，因为LSTM隐藏状态依赖于每个序列的前一个时间步长，以及
以正确的时间步长（每个序列的结尾）停止每个序列的计算。
这可以通过使用pyTorch中的PackedSequence类来实现。我们首先通过减少长度来对序列进行排序，并将它们放到在张量中。然后对张量和序列长度列表调用pack_padded_sequence函数
# input_seqs is a batch of input sequences as a numpy array of integers (word indices in vocabulary) padded with zeroas
input_seqs = Variable(torch.from_numpy(input_seqs.astype('int64')).long())
# First: order the batch by decreasing sequence length
input_lengths = torch.LongTensor([torch.max(input_seqs[i, :].data.nonzero()) + 1 for i in range(input_seqs.size()[0])])
input_lengths, perm_idx = input_lengths.sort(0, descending=True)
input_seqs = input_seqs[perm_idx][:, :input_lengths.max()]
# Then pack the sequences
packed_input = pack_padded_sequence(input_seqs, input_lengths.cpu().numpy(), batch_first=True)
PackedSequence对象包括：
一个data对象：一个torch.Variable（令牌的总数，每个令牌的维度），在这个简单的例子中有五个令牌序列（用整数表示）：（18，1）
一个batch_sizes对象：每个时间步长的令牌数列表，在这个例子中为：[6，5，2，4，1]
用pack_padded_sequence函数来构造这个对象非常的简单：
如何构造一个PackedSequence对象（batch_first = True）
PackedSequence对象有一个很不错的特性，就是我们无需对序列解包（这一步操作非常慢）即可直接在PackedSequence数据变量上执行许多操作。特别是我们可以对令牌执行任何操作（即对令牌的顺序/上下文不敏感）。当然，我们也可以使用接受PackedSequence作为输入的任何一个pyTorch模块（pyTorch 0.2）。
例如，在我们的NLP模型中，我们可以，并在此对象上应用LSTM。我们还可以在不解包的情况下执行关注层的一些操作。
pyTorch中的智能数据加载：DataSets和Batches
在Keras中，数据加载和批处理通常隐藏在中。重申一遍，如果你想要快速地测试模型，Keras很好用，但这也意味着我们不能完全控制模型中的重要部分。
在pyTorch中，我们将使用三个类来完成这个任务：
一个DataSet类，用于保存、预处理和索引数据集
一个BatchSampler类，用于控制样本如何批量收集
一个DataLoader类，负责将这些批次提供给模型
我们的DataSet类非常简单：
class DeepMojiDataset(Dataset):
""" A simple Dataset class.
# Arguments:
X_in: Inputs of the given dataset.
y_in: Outputs of the given dataset.
# __getitem__ output:
(torch.LongTensor, torch.LongTensor)
def __init__(self, X_in, y_in):
# Check if we have Torch.LongTensor inputs (assume Numpy array otherwise)
if not isinstance(X_in, torch.LongTensor):
X_in = torch.from_numpy(X_in.astype('int64')).long()
if not isinstance(y_in, torch.LongTensor):
y_in = torch.from_numpy(y_in.astype('int64')).long()
self.X_in = torch.split(X_in, 1, dim=0)
self.y_in = torch.split(y_in, 1, dim=0)
def __len__(self):
return len(self.X_in)
def __getitem__(self, idx):
return self.X_in[idx].squeeze(), self.y_in[idx].squeeze()
我们BatchSampler则更有趣。
我们有几个小的NLP数据集，用于微调情感情绪检测模型。这些数据集有着不同的长度和某些不平衡的种类，所以我们想设计这么一个批量采样器：
在预先定义的样本数中收集批次，这样我们的训练过程就可以不依赖于批次的长度
能够从不平衡的数据集中以平衡的方式进行采样。
在PyTorch中，BatchSampler是一个可以迭代生成批次的类，BatchSampler的每个批处理都包含一个列表，其中包含要在DataSet中选择的样本的索引。
因此，我们可以定义一个用数据集类标签向量来初始化的BatchSampler对象，以构建满足我们需求的批次列表：
class DeepMojiBatchSampler(object):
"""A Batch sampler that enables larger epochs on small datasets and
has upsampling functionality.
# Arguments:
y_in: Labels of the dataset.
batch_size: Batch size.
epoch_size: Number of samples in an epoch.
upsample: Whether upsampling should be done. This flag should only be
set on binary class problems.
seed: Random number generator seed.
# __iter__ output:
iterator of lists (batches) of indices in the dataset
def __init__(self, y_in, batch_size, epoch_size, upsample, seed):
self.batch_size = batch_size
self.epoch_size = epoch_size
self.upsample = upsample
np.random.seed(seed)
if upsample:
# Should only be used on binary class problems
assert len(y_in.shape) == 1
neg = np.where(y_in.numpy() == 0)[0]
pos = np.where(y_in.numpy() == 1)[0]
assert epoch_size % 2 == 0
samples_pr_class = int(epoch_size / 2)
ind = range(len(y_in))
if not upsample:
# Randomly sample observations in a balanced way
self.sample_ind = np.random.choice(ind, epoch_size, replace=True)
# Randomly sample observations in a balanced way
sample_neg = np.random.choice(neg, samples_pr_class, replace=True)
sample_pos = np.random.choice(pos, samples_pr_class, replace=True)
concat_ind = np.concatenate((sample_neg, sample_pos), axis=0)
# Shuffle to avoid labels being in specific order
# (all negative then positive)
p = np.random.permutation(len(concat_ind))
self.sample_ind = concat_ind[p]
label_dist = np.mean(y_in.numpy()[self.sample_ind])
assert(label_dist & 0.45)
assert(label_dist & 0.55)
def __iter__(self):
# Hand-off data using batch_size
for i in range(int(self.epoch_size/self.batch_size)):
start = i * self.batch_size
end = min(start + self.batch_size, self.epoch_size)
yield self.sample_ind[start:end]
def __len__(self):
# Take care of the last (maybe incomplete) batch
return (self.epoch_size + self.batch_size - 1) // self.batch_size
从Keras到pyTorch：不要忘记初始化
将Keras/Tensorflow/Theano代码移植到pyTorch的过程中，最后需要注意的事情是对权重的初始化。
Keras在开发速度方面的另一个强大特点是层的默认初始化。
相反，pyTorch并没有初始化权重，而是由开发者自己来决定。为了在微调权重时获得一致的结果，我们将像如下代码那样复制默认的Keras权重初始化：
def init_weights(self):
Here we reproduce Keras default initialization weights to initialize Embeddings/LSTM weights
ih = (param.data for name, param in self.named_parameters() if 'weight_ih' in name)
hh = (param.data for name, param in self.named_parameters() if 'weight_hh' in name)
b = (param.data for name, param in self.named_parameters() if 'bias' in name)
nn.init.uniform(self.embed.weight.data, a=-0.5, b=0.5)
for t in ih:
nn.init.xavier_uniform(t)
for t in hh:
nn.init.orthogonal(t)
for t in b:
nn.init.constant(t, 0)
当我们针对一个模型比较Keras和pyTorch这两个框架时，我们可以感觉到它们有着不同的哲学和目标。
根据我的经验来看：
Keras非常适合于快速测试在给定任务上组合标准神经网络块的各种方法；
pyTorch非常适合于快速开发和测试自定义的神经网络模块，因为它有着很大的自由度和易于阅读的numpy风格的代码。
明天提醒我
我要该，理由是：
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）查看: 97|回复: 0
AI100_机器学习日报
课程推荐：深度强化学习两日教程
主题帖子积分
发表于 5&天前
AI100_机器学习日报
@the2 @wx: @wx:Thomas Wolf @爱可可-爱生活 @爱可可-爱生活
@ 出品,由@AI100运营， 过往目录 见.cn
订阅：关注微信公众号 AI100（ID：rgznai100，扫二维码），回复“机器学习日报”，加你进日报群
邮件版包括18条，本期的有完整内容21条
用日报搜索找到以前分享的内容： 今日焦点 (5)
京东等赞助的深度强化学习两日教程#DeepRL#Bootcamp. 讲师有Pieter Abbeel，Vlad Mnih ( DQN及其变体)，Andrej Karpathy，John Schulman等。实验工具是OpenAI Gym。课件和视频:
「【学习】确定最佳聚类数目的10种方法」在聚类分析的时候确定最佳聚类数目是一个很重要的问题，比如kmeans函数就要你提供聚类数目这个参数，总不能两眼一抹黑乱填一个吧。之前也被这个问题困扰过，看了很多博客，大多泛泛带过。今天把看到的这么多方法进行汇总以及代码实现并尽量弄清每个方法的原理。数据集选用比较出名的wine数据集进行分析因为我们要找一个数据集进行聚类分析，所以不需要第一列的种类标签信息，因此去掉第一列。同时注意到每一列的值差别很大，从1到100多都有，这样会造成误差，所以需要归一化，用scale函数去掉标签之后就可以开始对数据集进行聚类分析了，下面就一一介绍各种确定最佳聚类数目的方法mclust包是聚类分析非常强大的一个包，也是上课时老师给我们介绍的一个包，每次导入时有一种科技感
帮助文档非常详尽，可以进行聚类、分类、密度分析Mclust包方法有点“暴力”，聚类数目自定义，比如我选取的从1到20，然后一共14种模型，每一种模型都计算聚类数目从1到20的BIC值，最终确定最佳聚类数目，这种方法的思想很直接了当，但是弊端也就显然易见了——时间复杂度太高，效率低。63 51 64可见该函数已经把数据集聚类为3种类型了。数目分别为63、51、64。再画出14个指标随着聚类数目变化的走势图下表是这些模型的意义它们应该分别代表着相关性(完全正负相关——对角线、稍强正负相关——椭圆、无关——圆)等参数的改变对应的模型，研究清楚这些又是非常复杂的问题了，先按下不表，知道BIC值越大则说明所选取的变量集合拟合效果越好 上图中除了两个模型一直递增，其他的12模型数基本上都是在聚类数目为3的时候达到峰值，所以该算法由此得出最佳聚类数目为3的结论。mclust包还可以用于分类、密度估计等，这个包值得好好把玩。注意：此BIC并不是贝叶斯信息准则！！！最近上课老师讲金融模型时提到了BIC值，说BIC值越小模型效果越好，顿时想起这里是在图中BIC极大值为最佳聚类数目，然后和老师探讨了这个问题，之前这里误导大家了，Mclust包里面的BIC并不是贝叶斯信息准则。1.维基上的贝叶斯信息准则定义与log(likelihood)成反比，极大似然估计是值越大越好，那么BIC值确实是越小模型效果越好2.Mclust包中的BIC定义[3]这是Mclust包里面作者定义的“BIC值”，此BIC非彼BIC，这里是作者自己定义的BIC，可以看到，这里的BIC与极大似然估计是成正比的，所以这里是BIC值越大越好，与贝叶斯信息准则值越小模型越好的结论并不冲突Nbclust包是我在《R语言实战》上看到的一个包，思想和mclust包比较相近，也是定义了几十个评估指标，然后聚类数目从2遍历到15（自己设定），然后通过这些指标看分别在聚类数为多少时达到最优，最后选择指标支持数最多的聚类数目就是最佳聚类数目。可以看到有16个指标支持最佳聚类数目为3，5个指标支持聚类数为2，所以该方法推荐的最佳聚类数目为3. 转自：贝尔塔 完整内容请点击“阅读原文” via:
「如何用pyTorch改造基于Keras的MIT情感理解模型」作者 | Thomas Wolf 编译 | 雁惊寒 情感情绪检测是自然语言理解的关键要素。最近，我们改造出了一个好用的情感理解集成系统，该系统前身是MIT媒体实验室的情感检测模型DeepMoji。开源代码： 该模型最初的设计使用了TensorFlow、Theano和Keras，接着我们将其移植到了pyTorch上。与Keras相比，pyTorch能让我们更自由地开发和测试各种定制化的神经网络模块，并使用易于阅读的numpy风格来编写代码。在这篇文章中，我将详细说明在移植过程中出现的几个有趣的问题：如何使用自定义激活功能定制pyTorch LSTMPackedSequence对象的工作原理及其构建如何将关注层从Keras转换成pyTorch如何在pyTorch中加载数据：DataSet和Smart Batching如何在pyTorch中实现Keras的权重初始化 首先，我们来看看torchMoji/DeepMoji的模型。它是一个相当标准而强大的人工语言处理神经网络，具有两个双LSTM层，其后是关注层和分类器： torchMoji/DeepMoji模型 构建一个定制化的pyTorch LSTM模块 DeepMoji有一个很不错的特点：Bjarke Felbo及其协作者能够在一个拥有16亿条记录的海量数据集上训练该模型。因此，预先训练的模型在此训练集中具有非常丰富的情感和情绪表征，我们可以很方便地使用这个训练过的模型。该模型是使用针对LSTM的回归内核的Theano/Keras默认激活函数hard sigmoid训练的，而pyTorch是基于NVIDIA的cuDNN库建模的，这样，可获得原生支持LSTM的GPU加速与标准的sigmoid回归激活函数：Keras默认的LSTM和pyTorch默认的LSTM 因此，我写了一个具有hard sigmoid回归激活函数的自定义LSTM层：def LSTMCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None):& & &&&& & A modified LSTM cell with hard sigmoid activation on the input, forget and output gates.& & &&&& & hx, cx = hidden& & gates = F.linear(input, w_ih, b_ih) + F.linear(hx, w_hh, b_hh)& &&&ingate, forgetgate, cellgate, outgate = gates.chunk(4, 1)& &&&ingate = hard_sigmoid(ingate)& & forgetgate = hard_sigmoid(forgetgate)& & cellgate = F.tanh(cellgate)& & outgate = hard_sigmoid(outgate)& &&&cy = (forgetgate * cx) + (ingate * cellgate)& & hy = outgate * F.tanh(cy)& &&&return hy, cy def hard_sigmoid(x):& & &&&& & Computes element-wise hard sigmoid of x.& & See e.g. & & &&&& & x = (0.2 * x) + 0.5& & x = F.threshold(-x, -1, -1)& & x = F.threshold(-x, 0, 0)return x 这个LSTM单元必须集成在一个完整的模块中，这样才可以使用pyTorch所有的功能。这个集成相关的代码很长，建议直接引用到Github中的相关源代码。 Keras和pyTorch中的关注层 模型的关注层是一个有趣的模块，我们可以分别在Keras和pyTorch的代码中进行比较：class Attention(Module):& & &&&& & Computes a weighted average of channels across timesteps (1 parameter pr. channel).& & &&&& & def __init__(self, attention_size, return_attention=False):& && &&&&&& Initialize the attention layer& && &&&# Arguments:& && && && &attention_size: Size of the attention vector.& && && && &return_attention: If true, output will include the weight for each input token& && && && && && && && && && &used for the prediction& && &&&&&&& && &&&super(Attention, self).__init__()& && &&&self.return_attention = return_attention& && &&&self.attention_size = attention_size& && &&&self.attention_vector = Parameter(torch.FloatTensor(attention_size))& &&&def __repr__(self):& && &&&s = '{name}({attention_size}, return attention={return_attention})'& && &&&return s.format(name=self.__class__.__name__, **self.__dict__)& &&&def forward(self, inputs, input_lengths):& && &&&&&& Forward pass.& && &&&# Arguments:& && && && &inputs (Torch.Variable): Tensor of input sequences& && && && &input_lengths (torch.LongTensor): Lengths of the sequences& && &&&# Return:& && && && &Tuple with (representations and attentions if self.return_attention else None).& && &&&&&&& && &&&logits = inputs.matmul(self.attention_vector)& && &&&unnorm_ai = (logits - logits.max()).exp()& && && &# Compute a mask for the attention on the padded sequences& && &&&# See e.g. & && &&&max_len = unnorm_ai.size(1)& && &&&idxes = torch.arange(0, max_len, out=torch.LongTensor(max_len)).unsqueeze(0)& && &&&if torch.cuda.is_available():& && && && &idxes = idxes.cuda()& && &&&mask = Variable((idxes & input_lengths.unsqueeze(1)).float())& && && &# apply mask and renormalize attention scores (weights)& && &&&masked_weights = unnorm_ai * mask& && &&&att_sums = masked_weights.sum(dim=1, keepdim=True)&&# sums per sequence& && &&&attentions = masked_weights.div(att_sums)& && && &# apply attention weights& && &&&weighted = torch.mul(inputs, attentions.unsqueeze(-1).expand_as(inputs))& && && &# get the final fixed vector representations of the sentences& && &&&representations = weighted.sum(dim=1) return (representations, attentions if self.return_attention else None) class AttentionWeightedAverage(Layer):& & &&&& & Computes a weighted average of the different channels across timesteps.& & Uses 1 parameter pr. channel to compute the attention value for a single timestep.& & &&&& &&&def __init__(self, return_attention=False, **kwargs):& && &&&self.init = initializers.get('uniform')& && &&&self.supports_masking = True& && &&&self.return_attention = return_attention& && &&&super(AttentionWeightedAverage, self).__init__(** kwargs)& &&&def build(self, input_shape):& && &&&self.input_spec = [InputSpec(ndim=3)]& && &&&assert len(input_shape) == 3& && && &self.W = self.add_weight(shape=(input_shape[2], 1),& && && && && && && && && && && &name='{}_W'.format(self.name),& && && && && && && && && && && &initializer=self.init)& && &&&self.trainable_weights = [self.W]& && &&&super(AttentionWeightedAverage, self).build(input_shape)& &&&def call(self, x, mask=None):& && &&&# computes a probability distribution over the timesteps& && &&&# uses 'max trick' for numerical stability& && &&&# reshape is done to avoid issue with Tensorflow& && &&&# and 1-dimensional weights& && &&&logits = K.dot(x, self.W)& && &&&x_shape = K.shape(x)& && &&&logits = K.reshape(logits, (x_shape[0], x_shape[1]))& && &&&ai = K.exp(logits - K.max(logits, axis=-1, keepdims=True))& && && &# masked timesteps have zero weight& && &&&if mask is not None:& && && && &mask = K.cast(mask, K.floatx())& && && && &ai = ai * mask& && &&&att_weights = ai / K.sum(ai, axis=1, keepdims=True)& && &&&weighted_input = x * K.expand_dims(att_weights)& && &&&result = K.sum(weighted_input, axis=1)& && &&&if self.return_attention:& && && && &return [result, att_weights]& && &&&return result& &&&def get_output_shape_for(self, input_shape):& && &&&pute_output_shape(input_shape)& &&&def compute_output_shape(self, input_shape):& && &&&output_len = input_shape[2]& && &&&if self.return_attention:& && && && &return [(input_shape[0], output_len), (input_shape[0], input_shape[1])]& && &&&return (input_shape[0], output_len)& &&&def compute_mask(self, input, input_mask=None):& && &&&if isinstance(input_mask, list):& && && && &return [None] * len(input_mask)& && &&&else:return None 如你所见，主要的算法大致相同，但PyTorch代码中的大部分都是注释，而Keras则需要编写几个附加函数并进行调用。在编写和调试自定义模块和层时，pyTorch是一个更快的选择；而对于快速训练和测试由标准层构建的模型时，Keras显然更加合适。 PackedSequence对象的工作原理 Keras有一个不错的掩码功能可以用来处理可变长度序列。那么在pyTorch中又该如何处理这个呢？可以使用PackedSequences！ pyTorch文档中有关PackedSequence的介绍并不是很详细，所以这里会详细描述它的细节。一个拥有5个序列18个令牌的典型NLP批次 假设我们有一批可变长度的序列（在NLP应用中通常就是这样的）。为了在GPU上并行计算这样一个批次，我们希望：尽可能多地并行处理这个序列，因为LSTM隐藏状态依赖于每个序列的前一个时间步长，以及以正确的时间步长（每个序列的结尾）停止每个序列的计算。 这可以通过使用pyTorch中的PackedSequence类来实现。我们首先通过减少长度来对序列进行排序，并将它们放到在张量中。然后对张量和序列长度列表调用pack_padded_sequence函数# input_seqs is a batch of input sequences as a numpy array of integers (word indices in vocabulary) padded with zeroasinput_seqs = Variable(torch.from_numpy(input_seqs.astype('int64')).long()) # First: order the batch by decreasing sequence lengthinput_lengths = torch.LongTensor([torch.max(input_seqs[i, :].data.nonzero()) + 1 for i in range(input_seqs.size()[0])])input_lengths, perm_idx = input_lengths.sort(0, descending=True)input_seqs = input_seqs[perm_idx][:, :input_lengths.max()] # Then pack the sequencespacked_input = pack_padded_sequence(input_seqs, input_lengths.cpu().numpy(), batch_first=True) PackedSequence对象包括：一个data对象：一个torch.Variable（令牌的总数，每个令牌的维度），在这个简单的例子中有五个令牌序列（用整数表示）：（18，1）一个batch_sizes对象：每个时间步长的令牌数列表，在这个例子中为：[6，5，2，4，1] 用pack_padded_sequence函数来构造这个对象非常的简单：如何构造一个PackedSequence对象（batch_first = True） PackedSequence对象有一个很不错的特性，就是我们无需对序列解包（这一步操作非常慢）即可直接在PackedSequence数据变量上执行许多操作。特别是我们可以对令牌执行任何操作（即对令牌的顺序/上下文不敏感）。当然，我们也可以使用接受PackedSequence作为输入的任何一个pyTorch模块（pyTorch 0.2）。例如，在我们的NLP模型中，我们可以在对PackedSequence对象不解包的情况下连接两个LSTM模块的输出，并在此对象上应用LSTM。我们还可以在不解包的情况下执行关注层的一些操作。 pyTorch中的智能数据加载：DataSets和Batches 在Keras中，数据加载和批处理通常隐藏在fit_generator函数中。重申一遍，如果你想要快速地测试模型，Keras很好用，但这也意味着我们不能完全控制模型中的重要部分。在pyTorch中，我们将使用三个类来完成这个任务：一个DataSet类，用于保存、预处理和索引数据集一个BatchSampler类，用于控制样本如何批量收集一个DataLoader类，负责将这些批次提供给模型 我们的DataSet类非常简单：class DeepMojiDataset(Dataset):& & &&& A simple Dataset class.& & # Arguments:& && &&&X_in: Inputs of the given dataset.& && &&&y_in: Outputs of the given dataset.& &&&# __getitem__ output:& && &&&(torch.LongTensor, torch.LongTensor)& & &&&& & def __init__(self, X_in, y_in):& && &&&# Check if we have Torch.LongTensor inputs (assume Numpy array otherwise)& && &&&if not isinstance(X_in, torch.LongTensor):& && && && &X_in = torch.from_numpy(X_in.astype('int64')).long()& && &&&if not isinstance(y_in, torch.LongTensor):& && && && &y_in = torch.from_numpy(y_in.astype('int64')).long()& && && &self.X_in = torch.split(X_in, 1, dim=0)& && &&&self.y_in = torch.split(y_in, 1, dim=0)& &&&def __len__(self):& && &&&return len(self.X_in)& &&&def __getitem__(self, idx):& && &&&return self.X_in[idx].squeeze(), self.y_in[idx].squeeze() 我们BatchSampler则更有趣。我们有几个小的NLP数据集，用于微调情感情绪检测模型。这些数据集有着不同的长度和某些不平衡的种类，所以我们想设计这么一个批量采样器：在预先定义的样本数中收集批次，这样我们的训练过程就可以不依赖于批次的长度能够从不平衡的数据集中以平衡的方式进行采样。 在PyTorch中，BatchSampler是一个可以迭代生成批次的类，BatchSampler的每个批处理都包含一个列表，其中包含要在DataSet中选择的样本的索引。因此，我们可以定义一个用数据集类标签向量来初始化的BatchSampler对象，以构建满足我们需求的批次列表：class DeepMojiBatchSampler(object):& & &&&A Batch sampler that enables larger epochs on small datasets and& && &&&has upsampling functionality.& & # Arguments:& && &&&y_in: Labels of the dataset.& && &&&batch_size: Batch size.& && &&&epoch_size: Number of samples in an epoch.& && &&&upsample: Whether upsampling should be done. This flag should only be& && && && &set on binary class problems.& && &&&seed: Random number generator seed.& & # __iter__ output:& && &&&iterator of lists (batches) of indices in the dataset& & &&&& &&&def __init__(self, y_in, batch_size, epoch_size, upsample, seed):& && &&&self.batch_size = batch_size& && &&&self.epoch_size = epoch_size& && &&&self.upsample = upsample& && && &np.random.seed(seed)& && && &if upsample:& && && && &# Should only be used on binary class problems& && && && &assert len(y_in.shape) == 1& && && && &neg = np.where(y_in.numpy() == 0)[0]& && && && &pos = np.where(y_in.numpy() == 1)[0]& && && && &assert epoch_size % 2 == 0& && && && &samples_pr_class = int(epoch_size / 2)& && &&&else:& && && && &ind = range(len(y_in))& && && &if not upsample:& && && && &# Randomly sample observations in a balanced way& && && && &self.sample_ind = np.random.choice(ind, epoch_size, replace=True)& && &&&else:& && && && &# Randomly sample observations in a balanced way& && && && &sample_neg = np.random.choice(neg, samples_pr_class, replace=True)& && && && &sample_pos = np.random.choice(pos, samples_pr_class, replace=True)& && && && &concat_ind = np.concatenate((sample_neg, sample_pos), axis=0)& && && && & # Shuffle to avoid labels being in specific order& && && && &# (all negative then positive)& && && && &p = np.random.permutation(len(concat_ind))& && && && &self.sample_ind = concat_ind[p]& && && && & label_dist = np.mean(y_in.numpy()[self.sample_ind])& && && && &assert(label_dist & 0.45)& && && && &assert(label_dist & 0.55)& &&&def __iter__(self):& && &&&# Hand-off data using batch_size& && &&&for i in range(int(self.epoch_size/self.batch_size)):& && && && &start = i * self.batch_size& && && && &end = min(start + self.batch_size, self.epoch_size)& && && && &yield self.sample_ind[start:end]& &&&def __len__(self):& && &&&# Take care of the last (maybe incomplete) batchreturn (self.epoch_size + self.batch_size - 1) // self.batch_size 从Keras到pyTorch：不要忘记初始化 将Keras/Tensorflow/Theano代码移植到pyTorch的过程中，最后需要注意的事情是对权重的初始化。Keras在开发速度方面的另一个强大特点是层的默认初始化。相反，pyTorch并没有初始化权重，而是由开发者自己来决定。为了在微调权重时获得一致的结果，我们将像如下代码那样复制默认的Keras权重初始化：def init_weights(self):& & &&&& & Here we reproduce Keras default initialization weights to initialize Embeddings/LSTM weights& & &&&& & ih = (param.data for name, param in self.named_parameters() if 'weight_ih' in name)& & hh = (param.data for name, param in self.named_parameters() if 'weight_hh' in name)& & b = (param.data for name, param in self.named_parameters() if 'bias' in name)& & nn.init.uniform(self.embed.weight.data, a=-0.5, b=0.5)& & for t in ih:& && &&&nn.init.xavier_uniform(t)& & for t in hh:& && &&&nn.init.orthogonal(t)& & for t in b:& && &&&nn.init.constant(t, 0) 结论 当我们针对一个模型比较Keras和pyTorch这两个框架时，我们可以感觉到它们有着不同的哲学和目标。根据笔者的经验来看：Keras非常适合于快速测试在给定任务上组合标准神经网络块的各种方法；pyTorch非常适合于快速开发和测试自定义的神经网络模块，因为它有着很大的自由度和易于阅读的numpy风格的代码。 原文： SDCC 2017“人工智能技术实战线上峰会”将在CSDN学院以直播互动的方式举行。作为SDCC系列技术峰会的一部分，来自阿里巴巴、微软、商汤科技、第四范式、微博、出门问问、菱歌科技的AI专家，将针对机器学习平台、系统架构、对话机器人、芯片、推荐系统、Keras、分布式系统、NLP等热点话题进行分享。先行者们正在关注哪些关键技术？如何从理论跨越到企业创新实践？你将从本次峰会找到答案。每个演讲时段均设有答疑交流环节，与会者和讲师可零距离互动。&&via:
【Luminoth：计算机视觉深度学习工具集(基于TensorFlow/Sonnet)】《Luminoth: Open source toolkit for Computer Vision》
GitHub: https ://github .com/tryolabs/luminoth
【灰度图像自动上色(CNN/Inception-ResNet-v2)】’Deep Koalarization - Grayscale Image Colorization using deep CNN and Inception-ResNet-v2 (DD2424 Deep Learning in Science course at KTH 2017)' by Federico Baldassarre GitHub: https ://github .com/baldassarreFe/deep-koalarization ref:...全文： 全文：
「动态 | 共筑开放AI生态：ONNX标准得到华为、英特尔等更多厂商支持」AI科技评论消息，今年九月，微软和 Facebook 发布了一个全新的开源项目——ONNX，欲借此打造一个开放的深度学习开发工具生态系统。该项目的目的是让不同的神经网络开发框架做到互通互用。详细信息可参见Facebook、微软联合推出 ONNX 标准，号称要解决开发框架碎片化。早前，Microsoft Cognitive Toolkit、PyTorch 和 Caffe2 均已宣布支持 ONNX。而就在今天，AMD、ARM、华为、IBM、英特尔、高通同时宣布支持ONNX。这些公司和Facebook、微软一样，认识到了ONNX开源系统给工程师和研究者提供的便利性，它可以让研究人员轻易地在当前顶尖的机器学习工具之间进行转换，并为项目选择最好的组合方式。与此同时，ONNX还可以让更多的开发人员更容易地进行优化。任何支持ONNX模型的工具都可以受益，因为ONNX兼容不同的运行时间和库，其设计初衷是让业界最好的人工智能硬件的性能最大化发挥。Facebook表示，ONNX是他们的人工智能团队中有关深度学习方法的重要组成部分，他们一直致力于推动人工智能的前沿发展，开发出更好的学习算法。一旦发现新的突破，他们就会试图把这种最先进的技术尽快交付给整个团队。一旦有了ONNX，他们就可以专注于将大量人工智能相关的研究和产品更紧密地结合在一起，这样就能更快地进行创新和展开相关研究。Facebook同时表示，很高兴华为、英特尔、高通等公司加入ONNX开放系统，他们也在邀请其他公司加入到ONNX生态系统中来。ONNX支持在不同的框架之间进行互操作，并能简化从研究到生产的操作，将有助于提高人工智能研究的创新速度。可以在 GitHub 上查看更多细节。地址：：Facebook researchAI科技评论编译整理。—————&&AI 科技评论招人啦！&&—————你即将从事的工作内容：报道海内外人工智能相关学术会议，形成具有影响力的报道内容；采访高校学术青年领袖，输出人工智能领域的深度观点；跟进国内外学术热点，深入剖析学术动态；我们希望你是这样的小伙伴：英语好，有阅读英文科技网站的习惯；兴趣广，对人工智能有关注及了解；态度佳，有求知欲，善于学习；欢迎发送简历到 guoyixin@leiphone.com—————&&给爱学习的你的福利&&—————3个月，从无人问津到年薪30万的秘密究竟是什么？答案在这里——崔立明授课【推荐系统算法工程师-从入门到就业】3个月算法水平得到快速提升，让你的职业生涯更有竞争力！长按识别下方二维码（或阅读原文戳开链接）抵达课程详细介绍~———————————————————— via:
「【2018年AI发展8大趋势】创业公司被并购，科技巨头或成最大赢家」【AI WORLD 2017世界人工智能大会倒计时 28天】大会早鸟票已经售罄，现正式进入全额票阶段。还记得去年一票难求的AI WORLD 2016盛况吗？今年，百度副总裁、AI技术平台体系总负责人王海峰、微软全球资深副总裁，微软亚洲互联网工程院院长王永东等产业领袖已经确认出席大会并发表演讲。谷歌、亚马逊、BAT、讯飞、京东和华为等企业重量级嘉宾也已确认出席。本届大会特设智能医疗论坛，并邀请到来自谷歌、卡内基梅隆大学、康奈尔大学等多位相关领域的专家和创业者，就“医疗 AI 在哪些方面已经或即将超越人类医生”、“独立的AI医疗系统何时能够出现”等问题进行展望、分享。智能医疗的真实发展现状如何？技术瓶颈何在？未来最有潜力的应用是哪些？请来世界人工智能大会智能医疗论坛寻求答案。更多大会日程陆续揭晓中……参加大会，请关注新智元微信公众号或访问活动行页面：了解更多 1新智元编译&&来源：编译：常佩琦 【新智元导读】本文综合了IDC和Gartner等机构的预测，对2018 AI领域的发展进行预测，包括大公司、算法、兼并等多个方面。 计算分析大数据绝不是一时性的。随着数据量的不断增长，分析大数据的方式也将改善。涉及到预测性分析（Predictive Analytics）的应用时，我们只看到冰山一角。它通过数据挖掘、机器学习、AI技术帮助组织机构分析现有数据，比如预测销售额、优化营销活动等。这些人工智能技术都在深刻地改变着我们的生活。 以下是AI世界、大数据、预测分析、机器学习的关键数据：2018年，75%的开发商都将在一个或者多个业务或服务中包含AI功能——IDC2019年，AI 将辅助100%的物联网——IDC2020年，30%的公司都将使用AI，至少增加一个主要销售环节——Gartner2020年，算法将改变全球数十亿工人的行为——Gartner2020年，人工智能市场将超过400亿美元——Constellation Research2025年，AI将驱动95%的用户交互——Servion 2018，8大AI趋势 亚马逊、谷歌、Facebook、IBM将成为AI领头羊。大公司拥有大量资源来收集数据，因此会有更多数据为其所用。 以下是AI领域的顶尖玩家： 亚马逊：投资人工智能已超过20年抓取超过50亿网页的数据亚马逊物流中心有超过50万张描述产品的JPEG图像和相应的JSON元数据文件每日监测全球广播、印刷物、网络新闻的记录超过40亿份近1亿图像和具有注释的视频亚马逊的Echo领先语音助理市场 谷歌：是拥有最大存储库的数据集之一，数据达10-15Exabyte——Cirrus Insight专注于应用和产品开发，而非长期AI研究超过1300位研究人员的团队——谷歌大脑占据声控助理市场23.8%的用户份额——Voicebot任何人都能使用的机器学习开源平台TensorFlow谷歌地球数据库大约是3017TB或者近3Petabytes——Google Earth Blog谷歌街景有近20Petabytes的街道照片—— Peta Pixel Facebook每天处理25亿的内容和500多TB的数据——Tech CrunchFacebook有约80名人工智能研究员——FAIR日均生成20亿“赞”和3亿照片——Tech Crunch每30分钟扫描月105TB数据——Tech Crunch建有一个62000平方英尺的数据中心，可以容纳500台机架每天用超过40种语言翻译20亿用户帖，8亿用户可以看到翻译——Fortune 在部署机器学习和产品应用开发方面，谷歌很可能处在最前沿。谷歌的研究范围涵盖机器学习、自然语言处理、机器学习算法和技术、机器人技术等领域。 全球100家最有潜力AI公司 投资人工智能的第二梯队，如英特尔、推特等，将追随拥有数据的大公司，并使用它们的数据算法。数据交易将发生在行业内部，算法和技术将得以巩固。 谷歌、FB等巨头收购小公司后，算法将被集成到其核心平台。谷歌收购了DeepMind以获取竞争优势。FB收购了Wit.ai来提升语音识别和语音接口业务。 所有的人工智能公司都将想方设法获得海量数据集，来实现其AI壮志。这些公司会开始收集众包数据。公司已经找到评估众包数据质量和真实性的不同方法。企业方会从这些数据中受益，消费者也得到了话语权。 谷歌通过众包获取了大量图片，来构建其成像算法。谷歌还通过众包改进翻译等服务。亚马逊通过众包AI来提高Alexa的技能。 CBInsights统计数据显示，收购AI公司的竞赛已经开始。2018年竞争会越发激烈。很多机器学习和AI的小公司都会被大企业收购，原因有二： 首先，AI无法在缺少数据集的情况下独立工作。大公司拥有大量数据，小公司会失去竞争力。其次，没有数据的算法毫无用处。反之亦然。数据是算法的核心，因此获取大量数据将成为重中之重。 大公司将开源算法和工具集来获取市场份额。基于市场的数据访问和算法进入壁垒将会减少，新的AI应用将会增加。通过民主化，此前缺乏AI工具的小公司将更容易获得大量数据，来训练复杂的AI算法。 Siri和Alexa是两个最受欢迎的人机交互工具。将会有更多的类似产品出现。例如，机器能够根据用户讲话的语调识别情绪。2018年，农业和医药领域的人机交互也会增多。 制造业、客服、金融、医疗、交通等行业已经受到人工智能的影响。明年人工智能将会影响更多的垂直行业，包括：保险、法律、传媒、教育、健康等。 与隐私、安全相关的担忧，（如保密银行账户、健康信息），会促进对人工智能安全性的研究。2018年，安全和隐私问题会得到一定的解决，也可能会有新的发展。 伦理问题也值得关注。需要强调的问题包括：人工智能将如何伤害／促进人类。还有一些对于人工智能取代人类的担忧。 总而言之，虽然AI已经存在了很多年，但目前还处于起步阶段。人工智能还有很长的路要走。 原文地址：@Unfoldlabs/the-world-of-artificial-intelligence-6cec415edc56【扫一扫或点击阅读原文抢购大会门票】AI WORLD 2017 世界人工智能大会购票二维码：&&via:
「ADL报名 | 不懂理论何谈应用？」本期CCF学科前沿讲习班《计算经济学的理论与应用》邀请了学术界计算经济学领域以及业界相关应用方向权威专家，将从计算机经济学的基本理论、机制设计的理论、一些具体的前沿研究课题、相关理论在金融和区块链等相关行业的应用等方面对计算经济学的原理及应用进行详尽的解读和讲解。 特邀讲者： 陆品燕：本期学术主任、上海财经大学信息学院教授、理论计算机科学研究中心主任& && && && & 讲座题目：计算经济学概论 邓小铁：上海交通大学教授、国家千人特聘专家& && && && & 讲座题目：基于数据的互联网市场定价与资源分配原理所面临的行为学挑战 盛子夏：蚂蚁金服集团人工智能商业决策总监讲座题目：人工智能驱动金融生活 陶曲明：万向区块链股份公司副总经理& && && && & 讲座题目：区块链与机制设计 黄志毅：香港大学计算机系助理教授& && && && & 讲座题目：基于数据的机制设计理论 Nick Gravin:上海财经大学副教授、青年千人& && && && & 讲座题目：Budget Feasible Procurement Mechanisms 唐平中：清华大学交叉信息研究员助理教授，青年千人& && && && &讲座题目：最优机制设计 地点：上海财经大学信息学院一楼报告厅（上海杨浦区武东路100号）报名方式：请登录 &&或长按以下二维码报名& && & 活动详细介绍请点击【阅读原文】 via:
香港科技大学在读博士生张鹏博：借鉴师生互动模式来训练机器学习模型 | 分享总结
【社交媒体假新闻检测快速指南】《A Quick Guide to Fake News Detection on Social Media》by Kai Shu, Huan Liu
2017年KDD，Sigir以及Recsys会议被接收的论文早已公示，本文对这些会议中Attention Model相关的10篇论文进行了整理，为大家介绍Attention Model的发展和应用。
【机器学习实践指南】在今天的文章中，我会列出 7 个步骤（和 50 多个资源）帮助你开启这个令人兴奋的计算机科学领域的大门，并逐渐成为一个机器学习高手。详见（来自：Linux中国）
【阿里巴巴宣布成立全球研究院“达摩院”】阿里巴巴首席技术官张建峰称，推出全球技术开发研究项目“达摩院”，未来三年对基础科学研发投资将超过1000亿元。该院由全球实验室，高校联合研究所，全球前沿创新研究计划三大部分组成，研究包括：量子计算、机器学习、基础算法、网络安全、视觉计算、自然语...全文：
高斯过程回归？效果意想不到的好:在R里面你可以用kernlab包的gausspr函数进行预测，高斯过程还能解决分类问题
@数据分析招聘
#热门微博机器学习# Batch Normalization（）及其在TensorFlow里的实现（）。对于连续特征的神经网络挺有效的哦。
转发于 12:32
大BN目前基本快成为DL的标配了，很有了解的必要，跟风转个去年写的BN导读：（Batch Normalization导读）
【港科大KDD 2017录用论文作者详解：基于异构信息网络元结构融合的推荐系统】 在KDD 2017上，香港科技大学计算机系博士生赵欢作为第一作者的论文 Meta-Graph Based Recommendation Fusion over Heterogeneous Information Networks 被 research track接收并做口头报告。
【文本词嵌入详解】《What Are Word Embeddings for Text? | Machine Learning Mastery》by Jason Brownlee
【深度增强学习训练营(videos/slides)】“Deep RL Bootcamp - 26-27 August 2017 | Berkeley CA”
Powered by}