小编max*_*moo的帖子

我在scikit-learn 封装中使用截断的SVD .

在SVD的定义中,原始矩阵阿被approxmated作为产品甲 ≈ UΣV*其中ù和V具有正交列,并且Σ是非负对角线.

我需要得到U,Σ和V*矩阵.

看一下这里的源代码,我发现调用后V*存储在self.components_字段中fit_transform.

是否有可能得到U  和Σ矩阵？

我的代码:

import sklearn.decomposition as skd
import numpy as np

matrix = np.random.random((20,20))
trsvd = skd.TruncatedSVD(n_components=15)
transformed = trsvd.fit_transform(matrix)
VT = trsvd.components_

来自文档:

转置a.根据烫发更换尺寸.

返回的张量的维度i将对应于输入维度perm[i].如果perm没有给出,则设置为(n-1 ... 0),其中n是输入张量的等级.因此,默认情况下,此操作在2-D输入张量上执行常规矩阵转置.

但是我仍然有点不清楚我应该如何切割输入张量.例如,来自文档:

tf.transpose(x, perm=[0, 2, 1]) ==> [[[1  4]
                                      [2  5]
                                      [3  6]]

                                     [[7 10]
                                      [8 11]
                                      [9 12]]]

为什么perm=[0,2,1]产生1x3x2张量？

经过一些试验和错误:

twothreefour = np.array([ [[1,2,3,4], [5,6,7,8], [9,10,11,12]] , 
                        [[13,14,15,16], [17,18,19,20], [21,22,23,24]] ])
twothreefour

[OUT]:

array([[[ 1,  2,  3,  4],
        [ 5,  6,  7,  8],
        [ 9, 10, 11, 12]],

       [[13, 14, 15, 16],
        [17, 18, 19, 20],
        [21, 22, 23, 24]]])

如果我转置它:

fourthreetwo = tf.transpose(twothreefour) 
with …

我正在尝试使用新的流式音频API.以下回复是否有效？当我在我的设备上测试它时,我得到"技能有问题"错误.

这是我的AWS-lambda函数的代码:

def lambda_handler(event, context):
    return {
        "response": {
            "directives": [
                {
                    "type": "AudioPlayer.Play",
                    "playBehavior": "REPLACE_ALL",
                    "audioItem": {
                        "stream": {
                            "token": "12345",
                            "url": "http://emit-media-production.s3.amazonaws.com/pbs/the-afterglow/2016/08/24/1700/201608241700_the-afterglow_64.m4a",
                            "offsetInMilliseconds": 0
                        }
                    }
                }
            ],
            "shouldEndSession": True
        }
    }

如果我想要随机训练/测试分裂,我使用sklearn辅助函数:

In [1]: from sklearn.model_selection import train_test_split
   ...: train_test_split([1,2,3,4,5,6])
   ...:
Out[1]: [[1, 6, 4, 2], [5, 3]]

什么是最简洁的方式来获得非混乱的火车/测试分裂,即

[[1,2,3,4], [5,6]]

编辑目前我正在使用

train, test = data[:int(len(data) * 0.75)], data[int(len(data) * 0.75):] 

但希望有更好的东西.我在sklearn上打开了一个问题 https://github.com/scikit-learn/scikit-learn/issues/8844

编辑2:我的PR已经被合并,在scikit学习版本0.19,你可以传递参数shuffle=False,以train_test_split获得非改组的分裂.

运行涉及以下函数的python程序时,image[x,y] = 0 会出现以下错误消息.这意味着什么以及如何解决它？谢谢.

警告

VisibleDeprecationWarning: using a non-integer number instead of an integer   
will result in an error in the future
image[x,y] = 0
Illegal instruction (core dumped)

码

def create_image_and_label(nx,ny):
  x = np.floor(np.random.rand(1)[0]*nx)
  y = np.floor(np.random.rand(1)[0]*ny)

  image = np.ones((nx,ny))
  label = np.ones((nx,ny))
  image[x,y] = 0
  image_distance = ndimage.morphology.distance_transform_edt(image)

  r = np.random.rand(1)[0]*(r_max-r_min)+r_min
  plateau = np.random.rand(1)[0]*(plateau_max-plateau_min)+plateau_min

  label[image_distance <= r] = 0 
  label[image_distance > r] = 1
  label = (1 - label)

  image_distance[image_distance <= r] = 0 
  image_distance[image_distance > r] …

我可以使用语法突出显示一列

import pandas as pd
df = pd.DataFrame([[1,0],[0,1]])
df.style.apply(lambda x: ['background: lightblue' if x.name == 0 else '' for i in x])

同样,我可以通过传递突出显示一行axis=1:

df.style.apply(lambda x: ['background: lightgreen' if x.name == 0 else '' for i in x], 
               axis=1)

但是,我无法弄清楚如何同时做两件事; 问题是,当我使用时applymap,我只获取值,而不是它们来自的系列的名称.

是否有添加到现有语料库的功能？我已经生成了我的矩阵,我希望定期添加到表中而不需要重新整理整个sha-bang

例如;

articleList = ['here is some text blah blah','another text object', 'more foo for your bar right now']
tfidf_vectorizer = TfidfVectorizer(
                        max_df=.8,
                        max_features=2000,
                        min_df=.05,
                        preprocessor=prep_text,
                        use_idf=True,
                        tokenizer=tokenize_text
                    )
