精华内容
下载资源
问答
  • 基于张量距离的高阶近邻传播聚类算法.pdf
  • 为了正则化扩散张量磁共振成像所产生的扩散张量场,提出了一种非线性张量值加权方向距离滤波方法。首先通过张量间的二次点积定义了张量值图像的方向滤波,然后结合张量中值滤波引入了一个联合最小化准则,在此准则的...
  • 异常检测在遥感高光谱图像(HSI)处理中起着... 另外,为了增强背景和异常的分离,我们将background.pixels的马氏距离之和最小化。 在四个HSI上进行的实验表明,该方法在重建和异常检测准确性方面均优于几种最新技术。
  • 随着可穿戴式传感器和移动设备数量的增加,基于多个传感器的人类活动识别(HAR)近年来引起了越来越多的关注。 由于人类行为的多样性,对活动的... 其活动识别的正确率要高于模糊c均值聚类和基于张量距离的模糊聚类。
  • torch.cosine_similarity 可以对两个向量或者张量计算相似度 >>> input1 = torch.randn(100, 128) >>> input2 = torch.randn(100, 128) >>> output = torch.cosine_similarity(input1, ...

    torch.cosine_similarity 可以对两个向量或者张量计算相似度

    >>> input1 = torch.randn(100, 128)
    >>> input2 = torch.randn(100, 128)
    >>> output = torch.cosine_similarity(input1, input2, dim=1)
    print(output.shape)

    torch.Size([100])
    

    hg1 = torch.FloatTensor(torch.randn([12]))
    hg2 = torch.FloatTensor(torch.randn([12]))
    torch.cosine_similarity(hg1, hg2, dim=0)

    tensor(-0.1543)

    pytorch计算欧式距离

    torch.dist(hg1, hg2, p=2)

    如果自己写的话就是:(因为很简单,大多数人自己写),Pytorch里封装了这个距离函数

    torch.sqrt(torch.sum((hg1-hg2)**2))

    Hamming 距离,汉密尔顿距离

    torch.dist(hg1, hg2, p=1)

    展开全文
  • 随着弥散张量成像(Diffusion Tensor Imaging, DTI)设备的临床应用,弥散张量图像分割算法已...本算法采用张量的欧氏距离构造能量函数,实验结果表明算法对DTI数据分割可以得到较好的结果,效率提高为原来的6~7倍。
  • 二维张量 乘以 三维张量 机器学习 (Machine Learning) Let’s first briefly recall what linear regression is: 让我们首先简要回顾一下线性回归是什么: Linear regression is estimating an unknown variable in...

    二维张量 乘以 三维张量

    机器学习 (Machine Learning)

    Let’s first briefly recall what linear regression is:

    让我们首先简要回顾一下线性回归是什么:

    Linear regression is estimating an unknown variable in a linear fashion by some other known variables. Visually, we fit a line (or a hyperplane in higher dimensions) through our data points.

    线性回归是通过一些其他已知变量以线性方式估计未知变量。 在视觉上,我们通过数据点拟合一条线(或较大尺寸的超平面)。

    If you’re not comfortable with this concept or want to understand better the math behind it, you can read my previous article about linear regression:

    如果您对这个概念不满意,或者想更好地理解其背后的数学运算,可以阅读我以前关于线性回归的文章:

    Probably, implementing linear regression with TensorFlow is an overkill. This library was made for more complicated stuff like neural networks, complex deep learning architectures, etc. Nevertheless, I think that using it for implementing a simpler machine learning method, like linear regression, is a good exercise for those who want to know how to build custom things with TensorFlow.

    用TensorFlow实施线性回归可能是一个过大的杀伤力。 该库是为更复杂的东西(例如神经网络,复杂的深度学习体系结构等)制作的。尽管如此,我认为,将其用于实现更简单的机器学习方法(如线性回归)对于那些想知道如何使用TensorFlow构建自定义的东西。

    TensorFlow has many APIs; and most introductory courses/tutorials only explain a higher-level API, like Keras. But that may not be sufficient, for example, if you want to use custom loss and/or activation functions that are not yet implemented in Keras.

    TensorFlow有许多API。 并且大多数入门课程/教程仅介绍了Keras等高级API。 但这可能还不够,例如,如果您要使用Keras中尚未实现的自定义丢失和/或激活功能。

    At its core, TensorFlow is just a math library similar to NumPy, but with 2 important improvements:

    TensorFlow的核心只是一个类似于NumPy的数学库,但有两个重要的改进:

    • It uses GPU to make its operations a lot faster. If you have a compatible GPU properly configured, TF 2 will automatically use it; no code changes are required.

      它使用GPU使其操作更快。 如果您具有正确配置的兼容GPU,则TF 2将自动使用它;否则,将自动使用它。 无需更改代码。
    • It is capable of automatic differentiation; this means that for gradient-based methods you don’t need to manually compute the gradient, TensorFlow will do it for you.

      具有自动区分能力; 这意味着对于基于梯度的方法,您无需手动计算梯度,TensorFlow会为您完成。

    You can think of TensorFlow as NumPy on steroids.

    您可以将TensorFlow视为类固醇上的NumPy。

    While these 2 features may not seem like big improvements for what we want to do here (linear regression), since this is not very computationally-expensive and the gradient is quite simple to compute manually, they make a big difference in deep learning where we need a lot of computing power and the gradient is quite nasty to calculate by hand.

    尽管这两个功能似乎对我们在此处想要做的事情(线性回归)似乎没有很大的改进,但是由于这在计算上不是很昂贵,并且梯度很容易手动计算,因此它们在深度学习中有很大的不同需要大量的计算能力,并且手工计算梯度非常麻烦。

    Now, let’s jump to the implementation.

    现在,让我们跳到实现。

    Firstly, we need to, obviously, import some libraries. We import tensorflow as it is the main thing we use for the implementation, matplotlib for visualizing our results, make_regression function, from sklearn, which we will be using to generate a regression dataset for using as an example, and the python’s built-in math module.

    首先,显然,我们需要导入一些库。 我们导入tensorflow因为它是实现的主要内容,从matplotlib可视化结果,从sklearn make_regression函数,我们将使用它生成一个回归数据集作为示例,以及python的内置math函数模块。

    import tensorflow as tfimport matplotlib.pyplot as pltfrom sklearn.datasets import make_regressionimport math

    Then we will create a LinearRegression class with the following methods:

    然后,我们将使用以下方法创建LinearRegression类:

    • .fit() — this method will do the actual learning of our linear regression model; here we will find the optimal weights

      .fit() -此方法将实际学习我们的线性回归模型; 在这里我们将找到最佳权重

    • .predict() — this one will be used for prediction; it will return the output of our linear model

      .predict() -这将用于预测; 它将返回线性模型的输出

    • .rmse() — computes the root mean squared error of our model with the given data; this metric is kind of “the average distance from our model’s estimate to the true y value”

      .rmse() —使用给定数据计算模型的均方根误差; 该指标是“从模型估计值到真实y值的平均距离”

    The first thing we do inside .fit() is to concatenate an extra column of 1’s to our input matrix X. This is to simplify our math and treat the bias as the weight of an extra variable that’s always 1.

    我们在.fit()内部做的第一件事是将一个额外的1列连接到我们的输入矩阵X。这是为了简化我们的数学并将偏见视为额外变量的权重始终为1。

    The .fit() method will be able to learn the parameters by using either closed-form formula or stochastic gradient descent. And to choose which to use, we will have a parameter called method that will expect a string of either ‘solve’ or ‘sgd’.

    .fit()方法将能够通过使用闭式公式或随机梯度下降来学习参数。 为了选择使用哪个参数,我们将有一个名为method的参数,该参数期望使用'solve'或'sgd'的字符串。

    When method is set to ‘solve’ we will get the weights of our model by the following formula:

    method设置为“ solve”时,我们将通过以下公式获得模型的权重:

    Image for post

    which requires the matrix X to have full column rank; so, we will check for this and otherwise we show an error message.

    这要求矩阵X具有完整的列等级; 因此,我们将对此进行检查,否则将显示错误消息。

    The first part of our .fit() method is:

    我们的.fit()方法的第一部分是:

    def fit(self, X, y, method, learning_rate=0.01, iterations=500, batch_size=32):
        X = tf.concat([X, tf.ones_like(y, dtype=tf.float32)], axis=1)
        rows, cols = X.shape
        if method == 'solve':
            if rows >= cols == tf.linalg.matrix_rank(X):
                self.weights = tf.linalg.matmul(
                    tf.linalg.matmul(
                        tf.linalg.inv(
                            tf.linalg.matmul(
                                X,
                                X, transpose_a=True)),
                        X, transpose_b=True),
                    y)
            else:
                print('X has not full column rank. method=\'solve\' cannot be used.')

    Note that the other parameters after method are optional and are used only in the case we use SGD.

    请注意, method之后的其他参数是可选的,仅在使用SGD的情况下使用。

    The second part of this method handles the case of method = ‘sgd’, which doesn’t require that X has full column rank.

    此方法的第二部分处理method = 'sgd'的情况,该方法不需要X具有完整的列等级。

    The SGD algorithm for our least squares linear regression is sketched below:

    下面概述了用于最小二乘线性回归的SGD算法:

    Image for post

    We will start this algorithm by initializing the weights class attribute to a TensorFlow Variable which is a column vector with values drawn from a normal distribution with mean 0 and standard deviation 1/(number of columns). We divide the standard deviation by the number of columns to make sure we don’t get too big values as output in the initial stages of the algorithm. This is to help us converge faster.

    我们将通过将权重类属性初始化为TensorFlow变量来启动此算法,TensorFlow变量是一个列向量,其值取自均值0和标准差1 /(列数)的正态分布。 我们将标准偏差除以列数,以确保在算法的初始阶段不会得到太大的输出值。 这是为了帮助我们更快地收敛。

    At the beginning of each iteration, we randomly shuffle our rows of data. Then, for each batch, we compute the gradient and subtract it (multiplied by the learning rate) from the current weights vector to obtain the new weights.

    在每次迭代的开始,我们随机地随机整理数据行。 然后,对于每个批次,我们计算梯度并将其从当前权重向量中减去(乘以学习率)以获得新的权重。

    In the SGD algorithm sketched above, we had shown the manually computed gradient; it’s that expression multiplied by alpha (the learning rate). But in the code below we won’t compute that expression explicitly; instead, we compute the loss value:

    在上面概述的SGD算法中,我们展示了手动计算的梯度。 就是表达式乘以alpha(学习率)。 但是在下面的代码中,我们不会显式地计算该表达式; 相反,我们计算损失值:

    Image for post

    then we let TensorFlow compute the gradient for us.

    然后让TensorFlow为我们计算梯度。

    Below is the second half of our .fit() method:

    以下是我们的.fit()方法的.fit()

    elif method == 'sgd':
            self.weights = tf.Variable(tf.random.normal(stddev=1.0/cols, shape=(cols, 1)))
            for i in range(iterations):
                Xy = tf.concat([X, y], axis=1)
                Xy = tf.random.shuffle(Xy)
                X, y = tf.split(Xy, [Xy.shape[1]-1, 1], axis=1)
                for j in range(int(math.ceil(rows/batch_size))):
                    begin, size = batch_size*j, batch_size if batch_size*(j+1) < rows else -1
                    Xb, yb = tf.slice(X, [begin, 0], [size, -1]), tf.slice(y, [begin, 0], [size, -1])
                    
                    with tf.GradientTape() as tape:
                        diff = tf.math.subtract(
                            tf.linalg.matmul(Xb, self.weights),
                            yb)
                        loss_value = tf.linalg.matmul(diff, diff,
                                                        transpose_a=True)
                        
                    gradient = tape.gradient(loss_value, self.weights)
                    self.weights.assign_sub(
                        tf.multiply(learning_rate, gradient))
        else:
            print(f'Unknown method: \'{method}\'')
        
        return self

    We need to compute the loss value inside the with tf.GradientTape() as tape block, then call tape.gradient(loss_value, self.weights) to get the gradient. For this to work, it is important that the quantity with respect to which the gradient is taken (self.weights) to be a tf.Variable object. Also, we should use the .assign_sub() method instead of -= when changing the weights.

    我们需要with tf.GradientTape() as tape块计算出内部的损失值,然后调用tape.gradient(loss_value, self.weights)获得梯度。 为此,重要的是,将与之相对应的渐变量( self.weights )设为tf.Variable对象。 另外,更改权重时,应使用.assign_sub()方法而不是-=

    We return self from this method to be able to concatenate the calls of the constructor and .fit() like this: lr = LinearRegression().fit(X, y, ‘solve’).

    我们从此方法返回self ,以便能够像下面这样串联构造函数和.fit()的调用: lr = LinearRegression().fit(X, y, 'solve')

    The .predict() method is quite straight-forward. We first check if .fit() was called before, then concatenate a column of 1’s to X and verify that the shape of X allows multiplication with the weights vector. If everything is OK, we simply return the result of the multiplication between X and the weights vector as the predictions.

    .predict()方法非常简单。 我们首先检查是否曾经调用过.fit() ,然后将1的列连接到X并验证X的形状是否允许与权重向量相乘。 如果一切正常,我们只需返回X与权重向量之间相乘的结果作为预测。

    def predict(self, X):
        if not hasattr(self, 'weights'):
            print('Cannot predict. You should call the .fit() method first.')
            return
        
        X = tf.concat([X, tf.ones((X.shape[0], 1), dtype=tf.float32)], axis=1)
        
        if X.shape[1] != self.weights.shape[0]:
            print(f'Shapes do not match. {X.shape[1]} != {self.weights.shape[0]}')
            return
        
        return tf.linalg.matmul(X, self.weights)

    In .rmse() we first get the outputs of the model using .predict(), then if there were no errors during predict, we compute and return the root mean squared error which can be thought of as “the average distance from our model’s estimate to the true y value”.

    .rmse()我们首先使用得到了模型的输出.predict()然后如果有预测过程中没有错误,我们计算并返回这可以从我们的模型被认为是“平均距离的均方根误差估算到真正的y值”。

    def rmse(self, X, y):
        y_hat = self.predict(X)
        
        if y_hat is None:
            return
        
        return tf.math.sqrt(
            tf.math.reduce_mean(
                tf.math.pow(tf.math.subtract(y_hat, y), 2)))

    Below is the full code of the LinearRegression class:

    下面是LinearRegression类的完整代码:

    class LinearRegression:
        def fit(self, X, y, method, learning_rate=0.01, iterations=500, batch_size=32):
            X = tf.concat([X, tf.ones_like(y, dtype=tf.float32)], axis=1)
            rows, cols = X.shape
            if method == 'solve':
                if rows >= cols == tf.linalg.matrix_rank(X):
                    self.weights = tf.linalg.matmul(
                        tf.linalg.matmul(
                            tf.linalg.inv(
                                tf.linalg.matmul(
                                    X,
                                    X, transpose_a=True)),
                            X, transpose_b=True),
                        y)
                else:
                    print('X has not full column rank. method=\'solve\' cannot be used.')
            elif method == 'sgd':
                self.weights = tf.Variable(tf.random.normal(stddev=1.0/cols, shape=(cols, 1)))
                for i in range(iterations):
                    Xy = tf.concat([X, y], axis=1)
                    Xy = tf.random.shuffle(Xy)
                    X, y = tf.split(Xy, [Xy.shape[1]-1, 1], axis=1)
                    for j in range(int(math.ceil(rows/batch_size))):
                        begin, size = batch_size*j, batch_size if batch_size*(j+1) < rows else -1
                        Xb, yb = tf.slice(X, [begin, 0], [size, -1]), tf.slice(y, [begin, 0], [size, -1])
                        
                        with tf.GradientTape() as tape:
                            diff = tf.math.subtract(
                                tf.linalg.matmul(Xb, self.weights),
                                yb)
                            loss_value = tf.linalg.matmul(diff, diff,
                                                          transpose_a=True)
                            
                        gradient = tape.gradient(loss_value, self.weights)
                        self.weights.assign_sub(
                            tf.multiply(learning_rate, gradient))
            else:
                print(f'Unknown method: \'{method}\'')
            
            return self
        
        def predict(self, X):
            if not hasattr(self, 'weights'):
                print('Cannot predict. You should call the .fit() method first.')
                return
            
            X = tf.concat([X, tf.ones((X.shape[0], 1), dtype=tf.float32)], axis=1)
            
            if X.shape[1] != self.weights.shape[0]:
                print(f'Shapes do not match. {X.shape[1]} != {self.weights.shape[0]}')
                return
            
            return tf.linalg.matmul(X, self.weights)
        
        def rmse(self, X, y):
            y_hat = self.predict(X)
            
            if y_hat is None:
                return
            
            return tf.math.sqrt(
                tf.math.reduce_mean(
                    tf.math.pow(tf.math.subtract(y_hat, y), 2)))

    在示例中使用我们的LinearRegression类 (Using our LinearRegression class in an example)

    To show our implementation of linear regression in action, we will generate a regression dataset with the make_regression() function from sklearn.

    为了表示我们的实施行动线性回归,我们会生成一个数据集的回归与make_regression()从功能sklearn

    X, y = make_regression(n_features=1, n_informative=1,
    bias=1, noise=35)

    Let’s plot this dataset to see how it looks like:

    让我们绘制该数据集以查看其外观:

    plt.scatter(X, y)
    Image for post
    Image by Author
    图片作者

    The y returned by make_regression() is a flat vector. We will reshape it to a column vector to use with our LinearRegression class.

    make_regression()返回的y是一个平面向量。 我们将其LinearRegression为列向量,以与LinearRegression类一起使用。

    y = y.reshape((-1, 1))

    Firstly, we will use method = ‘solve’ to fit the regression line:

    首先,我们将使用method = 'solve'来拟合回归线:

    lr_solve = LinearRegression().fit(X, y, method='solve')plt.scatter(X, y)plt.plot(X, lr_solve.predict(X), color='orange')
    Image for post
    Image by Author
    图片作者

    The root mean squared error of the above regression model is:

    上述回归模型的均方根误差为:

    lr_solve.rmse(X, y)
    # <tf.Tensor: shape=(), dtype=float32, numpy=37.436085>

    Then, we also use method = ‘sgd’ and we will let the other parameters have their default values:

    然后,我们还使用method = 'sgd' ,让其他参数具有其默认值:

    lr_sgd = LinearRegression().fit(X, y, method='sgd')plt.scatter(X, y)plt.plot(X, lr_sgd.predict(X), color='orange')
    Image for post
    Image by Author
    图片作者

    As you can see, the regression lines in the 2 images above for methods ‘solve’ and ‘sgd’ are almost identical.

    如您所见,上面两个图像中方法“ solve”和“ sgd”的回归线几乎相同。

    The root mean squared error we got when using ‘sgd’ is:

    使用'sgd'时得到的均方根误差为:

    lr_sgd.rmse(X, y)
    # <tf.Tensor: shape=(), dtype=float32, numpy=37.86531>

    Here is the Jupyter Notebook with all the code:

    这是Jupyter Notebook的所有代码:

    I hope you found this information useful and thanks for reading! If you liked this article please consider following me on Medium to get my latest articles.

    我希望您发现此信息有用,并感谢您的阅读! 如果您喜欢这篇文章,请考虑在Medium上关注我,以获取我的最新文章。

    翻译自: https://medium.com/towards-artificial-intelligence/how-to-implement-linear-regression-with-tensorflow-406b2cff1ffa

    二维张量 乘以 三维张量

    展开全文
  • 张量分解浅谈(二 CP NMF 张量秩)

    千次阅读 多人点赞 2020-07-18 22:59:26
    欢迎大家来到这一期的张量分解博客学习,本期博客的主要内容就是标题,难度会加大,本人也有写的错误的地方,烦请大家不吝赐教!

    欢迎大家来到这一期的张量分解博客学习,本期博客的主要内容就是标题,难度会加大,本人也有写的错误的地方,烦请大家不吝赐教!

    一. CANDECOMP/PARAFAC分解法

    CANDECOMP(canonical decomposition)和PARAFAC(parallel factors)是一种对高维张量进行拆分的方法, 其核心思想是用有限个的秩1张量的和来(近似地)表示该张量. 这种方法被很多人独立的发现, 不考虑历史上的因素, 我们将其称为CP分解法 (CP decomposition) !

    其实你可以这么理解:

    CP分解是将一个高维的张量,分解成多个核的和,每个核是由向量的外积组成;通过这样的分解,我们可以大大地降低参数的维度。其实,不止CP分解,其他的张量分解算法都是同个道理,只是所采用的分解方法不同而已。当然,这样的分解只是原来张量的近似,没办法保证完全复原。从以上角度来说,张量分解的目的跟矩阵分解是相同的,只是一个是在二维上的分解,另一个是在高维上的分解而已!

    这就要陆续的结合我们之前铺垫的相关知识了,检测前几期博客是否认真学习的时候到了,我们先看定义:

    在这里插入图片描述
    小伙伴们千万别把它想得有多复杂,且听我一步一步的慢慢道来:

    如果我们要把一个3阶张量 X ∈ R I × J × K \mathcal{X} \in \mathbb{R}^{I\times J\times K} XRI×J×K 进行CP分解, 其结果如下:

    X ≈ ∑ r = 1 R a r ∘ b r ∘ c r \mathcal{X} \approx \sum_{r=1}^{R} a_{r}\circ b_{r} \circ c_{r} Xr=1Rarbrcr
    这里的 ∘ \circ 是外积的意思!

    根据上面的图,我们知道这里的 a r a_{r} ar 之类的都是向量,通过三者之间的外积,组成一个新的矩阵,之后将新得到的矩阵求和,就是新的矩阵了, 通过外积的定义, 对张量中的每个元素都有:

    x i j k ≈ ∑ r = 1 R a i r b j r c k r  for  i = 1 , … , I , j = 1 , … , J , k = 1 , … , K x_{i j k} \approx \sum_{r=1}^{R} a_{i r} b_{j r} c_{k r} \text { for } i=1, \ldots, I, j=1, \ldots, J, k=1, \ldots, K xijkr=1Rairbjrckr for i=1,,I,j=1,,J,k=1,,K
    (这一步知道就行)

    我们称那些上式中通过外积组成秩1张量元素的向量集合为 因子矩阵(factor matrices),图片理解如下:
    在这里插入图片描述
    例如, A = [ a 1 a 2 … a R ] \mathbf{A}=\left[\begin{array}{llll}a_{1} & a_{2} & \ldots & a_{R}\end{array}\right] A=[a1a2aR] ,类似的,我们构造 B \mathbf{B} B C \mathbf{C} C ,利用这些定义, CP分解可以被等价写作以下矩阵形式. 注意, 其左侧都是张量的对应mode的矩阵化:
    在这里插入图片描述
    这个的小圆圈里面还有一点的符号代表的是 Khatri−Rao 积!

    接下来通过例子,帮助大家理解:

    在这里插入图片描述
    仔细观察这个例子,相信你很快就会发现它们的规律。

    我们也可以将前面的张量式子改写为horizontal slices和lateral slices的形式, 需要注意的是, 这种以slice切片为主体的表达很难延伸到超过3维的张量之中. 利用Kolda的命名方式, 也可以进一步简化CP模型:
    X ≈ [ A , B , C ] ≡ ∑ r = 1 R a r ∘ b r ∘ c r \mathcal{X} \approx[\mathrm{A}, \mathrm{B}, \mathrm{C}] \equiv \sum_{r=1}^{R} \mathrm{a}_{r} \circ \mathrm{b}_{r} \circ \mathrm{c}_{r} X[A,B,C]r=1Rarbrcr

    为了便利, 我们通常假设 A \mathbf{A} A B \mathbf{B} B C \mathbf{C} C s的列向量都是归一化的(normalized). 而原本的比重(weights)则被对应的向量所吸收, 写作以下形式:
    在这里插入图片描述
    到现在为止, 我们都把注意力放在了3维张量上. 这是因为3维张量恰恰是应用当中最为广泛也是足够满足我们需求的张量. 对于一个N阶的张量 X ∈ R I 1 × I 2 × ⋯ I N \mathcal{X} \in \mathbb{R}^{I_{1}\times I_{2} \times \cdots I_{N}} XRI1×I2×IN来说,他的CP分解可以被写为:
    在这里插入图片描述
    CP分解并未结束,后面的知识逐渐完善之后我们再看!

    二. 张量的秩

    前面说过一个张量能够被写成N个向量的外积就是秩为一的,我们举个例子让大家看一下:
    在这里插入图片描述
    大家应该能猜到这里的 | 表示有重叠的那种意思!那么显然,这就是一个秩为一的张量!

    张量的秩,记作 r a n k ( X ) rank(\mathcal{X}) rank(X) , 我们可以将它 “拆开” ,拆成秩为一的张量之和,那么新张量的数目之和就是这原张量的秩:

    在这里插入图片描述
    显然,这个张量的秩就是2!
    故:

    如果一个张量能够以一个秩一张量的和表示,那么其秩则为1。
    如果一个张量能够以两个秩一张量的和表示,那么其秩则为2。
    如果一个张量能够以三个秩一张量的和表示,那么其秩为3。
    以此类推…

    虽然理论上是这样,但是在真正的高维张量求秩的时候还是非常棘手的,目前木有特定的算法可以直接得到某给定张量的秩,一般的时候都是像上面一下用cp分解尝试!

    三. 非负矩阵分解 (NMF)

    通常的矩阵分解会把一个大的矩阵分解为多个小的矩阵,但是这些矩阵的元素有正有负。而在现实世界中,比如图像,文本等形成的矩阵中负数的存在是没有意义的,所以如果能把一个矩阵分解成全是非负元素是很有意义的。在NMF中要求原始的矩阵的所有元素的均是非负的,那么矩阵可以分解为两个更小的非负矩阵的乘积,这个矩阵有且仅有一个这样的分解,即满足存在性和唯一性

    NMF的基本思想:
    NMF的基本思想可以简单描述为:对于任意给定的一个非负矩阵A,NMF算法能够寻找到一个非负矩阵U和一个非负矩阵V,使得满足 ,从而将一个非负的矩阵分解为左右两个非负矩阵的乘积!

    对于给定矩阵 V ∈ R + F × N \boldsymbol{V}\in \boldsymbol{R_{+}^{F \times N}} VR+F×N,我们需要寻找 非负矩阵 W ∈ R + F × K \boldsymbol{W}\in \boldsymbol{R_{+}^{F \times K}} WR+F×K H ∈ R + K × N \boldsymbol{H}\in \boldsymbol{R_{+}^{K \times N}} HR+K×N使得:
    V ≈ W H \boldsymbol{V}\approx \boldsymbol{W}\boldsymbol{H} VWH

    如下图:
    在这里插入图片描述
    需要注意的是,这里用了约等于,和CP分解是一个道理:当前解法并非精确解,只是数值上的近似解!

    分解前后可理解为:原始矩阵 V \boldsymbol{V} V的列向量是对左矩阵 W \boldsymbol{W} W中所有列向量的加权和,而权重系数就是右矩阵对应列向量的元素,故称 W \boldsymbol{W} W为基矩阵, H \boldsymbol{H} H为系数矩阵。一般情况下 K \boldsymbol{K} K的选择要比 N \boldsymbol{N} N小,即满足 ( F × N ) K ⩽ F N (F\times N)K\leqslant FN (F×N)KFN,这时用系数矩阵代替原始矩阵,就可以实现对原始矩阵进行降维,得到数据特征的降维矩阵,从而减少存储空间,减少计算机资源!
    在这里插入图片描述
    其实说到这里,肯定还有小白不知道这个非负矩阵到底是干什么的,我用电影评分举一个简单的例子:

    比如:
    一个电影里如果只考虑爱情和动作两个因素。
    一个用户也一定会有给爱情打分多一点还是喜欢动作多一点。在这里插入图片描述
    期望就是我们已知下面的矩阵,而期望分解出比较合理的上面两个矩阵。这样就可以用来预测别的用户对别的电影的看法了!当然我这样举例其实是非常不严谨的,但是好理解!

    那么了解的这些东西之后,最大的问题就来了,我们如何能够求解这分解的非负矩阵呢??

    NMF求解问题实际上是一个最优化问题,利用乘性迭代的方法求解和,非负矩阵分解是一个NP问题。NMF 问题的目标函数有很多种,应用最广泛的就是欧几里得距离KL散度.

    在这里插入图片描述

    第一个式子我们可以理解为损失函数,需要我们求解其最小值是对应的各个矩阵,如果你用编程实现的话使用的是:乘法更新发展的迭代更新算法,其将矩阵分解算法转化为如下的优化问题,即最小化两个矩阵之间的欧几里得距离的优化问题:
    在这里插入图片描述
    感兴趣的同学可以了解一下上面的这个迭代跟新算法,其实非常好理解!

    上面都是理论部分,看不懂也莫慌,时间是检验真理的唯一标准,我们玩个小游戏:
    在这里插入图片描述
    这个图我们刚刚见过,但是显然其包含的信息远不止上面那么简单,我们更多的是看它内在蕴含的规律;

    游戏规则是这样的,任何图形乘以黑圆是它本身,任意图形加上圆形是它本身。举个例子, W \boldsymbol{W} W矩阵中的第二行(图中红笔圈起来的一个白圆,一个红三角)乘上H矩阵中四列,由于:
    白圆 × \times ×黑圆=白圆
    红三角 × \times ×黑圆=红三角
    白圆+红三角=红三角
    因此在V矩阵中,第二行第四列的元素为红三角;
    但同时我们也应该关注到, W \boldsymbol{W} W H \boldsymbol{H} H相乘并不能完全还原矩阵V.依然举例说明, V \boldsymbol{V} V矩阵中,第六行(也即是倒数第二行),第一列是一个白圆.
    由于W第六行是一个白圆,一个红三角. H第一列是两个白圆。
    白圆 × \times × 白圆=白圆;
    红三角 × \times ×白圆=红三角;
    白圆+红三角= 红三角;
    而原矩阵中的对应结果显然不符我们推测的结果,这也间接说明我们为什么要用约等于号 !

    这样的处理方法会让我直接想到神经网络中的示意图也是类似于这样的感觉,看下面这个图:

    在这里插入图片描述
    这个图非常好理解,通过前面定义的系数矩阵和基(特征)矩阵,将系数矩阵的每一列 h 1 , h 2 , ⋯ h n \boldsymbol{h_{1},h_{2},\cdots h_{n}} h1,h2,hn 排成上面蓝色的小球球,一次乘以矩阵 W \boldsymbol{W} W 原矩阵的 每一列 v \boldsymbol{v} v 就求出来了,它将原矩阵,权重矩阵以及特征矩阵的关系更加清晰的展现出来了,我们可以看到系数与特征进行线性操作之后可以得到原矩阵,其和神经网络的本质也是一样的,神经网络靠着对特征的学习,得出权重,也是以权重乘以特征的方式去得到最终的答案.NMEE理上等性方程组,这个理解了上面的示意图就非常简单了!

    NMF算法在是真正实现的是时候还有一个特别的地方,就是分解新矩阵的参数K的选择,这就像神经网络里面的调参一样,是个玄学,其中不同的K对于不同模型情况如下:

    • 数据拟合:K越大那么对于数据拟合更好。
    • 模型复杂性:一个更小的K模型更简单(易于预测、少输入参数等)

    下面为声频处理时候不同K的表现:

    在这里插入图片描述

    本期的博客学习就到这里了,下一期我会向大家详细的介绍 张量的另一种分解方法—— 压缩与Tucker分解法,并简单的看一下奇异值分解的相关内容,大家加油!

    展开全文
  • 这里写目录标题一、无穷大张量网络的本征自洽方法张量网络的梯度更新任意尺寸张量网络收缩算法张量网络中的有效哈密顿量思想 一、无穷大张量网络的本征自洽方法 无穷大张量网络的本征自洽方法,称为张量网络编码算法...


    我是一只正在不断学习、希望早日成为小白的小小白,有什么错误欢迎大家批评指正,喜欢的请点个赞哦!
    在这里插入图片描述

    一、无穷大张量网络的本征自洽方法

    无穷大张量网络的本征自洽方法,称为张量网络编码算法(TNE),其思想是将无穷大TN的收缩问题等价成为局域自洽本征方程组求解问题,对于这个自洽的含义不了解也没关系,后文会有介绍,可以放心往后看。
    注释:张量网络简称TN

    将一整行张量构成的MPO当作哈密顿量,则收缩计算可表示成如下“基态”极小化问题,即 min ⁡ ⟨ φ ∣ φ ⟩   ⟨ φ ∣ M P O ∣ φ ⟩ \underset{\left\langle \varphi | \varphi \right\rangle }{\mathop{\min }}\,\left\langle \varphi \right|MPO\left| \varphi \right\rangle φφminφMPOφ

    在这里插入图片描述
    当变分达到极值点后,我们可以近似地认为,MPS就是MPO的本征态,于是本征方程 M P O ∣ φ ⟩ ∼ ∣ φ ⟩ MPO\left| \varphi \right\rangle \sim \left| \varphi \right\rangle MPOφφ。这个有什么用呢?请继续往下看。

    在这里插入图片描述
    只要MPO的基态对应于边界的MPS态,整个张量网络可被看成是无穷多层MPO,其收缩可以被等效为“基态”MPS与一层MPO的内积,一层一层地收缩,最后整个张量网络就被收缩为一层张量,如下图所示,这极大的简化了问题。

    在这里插入图片描述
    在这里插入图片描述

    进行如上收缩以后,假设MPS满足中心正交形式,中心tensor左边的都是从左到右的正交形式,中心tensor右边的都是从右到左的正交形式。根据MPS态的平移不变性,假设中心tensor左边的张量都是一样的,中心tensor右边的张量都是一样的,所以中间有三个不等价张量。中心张量为有效哈密顿量的本征态,我们可以将这个无穷长的收缩问题转化成如下图的局域收缩问题:

    在这里插入图片描述
    注意:上图中左边的中心tensor (绿色张量) 和右边的中心张量不一样

    左/右正交张量可通过对中心张量进行SVD分解或QR分解获得

    在这里插入图片描述
    左/右环境张量分别为左/右转移哈密顿量的本征态,有效哈密顿量由TN中的张量及左/右环境张量构成。

    在这里插入图片描述
    在iDMRG中可以不知道无穷大的张量网络,只需要知道局域张量,需要求解的张量为中心张量、左右正交张量、左右环境张量。通过如下的自洽方法,迭代求解上述张量,如图:

    在这里插入图片描述
    步骤:
    (1) 构造有效哈密顿量,此时有效哈密顿量中的左右最大本征张量是不知道的,可以随机初始化;
    (2) 通过构造的有效哈密顿量求本征态得到中心张量;
    (3) 通过SVD或QR分解得到从左向右以及从右向左的满足正交条件的三阶张量;
    (4) 用的到的三阶张量构造定义左/右转移哈密顿量;
    (5) 用构造的左/右哈密顿量求左/右本征态;
    (6) 用求得的左/右本征态定义有效哈密顿量;
    (7) 重复步骤(2)~(6)直到收敛。
    最后通过有效哈密顿量和左/右转移哈密顿量的本征值和最后达到收敛的张量进行收缩可以得到无穷大张量网络收缩的结果。

    自洽的解释来了!

    在这里插入图片描述

    由上面我们可以看出对于局域自洽本征方程组求解问题,自洽体现在一组本征问题的定义是基于另一组本征问题的解,例如有效哈密顿量的定义是基于左/右转移哈密顿量本征问题的解,而左/右转移哈密顿量的定义是基于有效哈密顿量本征问题的解,有木有很神奇。

    iTEBD算法对局部张量收缩和裁剪的操作如图所示:

    在这里插入图片描述
    当系统无穷大且满足平移不变性,那么算法中所有计算都是对不等价张量的计算。定义iTEBD中的“转移哈密顿量”,当MPS收敛时,易得该张量为转移哈密顿量的本征态。

    在这里插入图片描述让人头疼的来了!
    在这里插入图片描述

    当利用iTEBD收缩竖直方向指标来计算张量网络收缩,等效同时在水平方向上进行iDMRG计算。iTEBD计算得到的是水平方向上一行张量构成的MPO的基态,iDMRG计算得到的是竖直方向上一列构成的MPO的基态,如图:

    在这里插入图片描述
    整个iTEBD的自洽计算流程及其与iDMRG的对应关系如下图所示:

    在这里插入图片描述

    整个iDMRG的自洽计算流程及其与iTEBD的对应关系如下图所示:

    在这里插入图片描述
    如果看完很懵,那就休息会再从头开始看,认认真真多看几遍就懂了(ง •_•)ง

    二、张量网络的梯度更新

    在上面的介绍中,iTEBD和iDMRG算法将基态的计算转化成了TN的收缩计算,MPS态是作为计算TN收缩的工具,即一行张量构成的MPO的近似本征态。

    实际上,张量网络的收缩问题与变分问题具有一定的等价性,梯度法求解张量网络收缩也是TN领域中一种常见的方法。要解决的就是,在MPS态归一条件下,极小化下图所示能量:

    在这里插入图片描述
    假设MPS中每一个张量相互独立,那么这个问题用梯度更新法来算,实际上就是求能量关于每一个局域张量的梯度。

    对应局域张量的更新方法为 A ( n ) ← A ( n ) − η ∂ E ∂ A ( n ) {{A}^{(n)}}\leftarrow {{A}^{(n)}}-\eta \frac{\partial E}{\partial {{A}^{(n)}}} A(n)A(n)ηA(n)E。所以基于梯度法极小化能量的核心问题在于算出梯度。

    在这里插入图片描述
    实际上,对于任何闭合张量网络,其关于某张量的导数等于该张量从张量网络中移除之后所得的张量网络,如图:

    在这里插入图片描述
    由上面的图我们可以看出,代表导数的张量网络的开放指标即为被求导张量的指标,所以计算导数张量网络的收缩后得到的张量与被求导张量同阶同维,张量网络导数计算就是张量网络的收缩计算。

    三、任意尺寸张量网络收缩算法

    由前面的学习我们知道,无论是TN重整化群算法还是encoding算法,通常都要求张量网络的几何结构具有一定的规律,比如一维链、正方格子、三角格子等。并且,对于不同几何的张量网络对应的张量分解与收缩方程往往不同。那有没有一种通用的计算方法呢?有的,接下来引入一种计算任意张量网络收缩的算法,步骤如下:
    (1) 为张量编号,并重新绘制成圈状网络,需要注意的是张量网络的定义只与节点之间的连接有关系,与网络的具体形状无关;
    (2) 收缩掉仅有最近邻连接的张量,且收缩不会增加求和指标的维数,收缩之后张量个数减小,收缩方法不唯一;

    如何解释最近邻连接的张量?我的判断方法就是当两个张量进行收缩得到的张量阶数小于或等于收缩前张量的最大阶数,那么它们就可以被称为最近邻张量。我们看图说话,比如张量2和张量3收缩后的张量阶数是4,等于收缩前张量3的阶数,所以张量2和张量3就是最近邻连接的张量,再比如张量7和张量8收缩后的张量的阶数为5,大于张量7的阶数也大于张量8的阶数,所以张量7和张量8不是最近邻连接的张量。

    在这里插入图片描述
    (3) 再次收缩掉仅有最近邻连接的张量,例如张量2和张量3;
    (4) 若无仅有最近邻连接的张量,则进行交换操作,交换的目的是减小非最近邻连接的距离。交换方法:收缩掉张量之间的最近邻连接后,使用SVD分解成两个张量,并进行维数裁剪。为什么要进行分解?如果不进行分解,张量网络的指标的个数会不断增加;

    在这里插入图片描述
    (5) 交换操作后未出现仅有最近邻连接的张量则继续进行交换操作直到出现仅有最近邻连接的张量,然后回到步骤(2);若仅剩下两个张量则直接进行收缩完成全部计算。

    在这里插入图片描述
    交换操作会引入近似,所以需要尽量降低交换操作的次数。如果在交换操作的过程中,出现仅含有最近邻连接的张量,可以在SVD前先进行收缩。

    四、张量网络中的有效哈密顿量思想

    有效哈密顿量是张量网络中一个非常重要度的思想,在DMRG和TEBD算法中,已经用到了“有效哈密顿量”的思想。以iDMRG为例,其有效哈密顿量的基态给出的满足中心正交形式的MPS态的中心张量就是有效哈密顿量的基态。从密度矩阵方面考虑,从DMRG中有效哈密顿量的基态出发,可以近似的给出原系统相应的密度矩阵,以下图为例:

    在这里插入图片描述
    用DMRG算出整个系统的MPS态,如果用two-site的iDMRG,那么中心张量满足:左边满足左正则、右边满足右正则、中心满足归一化的张量。要观测这两个site上的局域能量,即计算它的约化密度矩阵。先把需要计算的site断开,然后把其它的所有物理指标收缩掉,得到约化密度矩阵。由此可以看出,由中心张量给出的约化密度矩阵为真实约化密度矩阵的最优近似。

    由上述信息,可以定义量子纠缠模拟(QES),即利用少体系统最优地模拟无穷大多体系统性质。具体内容:引入纠缠库格点,即由中心张量给出的约化密度矩阵的几何自由度,构造包含少量物理及纠缠库格点的少体系统哈密顿量,使得将基态中纠缠库求迹后所得的物理约化密度矩阵为无穷大系统基态对应的约化密度矩阵的最优低秩近似。如下图,蓝色球之间的相互作用就是原哈密顿量之间的相互作用,蓝球和红球之间的相互作用需要用QES进行优化。
    在这里插入图片描述
    QES的一维版本就是DMRG或TEBD。再看看QES计算无穷大二维六角晶格上的自旋体系的基态,构造如下图所示有限的尺寸的体系:
    在这里插入图片描述
    蓝色格点之间的相互作用就是原哈密顿量之间的相互作用,蓝点和红点之间的相互作用需要用QES进行优化,优化的目标就是使得该有限尺寸体系的基态中的约化密度矩阵去最优地近似无穷大体系的基态中的待求site的约化密度矩阵。

    我是一只正在不断学习、希望早日成为小白的小小白,有什么错误欢迎大家批评指正,喜欢的请点个赞哦!
    在这里插入图片描述

    展开全文
  • PyTorch有各种组件: Torch有与NumPy类似的功能,但是支持GPU。 torch.autograd提供了用于实现任意标量值函数的...Multiprocessing是一个用于在多个张量之间共享内存的有用库。 Utils有加载数据的实用函数;它还有其
  • 张量展开与tensor tool box

    千次阅读 2017-05-02 12:55:55
    1张量的定义在维基百科上,张量被定义为“一个多重线性映射”:这个可以理解为一个多维数组,当变换坐标或者变换基底的时候,其分量会按照一定的规则变换。2.张量的模展开矩阵在实际运算当中,我们有时需要对张量...
  • 弥散张量成像DTI

    千次阅读 2020-07-14 00:28:36
    弥散张量成像原理 Diffusion tensor imaging, DTI什么是弥散张量成像?基本概念背景弥散张量的定量表示量化指标平均弥散系数各向异性程度弥散的主要方向三维可视化量化分析参考文献 什么是弥散张量成像? 基本概念 ...
  • tensor tool 张量工具包

    2018-05-17 10:24:21
    张量tucker分解、CP、PARAPAC分解,khatri-rao积,以及张量和矩阵的乘积等代码
  • Tensor Factorization Using Auxiliary Information摘要介绍2 辅助信息张量补全问题2.1使用低秩分解的张量分析 摘要 现有的大多数张量(或多路阵列)分析方法仅假设要完成的张量等级较低。 但是,例如,当将它们应用...
  • Numpy, 张量,相关函数使用(逐步更新)张量查看Numpy张量张量形状与数据类型相关函数np.exp(z)np.insert()函数np. argmax()np.mean() 张量 张量是矩阵向任意维度的推广(张量的维度通常叫轴) 仅含一个数字的张量...
  • 张量 神经网络使用的数据经常是存储在Numpy数组中,也称为张量。 一般来说,当前所有机器学习系统都使用张量作为基本数据结构。 张量这一概念的核心在于,它是一个数据容器。它包含的数据几乎总是数值数据,因此它...
  • 转动惯量与惯性张量

    千次阅读 2020-08-13 17:19:03
    转动惯量和惯性张量’的定义 转动惯量是表征刚体转动惯性大小的物理量,它与刚体的质量、质量相对于转轴的分布有关。 大家都知道动能E=(1/2)mv¬2,而且动能的实际物理意义是:物体相对某个系统(选定一个参考系)...
  • 矩阵和张量运算构成了广泛领域和应用的基础,并且在许多情况下构成了整体计算复杂性的重要部分。通用gpu能够加速其中许多操作并使其他操作成为可能,这导致了这些设备的广泛适应性。为了充分利用张量运算的计算能力...
  • 最通俗的语言解释什么是张量,最近有混乱和不理解的可以详细看一下,耐心看就行。emmmm 一、一维张量 从一维开始: tf.constant([1.0 , 3.0 , 6.0]) 表示:生成一个一维张量(向量),shape是1行3列即shape是[3]。...
  • 张量运算的导数:梯度

    千次阅读 2020-03-04 23:40:54
    梯度(gradient)是张量运算的导数。它是导数这一概念向多元...你可以用 W 来计算预测y_pred,然后计算损失,或者说预测值 y_pred 和目标 y 之间的距离。 y_pred = dot(W, x) loss_value = loss(y_pred, y) 如果输...
  • (2) 张量

    2020-09-23 11:28:07
    A PyTorch Tensor is a view over such a Storage that’s capable of indexing into that storage by using an offset and per-dimension strides.(通过偏移量和每个维度的距离在内存中索引) The underlying ...
  • Robust Image Hashing with Tensor Decomposition一算法步骤预处理构造张量张量分解计算图像哈希相似性实验摘要 一 多媒体哈希是从多媒体中提取出来的、基于内容的一种简洁表示。通过多媒体哈希算法可将任意的多媒体...
  •   对于一个矩阵,可以将行作为起始地点,将列作为目标地点,那么对应的元素值可以代表起始地点到目标地点的距离,类似的,我们把矩阵的行作为输入,列作为输出,行数可以使用指标i代表输入空间的维数,列数可以用...
  • '''一维张量乘以一维张量''' # x.shape=torch([m]).y.shape=torch([m]),z.shape=torch(value) z=torch.dot(x,y) # 或者 z=torch.randn(y,x) '''二维张量相乘''' # x.shape=torch([m,n]),y.shape=torch([n,d]),z....
  • 张量(Tensor)的基本含义 张量,可以简单的理解为多维数组,是二维向量在更高的维度的延申。 用到的库和框架 import torch import numpy as np 张量的创建torch.tensor() 通过列表创建张量 # 通过列表创建张量 t ...
  • 针对传统模糊C均值聚类算法对图像特征描述单一,易受图像复杂纹理干扰而出现误分割的问题,提出一种基于自适应结构张量的FCM算法,并将其应用于...采用一种新颖的节点间距离度量公式来计算图像中节点与聚类中心点的差异.仿
  • 本次将继续学习张量分解的有关内容。 一.TURCKER分解 二.非负矩阵分解 三.奇异值分解和高阶张量的奇异值分解 (一般)矩阵的奇异值分解(SVD) 高阶张量的奇异值分解(HOSVD) 四.其他矩阵分解 1.LU分解 2.正交分解...
  • 再开p次根 即 ∣∣x∣∣p=(∑∣xi∣p)1/p ||x||_p = (\sum{|x_i|^p})^{1/p} ∣∣x∣∣p​=(∑∣xi​∣p)1/p 故 1范数为向量各元素绝对值之和 2范数为向量各元素平方和再开根号,即距原点的欧式距离 特殊的,无穷范数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,579
精华内容 3,031
关键字:

张量距离