对于向量，WMEAN（X，W）是使用非负权重W的X中元素的加权平均值。对于矩阵，WMEAN（X，W）是包含每一列的加权平均值的行向量。对于ND数组，WMEAN（X，W）是沿着X的第一个非单维度的元素的加权平均值。

输入X和W的类支持：

浮点数：双精度，单精度

示例：

x = rand（5,2）;

w = rand（5,2）;

wmean（x，w）

完整资料领取：https://ai.52learn.online/9652

从具有可变时间步长的模拟数据我有一个不规则的时间向量作为我的值的索引,它们存储在pandas.DataFrame中.
让我们考虑一个简化的测试用例：
import pandas as pd
import datetime
time_vec = [datetime.time(0,0),datetime.time(0,0),datetime.time(0,5),datetime.time(0,7),datetime.time(0,10)]
df = pd.DataFrame([1,2,4,3,6],index = time_vec)
使用正常的df.mean()函数将得到答案3.2,只有当时间向量是等距的时才会出现这种情况.
我认为正确的结果是3.55,第一个时间步长(零秒长),平均值是1.5,对于第二个时间步,平均值是3(五分钟长)等,这导致：
1.5 * 0 + 3*5 + 3.5 * 2 + 4.5 * 3 = 35.5
结果平均为3.55(35.5 /(0 5 2 3)).
有没有一种有效的方法来做大熊猫？
这应该最终会产生类似的结果
df.resample('15M',how = 'This very Method I am looking for')
用等距时间向量创建平均值.
解决方法:
好吧,我想出了如何解决我的问题.我不知道,如果这是一个很好的解决方案,但它的确有效.
我通过datetime.datetime交换datetime.time来更改问题中的原始代码,否则它将无效(datetime.time-Objects没有方法total_seconds()).我还必须导入numpy才能使用numpy.average.
所以现在的代码是：
import datetime
import numpy as np
import pandas as pd
time_vec =     [datetime.datetime(2007,1,1,0,0)
,datetime.datetime(2007,1,1,0,0)
,datetime.datetime(2007,1,1,0,5)
,datetime.datetime(2007,1,1,0,7)
,datetime.datetime(2007,1,1,0,10)]
df = pd.DataFrame([1,2,4,3,6],index = time_vec)
这个小功能解决了我的问题：
def time_based_weighted_mean(tv_df):
time_delta = [(x-y).total_seconds() for x,y in zip(df.index[1:],df.index[:-1])]
weights = [x+y for x,y in zip([0]+ time_delta,time_delta+[0])]
res = np.average(df[0],weights = weights)
return res
print time_based_weighted_mean(df[0])
我首先尝试使用pd.index.diff()来计算time_delta-Array,但这导致了一个numpy.datetime64系列,我不知道如何将它们转换为浮点数,因为np.average需要浮点数作为输入 – 重量类型.
我很感谢任何改进代码的建议.
标签：python,pandas,weighted-average
来源： https://codeday.me/bug/20190703/1362895.html

  文献：A SIMPLE BUT TOUGH-TO-BEAT BASELINE FOR SENTENCE EMBEDDINGS
  在进行了词嵌入的研究后，我们往往会联想到这样一个问题：既然单词可以用向量表示，那么由一个个单词组成的句子，可不可以也用向量表示呢？如果可以的话，句子之间就可以进行向量的运算，计算它们之间的相似度，进而可以对句子进行聚类或者进行匹配。
  因此，这篇文献提出了一种简单但又难以打败的计算句子嵌入的方法，使得句子向量计算的性能得到了提升。
  关于代码的实现，请看 记录一次失败的句子相似性实验 。当时效果不太好，但是后来的结果证明，还是可取的！大家谨慎参考！

Navigation
ABSTRACT
INTRODUCTION
METHOD
$1$ Latent Variable Generative Model
$2$ Improve Random Walk Model
$3$ Compute Sentence Embedding
REFERENCE


ABSTRACT
  应用神经网络方法来计算单词嵌入的成功促进了对于较长段落（例如文本）语义嵌入的研究。而作者提出了这样一种句子嵌入方法：通过一种流行的方法对未标记的语料库（如$Wikipedia$）计算词嵌入，通过词向量的加权平均值表示句子，然后使用 $PCA$ $/$ $SVD$ 对其进行一些修改。
  这种加权可将文本相似性任务的性能提高约 10％ 到 30％，并且优于包括 $RNN$ 和 $LSTM$ 在内的复杂的监督方法。这种简单的方法在将来的研究中应当作为 $baseline$，尤其是在带有标签的训练数据稀缺或不存在的情况下。

