精华内容
下载资源
问答
  • 深度学习:词嵌入Embedding

    万次阅读 多人点赞 2017-07-26 11:08:06
    嵌入嵌入其实就是将数据的原始表示表示成模型可处理的或者是更dense的低... 假设一共有个物体,每个物体有自己唯一的id,那么从物体的集合到有一个trivial的嵌入,就是把它映射到中的标准基,这种嵌入叫做On...

    http://blog.csdn.net/pipisorry/article/details/76095118

    词嵌入

    词嵌入其实就是将数据的原始表示表示成模型可处理的或者是更dense的低维表示(lz)。

    One-hot Embedding

            假设一共有m个物体,每个物体有自己唯一的id,那么从物体的集合到\mathbb R^m有一个trivial的嵌入,就是把它映射到\mathbb R^m中的标准基,这种嵌入叫做One-hot embedding/encoding.

    [数据预处理:独热编码(One-Hot Encoding)]

    一般使用的低维embedding

            应用中一般将物体嵌入到一个低维空间\mathbb R^n(n \ll m) ,只需要再compose上一个从\mathbb R^m\mathbb R^n的线性映射就好了。每一个n\times m 的矩阵M都定义了\mathbb R^m\mathbb R^n的一个线性映射: x \mapsto Mx。当x 是一个标准基向量的时候,Mx对应矩阵M中的一列,这就是对应id的向量表示。

    这个概念用神经网络图来表示如下:

            从id(索引)找到对应的One-hot encoding,然后红色的weight就直接对应了输出节点的值(注意这里没有activation function),也就是对应的embedding向量。

    Note:

    1 M随机初始化并且是可训练的,查找x对应的embedding表示其实 等价于 找x在下面这个网络中的权重,而这些权重是可训练的,且对应于矩阵M。

    2  关于嵌入维度数量(New Embedding维度)的一般经验法则:

    embedding_dimensions =  number_of_categories**0.25

    也就是说,嵌入矢量维数应该是类别数量的 4 次方根。如词汇量为 81,建议维数为 3。

    低维向量嵌入在tensorflow中的实现:tf.nn.embedding_lookup()

        embedding_map = tf.get_variable(  # 默认参数trainable = True,可训练
            name="embedding_map",
            shape=[self.config.vocab_size, self.config.embedding_size],
            initializer=self.initializer)
        seq_embeddings = tf.nn.embedding_lookup(embedding_map, self.input_seqs)

    和下面类似:

    matrix = np.random.random([1024, 64])  # 64-dimensional embeddings
    ids = np.array([0, 5, 17, 33])
    print matrix[ids]  # prints a matrix of shape [4, 64] 

    从id类特征(category类)使用embedding_lookup的角度来讲:

    1、onehot编码神经网络处理不来。embedding_lookup虽然是随机化地映射成向量,看起来信息量相同,但其实却更加超平面可分。

    2、embedding_lookup不是简单的查表,id对应的向量是可以训练的(带有label信息),训练参数个数应该是 category num*embedding size,也就是说lookup是一种全连接层。详见 brain of mat kelcey

    3、word embedding其实是有了一个距离的定义,即出现在同一上下文的词的词向量距离应该小,这样生成向量比较容易理解。autoencode、pca等做一组基变换,也是假设原始特征值越接近越相似。但id值的embedding应该是没有距离可以定义,没有物理意义,只是一种特殊的全连接层。

    4、用embedding_lookup做id类特征embedding由google的deep&wide提出。阿里 第七章 人工智能,7.6 DNN在搜索场景中的应用(作者:仁重) 中提下了面对的困难,主要是参数数量过多(引入紫色编码层)和要使用针对稀疏编码特别优化过的全连接层( Sparse Inner Product Layer )等。

    5、在分类模型中用这种id类特征,主要是希望模型把这个商品记住。但id类特征维度太高,同一个商品的数据量也不大,因此也常常用i2i算法产出的item embedding来替代id特征。

    [tf.nn.embedding_lookup函数原理?]

    [求通俗讲解下tensorflow的embedding_lookup接口的意思?]

    [tf.nn.embedding_lookup]

    [what-does-tf-nn-embedding-lookup-function-do]

    某小皮

            词嵌入有其它很多方法如word2vec,bert等,embedding lookup只是其中一种。我们可以只使用简单的embedding lookup让模型自己去训练;也可以将embedding lookup中的矩阵先通过word2vec训练好进行初始化,再通过embedding lookup训练;或者只使用vord2vec进行初始化后,embedding lookup设置成不训练。

    Word2vec

    [深度学习:词嵌入之word2vec]

    其它的Word Representation

     

    Word level representation from characters embeddings    Bidirectional LSTM on top of word representation to extract contextual representation of each word

    右图中的context应该是指句子的上下文。

    [Sequence Tagging with Tensorflow]

     

    句子embedding

    1 词向量直接求平均或者最大值:对句子中所有单词直接求平均, 每个单词的权重相同, 得到sentence embedding。

    2 使用每个词的TF-IDF值为权重, 加权平均, 得到sentence embedding。

    sif sentence embedding使用预训练好的词向量, 使用加权平均的方法, 对句子中所有词对应的词向量进行计算, 得到整个句子的embedding向量:模型的输入是一个已有的word embedding,然后通过加权求平均的方法求得sentence的embedding,最后使用主成分分析去掉一些special direction,即在完成词加权平均之后,移除所有行为向量的公共主成分:v_s -= u*u^t*v_s。

            其中v_s表示加权平均之后的结果,u表示所有句子向量进行特征分解之后,最大特征值对应的特征向量,相当于所有句子向量的最大主成分,这样就把所有行为链路中彼此相关的一部分去除,只保留反应序列特性的成分。
    [论文阅读 A SIMPLE BUT TOUGH-TO-BEAT BASELINE FOR SEN- TENCE EMBEDDINGS]

    [A simple but tough-to-beat baseline for sentence embedding]

     

     

    词向量维度的选择

    On the Dimensionality of Word Embedding

    词向量集合的距离度量:PIP loss,基于此可以选择最优词向量维度

    文章分析了LSA, Word2vec, Glove对于不同任务的最优维度


    [On the Dimensionality of Word Embedding]

    from: http://blog.csdn.net/pipisorry/article/details/76095118

    ref: [tensorflow对嵌入概念的解释]

    [深度学习、NLP 和表示法(Chris Olah 的博客)]

    [TensorFlow Embedding Projector]

     

    展开全文
  • 嵌入

    千次阅读 2019-06-27 11:01:14
    所谓词嵌入,通俗来讲,是指将一个词语(word)转换为一个向量 (vector)表示, 所以词嵌入有时又被叫作“word2vec"。在CharRNN中,输入序列数据的每一步是一个字母 。 具体来说,先对这些字母使用了独热编码再输入到 ...

    所谓词嵌入,通俗来讲,是指将一个词语(word)转换为一个向量 (vector)表示, 所以词嵌入有时又被叫作“word2vec"。在CharRNN中,输入序列数据的每一步是一个字母 。 具体来说,先对这些字母使用了独热编码再输入到 RNN 中,在实际应用中 , 每一步只输入一个字母显然是不太合适的 , 更加高效的方法是每一步输入一个单词 。如果还继续使用独热表示,那么每一步输入的向量维数会非常大,比如说使用的单词的数量为 10000,那么独热表示形成的向量形状是 (10000,)。另外一方面,独热表示实际上完全平等看待了单词表中的所有单词 ,忽略了单词之间的联系 。所谓 word2vec,是指学习一个映射f,它可以将单词变成向量表示: vec = f(word)。在 RNN 的每一步输入中,不再用词语的独热表示,而是用映射之后的 vec输入模型,这样模型不仅会得到更丰富的有关词语的信息,而且输入的维数还下降了,因此性能会大大提高。使用密集和低维向量的好处之一是利于计算:大多数神经网络工具包无法很好地处理非常高维的稀疏向量。

    本文会介绍两种词嵌入的方法 CBOW 和 Skip-Gram词嵌入的原理,然后会以 Skip-Gram 为例,详细介绍怎么在 TensorFlow 中实现它 。

    一、词嵌入的原理

    应当如何学习到上述的映射 f ? 一般来说有两种方法 , 一种方法是基于 “计数” 的 , 即在大型语料库中 , 计算一个词语和另一个词语同时出现的概率,将经常同时出现的词映射到向量空间的相近位置,另一种方法是基于“预测” 的,即从一个词或几个词出发 , 预测它们可能的相邻词,在预测过程中自然而然地学习到了词嵌入的映射 f。 通常使用的是基于预测的方法。具体来讲, 又有两种基于预测的方法,分别叫 CBOW 和 Skip-Gram,接下来分别介绍下它们的原理。

    1、CBOW 实现词嵌入的原理

    CBOW 的全称为 Continuous Bag of Words,即连续词袋模型 ,它的核心思想是利用某个词语的上下文预测这个词语 。

    输入的单词被独热表示为x,经过一个全连接层得到隐含层 h, h再经过一个全连接层得到输出 y。 V是词汇表的中单词的数量,因此 独热表示的 x的形状是(V,)。输出 y相当于做 Softmax操作前的 logits, 它的形状也是(V,)。隐层的神经元数量为 N, N一般设定为小于 Y的值,如 256, 512等。 通过BP(反向传播)算法及随机梯度下降来学习权重。训练完成后,隐层的值被当作是词的嵌入表示,即 word2vec 中的“ vec”。

    损失定义:在上述结构中,整个网络相当于是一个 V 类的分类器 。 V 是单词表中单词的数量,这个值往往非常大,所以比较难以训练,通常会简单修改网络的结构,将 V 类分类变成两类分类。模型会做一个两类分类:判断一个词汇是否属于“躁声词汇” 。 一般地,设上下文为 h , 该上下文对应的真正目标词汇为wt,躁声词汇为w,优化函数是:,其中: 代表的是利用 wt 和 h 对应的词嵌入向量进行一次 Logistic 回归得到的概率。这样的 Logistic 回归实际可以看作一层神经网络 。 因为 wt 为真实的目标单词,所以希望对应的 D=1。 另外w为与句子没关系的词汇,所以希望对应的D=O。通过优化二分类损失函数来训练模型后,最后得到的模型中的隐含层可以看作是 word2vec 中的“ vec”向量 。

     

    2、Skip-Gram 实现词嵌入的原理

    Skip-Gram 方法和 CBOW 方法正好相反,使用“出现的词”来预测“上下文文中词”。例如在 The man fell in love with the (woman)中,woman-> man, woman -> fell。

     

    二、词嵌入tensorflow实现(Skip-Gram)

    1、下载语料库

    # 语料库下载地址
    url = 'http://mattmahoney.net/dc/'
    
    def maybe_download(filename, expected_bytes):
      """
      这个函数的功能是:
          如果filename不存在,就在上面的地址下载它。
          如果filename存在,就跳过下载。
          最终会检查文字的字节数是否和expected_bytes相同。
      """
      if not os.path.exists(filename):
        print('start downloading...')
        filename, _ = urllib.request.urlretrieve(url + filename, filename)
      statinfo = os.stat(filename)
      if statinfo.st_size == expected_bytes:
        print('Found and verified', filename)
      else:
        print(statinfo.st_size)
        raise Exception(
            'Failed to verify ' + filename + '. Can you get to it with a browser?')
      return filename
    
    # 下载语料库text8.zip并验证下载
    filename = maybe_download('text8.zip', 31344016)

     

    2、读取语料库数据并转换格式

    # 将语料库解压,并转换成一个word的list
    def read_data(filename):
      """
      这个函数的功能是:
          将下载好的zip文件解压并读取为word的list
      """
      with zipfile.ZipFile(filename) as f:
        data = tf.compat.as_str(f.read(f.namelist()[0])).split()
      return data
    
    vocabulary = read_data(filename)
    print('Data size', len(vocabulary)) # 总长度为1700万左右
    # 输出前100个词。
    print(vocabulary[0:100])

     

    3、用语料库制作单词表

    单词表就是,将单词映射为一个数字,这个数字是该单词的 id。如5234 代表单词 anarchism, 3081 代表单词 originated。单词表一般只包含最常用的些词。对于剩下的不常用的词,会将其换为一个罕见词标记“ UNK”。所有的罕见词都会被映射为同一个单词 id。原来的训练数据 vocabulary是一个 单词的列表,在经过转换后, 变成了一个单词 id 的列表,即程序中的变量 data,它的形式是[5234, 3081, 12, 6, 195, 2, 3134, 46, ....]。

    # 制作一个词表,将不常见的词变成一个UNK标识符
    # 词表的大小为5万(即我们只考虑最常出现的5万个词)
    vocabulary_size = 50000
    
    def build_dataset(words, n_words):
      """
      函数功能:将原始的单词表示变成index
      """
      count = [['UNK', -1]]
      count.extend(collections.Counter(words).most_common(n_words - 1))
      dictionary = dict()
      for word, _ in count:
        dictionary[word] = len(dictionary)
      data = list()
      unk_count = 0
      for word in words:
        if word in dictionary:
          index = dictionary[word]
        else:
          index = 0  # UNK的index为0
          unk_count += 1
        data.append(index)
      count[0][1] = unk_count
      reversed_dictionary = dict(zip(dictionary.values(), dictionary.keys()))
      return data, count, dictionary, reversed_dictionary
    
    data, count, dictionary, reverse_dictionary = build_dataset(vocabulary,
                                                                vocabulary_size)
    del vocabulary  # 删除已节省内存
    # 输出最常出现的5个单词
    print('Most common words (+UNK)', count[:5])
    # 输出转换后的数据库data,和原来的单词(前10个)
    print('Sample data', data[:10], [reverse_dictionary[i] for i in data[:10]])
    # 我们下面就使用data来制作训练集
    data_index = 0

     

    4、生成训练样本

    变量 data包含了训练集中所有的数据,现在把它转换成训练时使用的 batch 数据 。一个 batch 可以看作是一些“单词对”的集合 , 如 woman-> man, woman -> fell,箭头左边表示“出现的单词”,右边表示该单词所在的“上下文”中的单词,这是采用Skip-Gram的方法。生成训练样本方法如下,它一共有三个参数,batch_size是单词对的个数,skip_window用来决定一个句子上下文的长度,在生成单词对时 ,会在语料库中先取出一个长度为 skip_window*2+ 1 连续单词列表,这个连续的单词列表是上面程序中的变量 buffer。 buffer 中最中间的那个单词是 Skip-Gram 方法中“ 出现的单词”,其余 skip_window*2 个单词是它的“上下文”。会在 skip_window*2 个单词中随机选取 num_skips 个单词,放入标签 labels。

    如 skip_window=1, num_skips=2 的情况 。 首先选取一个长度为 3 的 buffer,假设是[’anarchism’, ’originated’,’as'],此时 originated 为中心单词, 剩下的两个单词为上下文 。再在这两个单词中选择 num_skips 个词形成标签 。 由于 num_skips = 2,所以只能将这两个单词都选上(标签不能重复), 最后生成的训练数据为 originated-> anarchism和 originated-> as。

    def generate_batch(batch_size, num_skips, skip_window):
      # data_index相当于一个指针,初始为0
      # 每次生成一个batch,data_index就会相应地往后推
      global data_index
      assert batch_size % num_skips == 0
      assert num_skips <= 2 * skip_window
      batch = np.ndarray(shape=(batch_size), dtype=np.int32)
      labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)
      span = 2 * skip_window + 1  # [ skip_window target skip_window ]
      buffer = collections.deque(maxlen=span)
      # data_index是当前数据开始的位置
      # 产生batch后就往后推1位(产生batch)
      for _ in range(span):
        buffer.append(data[data_index])
        data_index = (data_index + 1) % len(data)
      for i in range(batch_size // num_skips):
        # 利用buffer生成batch
        # buffer是一个长度为 2 * skip_window + 1长度的word list
        # 一个buffer生成num_skips个数的样本
    #     print([reverse_dictionary[i] for i in buffer])
        target = skip_window  # target label at the center of the buffer
    #     targets_to_avoid保证样本不重复
        targets_to_avoid = [skip_window]
        for j in range(num_skips):
          while target in targets_to_avoid:
            target = random.randint(0, span - 1)
          targets_to_avoid.append(target)
          batch[i * num_skips + j] = buffer[skip_window]
          labels[i * num_skips + j, 0] = buffer[target]
        buffer.append(data[data_index])
        # 每利用buffer生成num_skips个样本,data_index就向后推进一位
        data_index = (data_index + 1) % len(data)
      data_index = (data_index + len(data) - span) % len(data)
      return batch, labels
    
    # 默认情况下skip_window=1, num_skips=2
    # 此时就是从连续的3(3 = skip_window*2 + 1)个词中生成2(num_skips)个样本。
    # 如连续的三个词['used', 'against', 'early']
    # 生成两个样本:against -> used, against -> early
    batch, labels = generate_batch(batch_size=8, num_skips=2, skip_window=1)
    for i in range(8):
      print(batch[i], reverse_dictionary[batch[i]],
            '->', labels[i, 0], reverse_dictionary[labels[i, 0]])

     

    5、定义模型

    此处的模型实际可以抽象为:用一个单词预测另一个单词。在输出时,不使用 Softmax 损失,而使用 NCE 损失。即再选取一些“躁声词“作为负样本进行两类分类。NCE损失函数表示:,该损失函数计算上下文与目标单词之间的点积,采集每一个正样本的同时采集k个负样本。公式的第一项最小化正样本的损失,第二项最大化负样本的损失。现在如果将负样本作为第一项的变量输入,则损失函数结果应该很大。

    batch_size = 128
    embedding_size = 128  # 词嵌入空间是128维的。即word2vec中的vec是一个128维的向量
    skip_window = 1       # skip_window参数和之前保持一致
    num_skips = 2         # num_skips参数和之前保持一致
    
    # 在训练过程中,会对模型进行验证 
    # 验证的方法就是找出和某个词最近的词。
    # 只对前valid_window的词进行验证,因为这些词最常出现
    valid_size = 16     # 每次验证16个词
    valid_window = 100  # 这16个词是在前100个最常见的词中选出来的
    valid_examples = np.random.choice(valid_window, valid_size, replace=False)
    
    # 构造损失时选取的噪声词的数量
    num_sampled = 64
    graph = tf.Graph()
    with graph.as_default():
      # 输入的batch
      train_inputs = tf.placeholder(tf.int32, shape=[batch_size])
      train_labels = tf.placeholder(tf.int32, shape=[batch_size, 1])
      # 用于验证的词
      valid_dataset = tf.constant(valid_examples, dtype=tf.int32)
    
      # 下面采用的某些函数还没有gpu实现,所以我们只在cpu上定义模型
      with tf.device('/cpu:0'):
        # 定义1个embeddings变量,相当于一行存储一个词的embedding
        embeddings = tf.Variable(tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0))
        # 利用embedding_lookup可以轻松得到一个batch内的所有的词嵌入
        embed = tf.nn.embedding_lookup(embeddings, train_inputs)
    
        # 创建两个变量用于NCE Loss(即选取噪声词的二分类损失)
        nce_weights = tf.Variable(
            tf.truncated_normal([vocabulary_size, embedding_size],stddev=1.0 / math.sqrt(embedding_size)))
        nce_biases = tf.Variable(tf.zeros([vocabulary_size]))
    
      # tf.nn.nce_loss会自动选取噪声词,并且形成损失。
      # 随机选取num_sampled个噪声词
      loss = tf.reduce_mean(
          tf.nn.nce_loss(weights=nce_weights,
                         biases=nce_biases,
                         labels=train_labels,
                         inputs=embed,
                         num_sampled=num_sampled,
                         num_classes=vocabulary_size))
    
      # 得到loss后,我们就可以构造优化器了
      optimizer = tf.train.GradientDescentOptimizer(1.0).minimize(loss)
    
      # 计算词和词的相似度(用于验证)
      norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keep_dims=True))
      normalized_embeddings = embeddings / norm
      # 找出和验证词的embedding并计算它们和所有单词的相似度
      valid_embeddings = tf.nn.embedding_lookup(normalized_embeddings, valid_dataset)
      similarity = tf.matmul(valid_embeddings, normalized_embeddings, transpose_b=True)
    
      # 变量初始化步骤
      init = tf.global_variables_initializer()

     

    六、训练

    num_steps = 100001
    with tf.Session(graph=graph) as session:
      # 初始化变量
      init.run()
      print('Initialized')
    
      average_loss = 0
      for step in xrange(num_steps):
        batch_inputs, batch_labels = generate_batch(batch_size, num_skips, skip_window)
        feed_dict = {train_inputs: batch_inputs, train_labels: batch_labels}
    
        # 优化一步
        _, loss_val = session.run([optimizer, loss], feed_dict=feed_dict)
        average_loss += loss_val
    
        if step % 2000 == 0:
          if step > 0:
            average_loss /= 2000
          # 2000个batch的平均损失
          print('Average loss at step ', step, ': ', average_loss)
          average_loss = 0
    
        # 每1万步,我们进行一次验证
        if step % 10000 == 0:
          # sim是验证词与所有词之间的相似度
          sim = similarity.eval()
          # 一共有valid_size个验证词
          for i in xrange(valid_size):
            valid_word = reverse_dictionary[valid_examples[i]]
            top_k = 8  # 输出最相邻的8个词语
            nearest = (-sim[i, :]).argsort()[1:top_k + 1]
            log_str = 'Nearest to %s:' % valid_word
            for k in xrange(top_k):
              close_word = reverse_dictionary[nearest[k]]
              log_str = '%s %s,' % (log_str, close_word)
            print(log_str)
      # final_embeddings是我们最后得到的embedding向量
      # 它的形状是[vocabulary_size, embedding_size]
      # 每一行就代表着对应index词的词嵌入表示
      final_embeddings = normalized_embeddings.eval()
    

     

    七、可视化

    之前设定的 embedding_size=128, 即每个词都被表示为一个 128 维的向量 。虽然不能把 128 维的空间直接画出来,但下面的程序使用了 t-SNE 方法把 128 维空间映射到了 2 维 ,并画出最常使用的 500 个词的位置 。可视化的图片会保存为“tsne.png”。

    def plot_with_labels(low_dim_embs, labels, filename='tsne.png'):
      assert low_dim_embs.shape[0] >= len(labels), 'More labels than embeddings'
      plt.figure(figsize=(18, 18))  # in inches
      for i, label in enumerate(labels):
        x, y = low_dim_embs[i, :]
        plt.scatter(x, y)
        plt.annotate(label,
                     xy=(x, y),
                     xytext=(5, 2),
                     textcoords='offset points',
                     ha='right',
                     va='bottom')
    
      plt.savefig(filename)
    
    try:
      # pylint: disable=g-import-not-at-top
      from sklearn.manifold import TSNE
      import matplotlib
      matplotlib.use('agg')
      import matplotlib.pyplot as plt
      # 因为我们的embedding的大小为128维,没有办法直接可视化
      # 所以我们用t-SNE方法进行降维
      tsne = TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000)
      # 只画出500个词的位置
      plot_only = 500
      low_dim_embs = tsne.fit_transform(final_embeddings[:plot_only, :])
      labels = [reverse_dictionary[i] for i in xrange(plot_only)]
      plot_with_labels(low_dim_embs, labels)
    
    except ImportError:
      print('Please install sklearn, matplotlib, and scipy to show embeddings.')
    
    
    
    展开全文
  • 关于图嵌入和知识图谱嵌入的区别,简单的做一个笔记 具体建议看大牛的博客和涉及具体方法的论文 ????图嵌入嵌入(Graph Embedding,GE),又称为网络嵌入(Network Embedding,NE): 目的:将高维图数据用低维...

    关于图嵌入和知识图谱嵌入的区别,简单的做一个笔记

    具体建议看大牛的博客和涉及具体方法的论文

    🌱图嵌入

    • 图嵌入(Graph Embedding,GE),又称为网络嵌入(Network Embedding,NE):
      • 目的:将高维图数据用低维稠密向量进行表示
      • 典型方法:Deepwalk、Node2vec等

    🌿知识图谱嵌入

    • 知识图谱嵌入(Knowledge Graph Embedding,KGE):
      • 目的:学习如何将知识图谱中的实体和关系,使用embedding向量进行表示。这么说的话也可以说是对图谱中的三元组进行嵌入了
      • 典型方法:TransE、TransH、TransR等

    🌳参考:

    展开全文
  • 嵌入代码

    2016-12-21 09:52:48
    直接嵌入的代码片段
     width="640px" height="360px" src="https://www.artstation.com/embed/3611623" allowfullscreen="" scrolling="no"> 
    
    

    直接嵌入的代码片段

    展开全文
  • ckeditor如何嵌入html

    2018-12-17 08:30:36
    ckeditor如何嵌入html,ckeditor如何嵌入html,ckeditor如何嵌入html
  • 现在的直播必然需要支持手机直播,如果能够嵌入到全面宠儿微信中,那就能深度民心了。从技术上而言,微信直播,自然需要使用H5页面。目前手机浏览器不支持RTSP、RTMP,想要在手机微信上直播那就需要HLS视频流,有些...
  • HTML 嵌入元素

    2017-10-10 15:21:40
    学习要点 嵌入元素总汇 嵌入元素解析 一、嵌入元素总汇 元素名称 说明 img 嵌入图片 map 定义客户端分区响应图
  • 最近要做一个在H5页面中嵌入第三方视频的功能,用户可以观看点赞等操作。由于本人目前在此方面初次了解,所以写下本文以供互相学习交流,有不对的地方,可留言对我进行指导(大神勿喷)。好了话不多说,关于H5页面...
  • 嵌入概述

    2019-08-05 07:30:00
    点击上方“AI公园”,关注公众号,选择加“星标“或“置顶”作者:rimož Godec编译:ronghuaiyang导读这篇文章描述了什么是图嵌入,图嵌入的用处,并对比了...
  • html嵌入mp3

    千次阅读 2017-05-26 06:29:58
    嵌入mp3音乐
  • 嵌入方法

    2020-03-07 19:57:28
    嵌入的主要思想是将文本转换为较低维度空间的矢量表示。对于这种转化后的向量有两个重要的要求: 较低维度空间:尽量降低编码词向量产生的稀疏性。 保证上下文相似性:为了使语言模型更好的预测文本的含义。 总...
  • Qt 嵌入网页

    千次阅读 2020-03-31 13:53:51
    Qt 嵌入网页Qt(版本5.6以上)自带控件MSVC版本,使用Qt WebEnginemingw 版本,使用QAxWidget第三方 Qt(版本5.6以上)自带控件 MSVC版本,使用Qt WebEngine 在安装Qt是需要选择支持Qt WebEngine: mingw 版本,...
  • Kaggle 官方教程:嵌入

    千次阅读 2018-12-14 21:36:53
    原文:Embeddings 译者:飞龙 协议:CC BY-NC-SA 4.0 P.S… 本课程仍处于测试阶段,因此我很乐意收到你的反馈意见。 如果你有时间填写本课程的超短期调查,我将非常感激。... 嵌入是一种技术,使深度神经网络能够...
  • 嵌入算法

    千次阅读 2018-03-16 10:09:59
    为了克服文字长短不一和将词与词之间的联系纳入模型的困难,人们使用了一种技术——词嵌入。 常见的词嵌入算法有:“Word2Vec”和“Glove” 「词嵌入(word embeddings)」术语,来指代词语在低维度向量空间的稠密...
  • 学习词嵌入

    2018-07-12 17:11:47
    使用每个单词的嵌入矩阵E乘one-hot向量得到该单词的嵌入向量(维度与特征数量相同)。把这些嵌入向量放入神经网络,然后通过softmax分类器,它会尝试在字典范围内预测输出单词。如果设置窗口大小,即只用固定数量的...
  • WPF_嵌入字体_EmbeddedFont

    千次下载 热门讨论 2015-01-30 09:09:55
    WPF_嵌入字体_EmbeddedFont
  • metabase嵌入java应用

    2020-02-18 11:35:21
    嵌入分为两种方式:问题嵌入和仪表盘嵌入 创建一个图表就是创建一个问题,之后就可以将该图表嵌入到应用中展示;当需要将多个图表在同一个页面展示时,可以将多个图表放入同一个仪表盘中,再将仪表盘嵌入到应用中。 ...
  • 嵌入模型综述

    千次阅读 2019-11-07 16:07:06
    最近在学习Embedding相关的知识的时候看到了一篇关于图嵌入的综述,觉得写的不错便把文章中的一部分翻译了出来。因自身水平有限,文中难免存在一些纰漏,欢迎发现的知友在评论区中指正。 目录 一、图嵌入概述 二...
  • uniapp嵌入html页面

    千次阅读 2020-08-12 18:37:24
    创建目录结构,放入html文件 嵌入webview标签即可
  • 参考论文Learning Community Embedding with Community Detection...一方面,节点嵌入可以帮助改进社区检测,从而输出良好的社区以适应更好的社区嵌入,另一方面,社区嵌入可以通过引入a community-aware high-order...
  • pdf 嵌入 html

    千次阅读 2018-03-22 11:21:14
    1. embed标签 这种嵌入之后,在chrome浏览器中显示的还是不错的,但是在IE10+上面如果文件很大加载始终出不来,体验不是很好2. iframe 这种嵌入方式最好,试了一下最后选择了这种方式。代码量很少&lt;iframe ...
  • Markdown嵌入视频

    万次阅读 2015-11-03 19:31:35
    Markdown嵌入视频
  • 嵌入矩阵

    2020-04-01 21:23:27
    在nlp任务中,计算机不会直接处理文本信息,而是需要先...词嵌入矩阵就是将单词从one-shot形式转化为固定维数的向量时所需的转换矩阵。 英文单词的oneshot形式可由tokenizer.word_index直接获得,它是一个字典,内...
  • 10分钟了解图嵌入

    千次阅读 2020-11-25 09:42:33
    知识图谱中的客户数据样本以及该图中附加的嵌入向量 去年,图嵌入在企业知识图谱(EKG)策略中变得越来越重要。 图形嵌入将很快成为在大型十亿顶点EKG中快速找到相似项目的实际方法。 实时相似性计算对于许多领域至...
  • C++嵌入对象

    千次阅读 2016-12-14 20:59:55
    嵌入对象 类的成员变量为用户自定义的类型时,这些成员变量称为嵌入对象。示例:在Master中嵌入World#include<iostream>class Master { public: Master(int id): _identifier(id) { std::cout <...
  • 嵌入特性

    2018-07-11 14:43:54
    类比特征embedding,词嵌入,将两个相近的词嵌入向量相减,得到的向量中会有很多0。因为这两个词很相近所以他们有很多特征值是接近的。比如用e_man-e_woman 约等于 e_king-e_queen这说明两类事物之间的关系很相似。e...
  • 在 QGraphicsScene 中嵌入 QWidget

    万次阅读 2016-11-14 15:34:55
    简述图形视图对将任何 widget 嵌入到场景中提供了无缝的支持。可以嵌入简单的 widget,例如:QLineEdit、QPushButton;也可以是复杂的 widget,例如:QTabWidget,甚至是完整的主窗口。要将 widget 嵌入场景中,只...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 89,022
精华内容 35,608
关键字:

嵌入