tfidf_matrix = tfidf_vectorizer.fit_transform(articleList)

#### ADDING A NEW ARTICLE TO EXISTING SET?
bigger_tfidf_matrix = tfidf_vectorizer.fit_transform(['the last article I wanted to add'])

我需要dtype在函数中使用pandas列,但由于某种原因,当我使用函数调用时apply,dtype更改为object.有谁知道这里发生了什么？

import pandas as pd

df = pd.DataFrame({'stringcol':['a'], 'floatcol': [1.5]})
df.dtypes
Out[1]: 
floatcol     float64
stringcol     object
dtype: object

df.apply(lambda col: col.dtype)
Out[2]: 
floatcol     object
stringcol    object
dtype: object

请注意,如果直接传递列,则不会发生此问题:

f = lambda col: col.dtype
f(test.floatcol)
Out[3]: dtype('float64')

我目前正在研究DNA序列数据,我遇到了一些性能障碍.

我有两个查找字典/哈希(作为RDD),其中DNA"单词"(短序列)作为键,索引位置列表作为值.一个用于较短的查询序列,另一个用于数据库序列.即使是非常非常大的序列,创建表也非常快.

对于下一步,我需要将它们配对并找到"命中"(每个常用词的索引位置对).

我首先加入查找字典,速度相当快.但是,我现在需要这些对,所以我必须进行两次flatmap,一次是从查询中扩展索引列表,第二次是从数据库中扩展索引列表.这不是理想的,但我没有看到另一种方法.至少它表现不错.

此时的输出是:(query_index, (word_length, diagonal_offset)),其中对角线偏移量是database_sequence_index减去查询序列索引.

但是,我现在需要找到具有相同对角线偏移量的索引对(db_index - query_index)并合理地靠近并加入它们(因此我增加了单词的长度),但仅作为对(即一旦我加入一个索引)与另一个,我不希望任何其他东西与它合并).

我使用一个名为Seed()的特殊对象使用aggregateByKey操作.

PARALELLISM = 16 # I have 4 cores with hyperthreading
def generateHsps(query_lookup_table_rdd, database_lookup_table_rdd):
    global broadcastSequences

    def mergeValueOp(seedlist, (query_index, seed_length)):
        return seedlist.addSeed((query_index, seed_length))

    def mergeSeedListsOp(seedlist1, seedlist2):
        return seedlist1.mergeSeedListIntoSelf(seedlist2)

    hits_rdd = (query_lookup_table_rdd.join(database_lookup_table_rdd)
                .flatMap(lambda (word, (query_indices, db_indices)): [(query_index, db_indices) for query_index in query_indices], preservesPartitioning=True)
                .flatMap(lambda (query_index, db_indices): [(db_index - query_index, (query_index, WORD_SIZE)) for db_index in db_indices], preservesPartitioning=True)
                .aggregateByKey(SeedList(), mergeValueOp, mergeSeedListsOp, PARALLELISM)
                .map(lambda (diagonal, seedlist): (diagonal, seedlist.mergedSeedList))
                .flatMap(lambda (diagonal, seedlist): [(query_index, …

我正在做一些粒子物理分析,希望有人可以给我一些关于高斯过程拟合的见解,我试图用来推断一些数据.

我有不确定性的数据,我正在参与scikit-learn GaussianProcess算法.我通过"nugget"参数包含了uncertanties(我的实现匹配一个标准示例,其中我的"corr"是指数的平方,"nugget"值设置为(dy/y)**2).主要关注点是:我在分布的边缘处具有较低的绝对不确定性(但是高分数不确定性),这产生了比该区域中预期的更大的预测置信区间(参见下图).

不确定性以这种方式表现的原因是我正在处理粒子物理数据,这是用不同特征(x)值观察到的粒子计数的直方图.这些计数遵循泊松分布,因此具有sqrt(N)的不确定性(标准偏差).因此,分布的较高计数区域具有较高的绝对值,但较低的分数不确定性,反之亦然,对于低计数区域.

我理解,正如我所提到的,当使用平方指数内核时,此函数中的"nugget"参数应具有(分数不确定性)**2的值.所以有意义的是,如果预测的不确定性是基于输入的分数不确定性,那么它在边缘上可能很大.但是我并不完全理解这在数学中如何发挥作用,并且预测不确定性的大小比边缘的数据点不确定性大得多,这对我来说似乎是错误的.

谁能评论这里发生了什么？这是否符合预期？如果是这样,为什么？任何有关该主题的进一步阅读的想法或参考将不胜感激!

我会给你留下几个重要的警告:

1)在分布的边缘有几个数据点,零计数.这引发了"金块"的分数不确定性的扭结,因为(sqrt(0)/ 0)**2不是一个非常幸福的值.我在这里做了一个调整,只是将这些点的金块值设置为1.0,这相当于你得到的值,如果这是1的数量.我相信这是一个常见的近似值确实影响了手头的问题,但我不知道我认为它从根本上改变了这个问题.

2)我正在使用的数据实际上是2d直方图(即,一个独立变量(比如x),另一个(y)和计数作为因变量(z)).所示的图是2d数据和预测的1d切片(即z与x在小范围的y上积分).我不认为这真的会影响到手头的问题,但我想我会提到它.