在 c++ 中，vector 是一个十分有用的容器。它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。
C++ 中数组很坑，有没有类似 Python 中 list 的数据类型呢？类似的就是 vector！vector 是同一种类型的对象的集合，每个对象都有一个对应的整数索引值。和 string 对象一样，标准库将负责管理与存储元素相关的内存。我们把 vector 称为容器，是因为它可以包含其他对象。一个容器中的所有对象都必须是同一种类型的。
使用vector注意事项：
1、如果你要表示的向量长度较长(需要为向量内部保存很多数)，容易导致内存泄漏，而且效率会很低；
2、Vector 作为函数的参数或者返回值时，需要注意它的写法：
double Distance(vector<int>&a, vector<int>&b)
 其中的“&”绝对不能少！！！
vector对象的定义和初始化
同样的，使用前，导入头文件 #include 可以使用using声明：using std::vector;vector 是一个类模板(class template)。使用模板可以编写一个类定义或函数定义，而用于多个不同的数据类型。因此，我们可以定义保存 string 对象的 vector，或保存 int 值的 vector，又或是保存自定义的类类型对象(如 Sales_items 对象)的 vector。
声明从类模板产生的某种类型的对象，需要提供附加信息，信息的种类取决于模板。以 vector 为例，必须说明 vector 保存何种对象的类型，通过将类型放在类型放在类模板名称后面的尖括号中来指定类型：
vector v1;
保存类型为 T 对象。默认构造函数 v1 为空。
vector v2(v1); 
v2 是 v1 的一个副本。
vector v3(n, i);
v3 包含 n 个值为 i 的元素。
vector v4(n); 
v4 含有值初始化的元素的 n 个副本。
【注意：1、若要创建非空的 vector 对象，必须给出初始化元素的值；2、当把一个 vector 对象复制到另一个 vector 对象时，新复制的 vector 中每一个元素都初始化为原 vectors 中相应元素的副本。但这两个 vector 对象必须保存同一种元素类型；3、可以用元素个数和元素值对 vector 对象进行初始化。构造函数用元素个数来决定 vector 对象保存元素的
个数，元素值指定每个元素的初始值】
vector对象动态增长：
vector 对象(以及其他标准库容器对象)的重要属性就在于可以在运行时高效地添加元素。
注意：因为 vector 增长的效率高，在元素值已知的情况下，最好是动态地添加元素。
实例：
vectortest;//建立一个vector，int为数组元素的数据类型，test为动态数组名
简单的使用方法如下：
vectortest;//建立一个vector
test.push_back(1);
test.push_back(2);//把1和2压入vector，这样test[0]就是1,test[1]就是2
实例：
vector > points; //定义一个二维数组
points[0].size();  //指第一行的列数
1 、基本操作
(1)头文件#include.
(2)创建vector对象，vector vec;
(3)尾部插入数字：vec.push_back(a);
(4)使用下标访问元素，cout<
(5)使用迭代器访问元素.
vector::iterator it;for(it=vec.begin();it!=vec.end();it++)
    cout<
(6)插入元素：vec.insert(vec.begin()+i,a); 在第i+1个元素前面插入a;
(7)删除元素：vec.erase(vec.begin()+2); 删除第3个元素
vec.erase(vec.begin()+i,vec.end()+j); 删除区间[ i,j-1] 区间从0开始
(8)向量大小: vec.size();
(9)清空: vec.clear();
特别提示：这里有 begin() 与 end() 函数、front() 与 back() 的差别
2、重要说明
vector 的元素不仅仅可以是 int,double,string 还可以是结构体，但是要注意：结构体要定义为全局的，否则会出错。
#include#include#include#includeusing namespace std;typedef struct rect{    int id;    int length;    int width;　　//对于向量元素是结构体的，可在结构体内部定义比较函数，下面按照id,length,width升序排序。　　bool operator< (const rect &a)  const      {        if(id!=a.id)            return id        else          {            if(length!=a.length)                return length            else                  return width        }    }}Rect;int main(){    vector vec;    Rect rect;    rect.id=1;    rect.length=2;    rect.width=3;    vec.push_back(rect);    vector::iterator it=vec.begin();    cout<' '<' '<endl;  return 0;}
3、算法
(1) 使用reverse将元素翻转：需要头文件 #include
reverse(vec.begin(),vec.end());将元素翻转，即逆序排列！
(在vecto r中，如果一个函数中需要两个迭代器，一般后一个都不包含)
(2)使用 sort 排序：需要头文件 #include，
sort(vec.begin(),vec.end());(默认是按升序排列,即从小到大).
可以通过重写排序比较函数按照降序比较，如下：
定义排序比较函数：
bool Comp(const int &a,const int &b)
{return a>b;
}
调用时: sort(vec.begin(),vec.end(),Comp)，这样就降序排序。 
输出Vector的中的元素   
vector vecClass; 
int nSize = vecClass.size();   
 //打印 vecClass,方法一： 