INTRODUCTION
  使用多种方法计算的词嵌入是自然语言处理 ($NLP$) 和信息检索 ($IR$) 的基本构建块。它计算词与词之间的相似性。而最近的工作尝试从单词向量的简单加总平均到复杂的方法（例如卷积神经网络和递归神经网络）来计算单词序列（短语，句子和段落）语义的嵌入。
  在这里，作者提供了一种非常简单的句子嵌入方法：只计算句子中单词向量的加权平均值，然后删除平均向量在其第一个主成分上的投影（“公共成分去除”）。我们称它为平滑反频率 ($smooth$ $inverse$ $frequency$)。
  ($1$) 单词 $w$ 的权重表示为a / (a + p(w))，a 是一个超参数，p(w)是词频。我们发现，p(w)越大，单词权重越小。是不是感觉与 $TF-IDF$ 原理有些相似，字词的重要性随着它在语料库中出现的频率成反比下降。
  ($2$) 关于第一主成分，由于使用单词向量的平均的方法在沿语义上无意义的方向具有巨大的分量。因此我们删去这些公共成分，留下关键的信息。
  $SIF$的优越性体现在以下几点：

well-suited for domain adaptation settings：对于各个领域的适应性较好
fairly robust to the weighting scheme：使用不同的语料库计算的词频并不会影响它的性能
a wide range of the parameters a can achieve close-to-best results：选择恰当的 $a$，可以达到最好的效果


METHOD
$1$ Latent Variable Generative Model
  作者简要回顾了文本的潜在变量生成模型：该模型将语料库生成视为一个动态过程，在步骤 $t$ 中生成第 $t$ 个单词。这个过程是由一个 discourse vector  驱动的，表示为 $c_t$，意味着在这个时刻，句子的话题是什么，可以视为一个主题向量；同时，对于每一个单词 $w$ ，也有对应的词向量 $v_w$（与时间无关）。二者之间的内积表示当前主题与词语的相关关系。
  假定 $t$ 时刻单词 $w$ 产生概率为：



  由于主题向量 $c_t$ 做缓慢的随机漫步(slow random walk)，即 $c_{t+1}$  只是在 $c_t$ 基础上新增了移位向量，因此我们可以将相邻单词看成在相同 $c_t$ 下产生。
$2$ Improve Random Walk Model
  在之前的基础上，作者定义 sentence embedding 为：给定一个句子 s，利用最大后验概率估计 ($MAP$) 产生这个句子的主题向量 $c_t$ 。我们假定在一步步产生单词时，该句子的主题向量不会发生较大改变，因此用 $c_s$ 来代替一个句子所有的 $c_t$ 。
  在模型的基础上，作者做了如下改进，引入了两个平滑项，用来解释 ($a$) 有些词是在上下文之外出现 ($b$) 某些高频词如 “$the$” “$and$” 是没有语境限制的。

α·p(w)：其中 $α$ 是标量，$p$($w$) 是整个语料库中单词 $w$ 的词频。这使得即使单词与当前主题 $c_s$ 内积（相关性）很小，它也有一定的概率出现。
$c_0$：公共话题向量，它代表着与语法相关的最频繁的主题向量，作用为校正项。它提高了沿 $c_0$ 具有较高分量的单词的共现概率。

  具体来说，给定主题向量 $c_s$ ，在句子 $s$ 中单词 $w$ 的生成概率为：



  $α$ 和 $β$ 都是超参数，$Z_{c_s} = ∑_{w∈v}exp(<c_s, v_w>)$ 是归一化常数。我们看到该模型允许生成与主题向量 $c_s$ 不相关的单词  $w$ ，其原因有二：($a$) 偶然地从项α·p(w)产生 ；($b$) $w$ 与公共话语向量 $c_ {0}$ 相关。
$3$ Compute Sentence Embedding
   句子向量被定义为向量 $c_s$ 的极大似然估计。



   因此我们发现，$MLE$大致是句子中单词的向量的加权平均值。我们发现，越频繁的单词，权重越小。
  为了估计 $c_s$ ，我们通过计算一组句子的第一主成分来估计方向 $c_0$ 。通过将  $c_s$  的投影减去它们的第一主成分可以得到最终的句子嵌入。
  整体流程如下：