for(int i=0;i{
   cout<"     ";
}
   cout<
需要注意的是：以方法一进行输出时，数组的下表必须保证是整数。
 //打印 vecClass,方法二：    
for(int i=0;i{
   cout<"     ";
}
   cout<
//打印 vecClass,方法三：输出某一指定的数值时不方便
for(vector::iterator it = vecClass.begin();it!=vecClass.end();it++)
{
    cout<"   ";
}
    cout<
二维数组的使用：
#include "stdafx.h"  #include #include #include using namespace std;int main(){    using namespace std;    int out[3][2] = { 1, 2,             3, 4,            5, 6 };    vector <int*> v1;    v1.push_back(out[0]);    v1.push_back(out[1]);    v1.push_back(out[2]);    cout << v1[0][0] << endl;//1    cout << v1[0][1] << endl;//2    cout << v1[1][0] << endl;//3    cout << v1[1][1] << endl;//4    cout << v1[2][0] << endl;//5    cout << v1[2][1] << endl;//6    return 0;}

	

因子分析(factor analysis)因子分析的一般步骤factor_analyzer模块进行因子分析使用Python实现因子分析初始化构建数据将原始数据标准化处理 X计算相关矩阵C计算相关矩阵C的特征值  和特征向量   确定公共因子个数k构造初始因子载荷矩阵A建立因子模型将因子表示成变量的线性组合.计算因子得分.
因子分析(factor analysis)
是指研究从变量群中提取共性因子的统计技术。因子分析是简化、分析高维数据的一种统计方法。
因子分析又存在两个方向，一个是探索性因子分析(exploratory factor analysis)。另一个是验证性因子分析(confirmatory factor analysis)。
探索性因子分析是先不假定一堆自变量背后到底有几个因子以及关系，而是我们通过这个方法去寻找因子及关系。
验证性因子分析是假设一堆自变量背后有几个因子，试图验证这种假设是否正确。
因子分析有两个核心问题，一是如何构造因子变量，二是如何对因子变量进行命名解释。
因子分析的一般步骤
将原始数据标准化处理 X
计算相关矩阵C
计算相关矩阵C的特征值 r 和特征向量 U
确定公共因子个数k
构造初始因子载荷矩阵,其中U为r的特征向量
建立因子模型
对初始因子载荷矩阵A进行旋转变换，旋转变换是使初始因子载荷矩阵结构简化，关系明确，使得因子变量更具有可解释性，如果初始因子不相关，可以用方差极大正交旋转，如果初始因子间相关，可以用斜交旋转，经过旋转后得到比较理想的新的因子载荷矩阵A'.
将因子表示成变量的线性组合，其中的系数可以通过最小二乘法得到.
计算因子得分.
factor_analyzer模块进行因子分析
算法核心：
对若干综合指标进行因子分析并提取公共因子,再以每个因子的方差贡献率作为权数与该因子的得分乘数之和构造得分函数。
import pandas as pd
import numpy as np
from pandas import DataFrame,Series
from factor_analyzer import FactorAnalyzer

import warnings
warnings.filterwarnings("ignore")
使用Python实现因子分析
初始化构建数据 
#构建数据集
data=pd.DataFrame(np.random.randint(50,100,size=(5, 10)))
data.columns=["特征1","特征2","特征3","特征4","特征5","特征6","特征7","特征8","特征9","特征10"]
data.index=['对象1','对象2','对象3','对象4','对象5']
#查看数据
data.head(3)
将原始数据标准化处理 X 
data=(data-data.mean())/data.std() # 0均值规范化
data
计算相关矩阵C 
C=data.corr() #相关系数矩阵
C
计算相关矩阵C的特征值    和特征向量    
import numpy.linalg as nlg #导入nlg函数，linalg=linear+algebra

eig_value,eig_vector=nlg.eig(C) #计算特征值和特征向量

eig=pd.DataFrame() #利用变量名和特征值建立一个数据框

eig['names']=data.columns#列名

eig['eig_value']=eig_value#特征值
eig
确定公共因子个数k 
from math import sqrt

for k in range(1,11): #确定公共因子个数
    if eig['eig_value'][:k].sum()/eig['eig_value'].sum()>=0.8: #如果解释度达到80%, 结束循环
        print(k)
        break
3
eig['eig_value'][:3].sum()/eig['eig_value'].sum()
(0.9013148087274826+0j)
构造初始因子载荷矩阵A 
col0=list(sqrt(eig_value[0])*eig_vector[:,0]) #因子载荷矩阵第1列
col1=list(sqrt(eig_value[1])*eig_vector[:,1]) #因子载荷矩阵第2列
col2=list(sqrt(eig_value[2])*eig_vector[:,2]) #因子载荷矩阵第3列
A=pd.DataFrame([col0,col1,col2]).T #构造因子载荷矩阵A
A.columns=['factor1','factor2','factor3'] #因子载荷矩阵A的公共因子
A
建立因子模型 
h=np.zeros(10) #变量共同度，反映变量对共同因子的依赖程度，越接近1，说明公共因子解释程度越高，因子分析效果越好

D=np.mat(np.eye(10))#特殊因子方差，因子的方差贡献度 ，反映公共因子对变量的贡献，衡量公共因子的相对重要性

A=np.mat(A) #将因子载荷阵A矩阵化
for i in range(10):
    a=A[i,:]*A[i,:].T #行平方和
    h[i]=a[0,0]  #计算变量X共同度,描述全部公共因子F对变量X_i的总方差所做的贡献，及变量X_i方差中能够被全体因子解释的部分
    D[i,i]=1-a[0,0] #因为自变量矩阵已经标准化后的方差为1，即Var(X_i)=第i个共同度h_i + 第i个特殊因子方差
将因子表示成变量的线性组合. 
from numpy import eye, asarray, dot, sum, diag #导入eye,asarray,dot,sum,diag 函数
from numpy.linalg import svd #导入奇异值分解函数

def varimax(Phi, gamma = 1.0, q =10, tol = 1e-6): #定义方差最大旋转函数
    p,k = Phi.shape #给出矩阵Phi的总行数，总列数
    R = eye(k) #给定一个k*k的单位矩阵
    d=0
    for i in range(q):
        d_old = d
        Lambda = dot(Phi, R)#矩阵乘法

        u,s,vh = svd(dot(Phi.T,asarray(Lambda)**3 - (gamma/p) * dot(Lambda, diag(diag(dot(Lambda.T,Lambda)))))) #奇异值分解svd

        R = dot(u,vh)#构造正交矩阵R

        d = sum(s)#奇异值求和

    if d_old!=0 and d/d_old:
        return dot(Phi, R)#返回旋转矩阵Phi*R

rotation_mat=varimax(A)#调用方差最大旋转函数
rotation_mat=pd.DataFrame(rotation_mat)#数据框化
rotation_mat
计算因子得分. 
data=np.mat(data) #矩阵化处理

factor_score=(data).dot(A) #计算因子得分

factor_score=pd.DataFrame(factor_score)#数据框化

factor_score.columns=['因子A','因子B','因子C'] #对因子变量进行命名
factor_score
#factor_score.to_excel(outputfile)#打印输出因子得分矩阵
喜欢分享or

tensor、numpy、vector转换
python中：
**numpy -> tensor**:  `torch.from_numpy(ndarray)`
**tensor -> numpy**:  `tensor.numpy()`
1
2
3
c++中：
**array -> tensor**:  `torch::tensor(at::ArrayRef({3.1, 3.2, 3.3, ...}));` 一般数组
**cv::Mat -> tensor**:  `torch::tensor(at::ArrayRef(img.data, img.rows * img.cols * 3)).view({img.rows, img.cols, 3}); `指针
1
2
3
**tensor->vector**:  ` vectorxxx(tensor.data(), tensor.data()+tensor.numel())`; 指针直接初始化vector
**tensor -> cv::Mat**:  `Mat m(tensor.size(0), tensor.size(1), CV_8UC1, (void*) tensor.data());`
1
2
3
cv::Mat 与tensor的其他转换方法：
// from_blob不申请新空间，只是image.data的view。可以用.clone深拷贝。
at::Tensor tensor_image = torch::from_blob(image.data, {1, 3, image.rows, image.cols}, at::kByte); //at::kByte与image的dypte一直；其它如at::kFloat等。
// 之后再转其他dtype
tensor_image = tensor_image.to(at::kFloat);
tensor_image.data(); //这是一个float* 指针。
// an example
at::Tensor compute(at::Tensor x, at::Tensor w) {
cv::Mat input(x.size(0), x.size(1), CV_32FC1, x.data());
cv::Mat warp(3, 3, CV_32FC1, w.data());
cv::Mat output;
cv::warpPerspective(input, output, warp, {64, 64});
return torch::from_blob(output.ptr(), {64, 64}).clone();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
c++ model forward 返回值
返回类型为 torch::jit::IValue
torch::jit::IValue result = module->forward(inputs);
1
如果只有一个返回值，可以直接转tensor：
auto outputs = module->forward(inputs).toTensor();
1
如果有多个返回值，需要先转tuple：
auto outputs = module->forward(inputs).toTuple();
torch::Tensor out1 = outputs->elements()[0].toTensor();
torch::Tensor out2 = outputs->elements()[1].toTensor();
1
2
3
使用gpu
把model和inputs都放到gpu上：
std::shared_ptrmodule = torch::jit::load(argv[2]);
//put to cuda
module->to(at::kCUDA);
// 注意是把tensor放到gpu，而不是vectorstd::vectorinputs;
image_tensor.to(at::kCUDA)
inputs.push_back(image_tensor)
1
2
3
4
5
6
7
8
可以指定 GPU id： to(torch::Device(torch::kCUDA, id))
————————————————
版权声明：本文为CSDN博主「西伯利亚的蓝眼睛」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_14975217/article/details/90512374

#-*- coding: UTF-8 -*-'''Vector3 3D向量类
关于操作符重载 http://docs.python.org/reference/datamodel.html'''importmathclassVector3():def__init__(self,x,y,z):
self.x=x
self.y=y
self.z=z#置为零向量defzero():
self.x=0
self.y=0
self.z=0#"=" 赋值不支持重载#重载 "==" 操作符def__eq__(self, other):returnself.x==other.xandself.y==other.yandself.z==other.z#重载 "!=" 操作符def__ne__(self, other):returnself.x!=other.xorself.y!=other.yorself.z!=other.z#重载一元 "-" 操作符def__neg__(self):returnVector3(-self.x,-self.y,-self.z)#重载 "+" 操作符def__add__(self, other):returnVector3(self.x+other.x, self.y+other.y, self.z+other.z)#重载 "-" 操作符def__sub__(self, other):returnVector3(self.x-other.x, self.y-other.y, self.z-other.z)#重载 "*" 操作符def__mul__(self, a):returnVector3(self.x*a, self.y*a, self.z*a)#重载 "/" 操作符def__div__(self, a):if(a!=0):returnVector3(self.x/a, self.y/a, self.z/a)else:returnNone#重载 "+=" 操作符def__iadd__(self, other):
self.x+=other.x
self.y+=other.y
self.z+=other.zreturnself#重载 "-=" 操作符def__isub__(self, other):
self.x-=other.x
self.y-=other.y
self.z-=other.zreturnself#重载 "*=" 操作符def__imul__(self, a):
self.x*=a
self.y*=a
self.z*=areturnself#重载 "/=" 操作符def__idiv__(self, a):if(a!=0):
self.x/=a
self.y/=a
self.z/=areturnself#向量标准化defnormalize(self):
magSq=self.x*self.x+self.y*self.y+self.z*self.zif(magSq>0):
oneOverMag=1.0/math.sqrt(magSq)
self.x*=oneOverMag
self.y*=oneOverMag
self.z*=oneOverMag#向量求模defvectorMag(self):returnmath.sqrt(self.x*self.x+self.y*self.y+self.z*self.z)#向量显示deftoString(self):print"{x:"+str(self.x)+",y:"+str(self.y)+",z:"+str(self.z)+"}"#向量点乘defdotProduct(va, vb):returnva.x*vb.x+va.y*vb.y+va.z*vb.z#向量叉乘defcrossProduct(va, vb):
x=va.y*vb.z-va.z*vb.y
y=va.z*vb.x-va.x*vb.z
z=va.x*vb.y-va.y*vb.xreturnVector3(x,y,z)#计算两点间的距离defdistance(va, vb):
dx=va.x-vb.x
dy=va.y-vb.y
dz=va.z-vb.zreturnmath.sqrt(dx*dx+dy*dy+dz*dz)