REFERENCE
SIF 论文阅读笔记

一、简介
顶点法向量的作用： 对渲染时光照的影响，造成不同的反射角度。
法向量：垂直于顶点所在的最小平面的单位向量，这个值是近似值。
二、目的
如何计算顶点法向量？
三、我的总结
网上对于法向量的计算方法有多种：1.取顶点周围三角面片的法向量的平均值 2.加权算法 3.....等，大同小异，无法就是取个近似值，每种方法在不同的情景中，所得的近似值各有千秋。
本文参考外文代码，给出实现的demo。
先参看下图;



代码是个加载地形的类：

class Terrain{
	private:
		int w;
		int l;
		float** hs;
		Vec3f** normals;
		bool computedNormals;
	public:
		Terrain(int w2, int l2){
			w = w2;
			l = l2;

			hs = new float*[l];
			for (int i = 0; i < l; i++){
				hs[i] = new float[w];
			}

			normals = new Vec3f*[l];
			for (int i = 0; i < l; i++){
				normals[i] = new Vec3f[w];
			}

			computedNormals = false;
		}

		~Terrain(){
			for (int i = 0; i < l; i++){
				delete [] hs[i];
			}
			delete[] hs;

			for(int i = 0; i < l; i++){
				delete[] normals[i];
			}
			delete[] normals;
		}

		int width(){
			return w;
		}

		int length(){
			return l;
		}

		void setHeight(int x, int z, float y){
			hs[z][x] = y;
			computedNormals = false;
		}

		float getHeight(int x, int z){
			return hs[z][x];
		}

		void computeNormals(){
			if(computedNormals){
				return;
			}

			Vec3f** normals2 = new Vec3f*[l];
			for (int i = 0; i < l; i++) {
				normals2[i] = new Vec3f[w];
			}

			for(int z = 0; z < l; z++){
				for (int x = 0; x < w; x++){
					Vec3f sum(0.0f, 0.0f, 0.0f);

					Vec3f out;
					if (z > 0)
					{
						out = Vec3f(0.0f, hs[z-1][x] - hs[z][x], -1.0f);
					}

					Vec3f in;
					if(z < l - 1){
						in = Vec3f(0.0f, hs[z + 1][x] - hs[z][x], 1.0f);
					}

					Vec3f left;
					if (x > 0){
						left = Vec3f(-1.0f, hs[z][x-1] - hs[z][x], 0.0f);
					}

					Vec3f right;
					if (x < w - 1){
						right = Vec3f(1.0f, hs[z][x+1] - hs[z][x], 0.0f);
					}

					if (x > 0 && z > 0){
						sum += out.cross(left).normalize();
					}

					if (x > 0 && z < l - 1){
						sum += left.cross(in).normalize();
					}

					if(x < w - 1 && z < l - 1){
						sum += in.cross(right).normalize();
					}

					if (x < w - 1 && z > 0){
						sum += right.cross(out).normalize();
					}

					normals2[z][x] = sum;
				}
			}
			const float FALLOUT_RATIO = 0.5f;
			for (int z = 0; z < l; z++)	{
				for(int x = 0; x < w; x++){
					Vec3f sum = normals2[z][x];

					if(x > 0){
						sum += normals2[z][x-1] * FALLOUT_RATIO;
					}

					if(x < w - 1){
						sum += normals2[z][x+1] * FALLOUT_RATIO;
					}

					if(z > 0){
						sum += normals2[z-1][x] * FALLOUT_RATIO;
					}

					if(z < l -1){
						sum += normals2[z+1][x] * FALLOUT_RATIO;
					}

					if(sum.magnitude() == 0){
						sum = Vec3f(0.0f, 1.0f, 0.0f);
					}

					normals[z][x] = sum;
				}
			}

			for (int i = 0; i < l; i++)
			{
				delete[] normals2[i];
			}
			delete[] normals2;

			computedNormals = true;
		}

		Vec3f getNormal(int x, int z){
			if (!computedNormals){
				computeNormals();
			}

			return normals[z][x];
		}
};


函数void computeNormals()便是计算法向量方法。