精华内容
下载资源
问答
  • 通过稀疏的低表示来减少不完整的面向数据的多视图维度
  • 数据维度

    2020-01-14 15:57:36
    特征挖掘衍生

    特征挖掘和衍生

    维度扩充

    展开全文
  • TFRecord存储维度、rank、dimension)较多的数据以及创建Dataset的过程 第一次接触tensorflow的DatasetEstimator是在阅读BERT的特定任务的代码,原本用低阶API需要写很长的代码,在Estimator模式中简化了许多...

    TFRecord存储维度(秩、rank、dimension)较多的数据以及创建Dataset的过程

    第一次接触tensorflow的Dataset和Estimator是在阅读BERT的特定任务的代码,原本用低阶API需要写很长的代码,在Estimator模式中简化了许多。
    原本代码中的输入数据(即Dataset中的Example)的每个特征(即每个Example含有的Feature)的秩都为1,即矢量如v=[1,2,3],其rank为1,shape为(3,)。而后续为了引入更多新的特征,比如charCNN或者charRNN来捕捉词语的形态特征,则需要在原来每个时间步的维度上再扩展一个维度,用于放置该时间步的字母。如[‘Are’, ’ you’, ‘OK’],则输入为[[‘A’,‘r’,‘e’],[‘y’,‘o’,‘u’],[‘O’,‘K’]],此时该Feature的rank为2,shape为(3,3)(此处将‘OK’ pad为长度为3的序列即可)。
    那么这种多维度,rank>=2的形式的Feature应该怎么存储呢,后续又应该怎么读出到Dataset并解析呢。

    保留该Feature的Shape信息后拉直(Flatten)Feature

    这里借YJango大神的例子来举个栗子,然后再写写我的啦。

    大神的例子

    在这里插入图片描述
    在这里插入图片描述
    这里有三个example,每个example都有四类feature,分别是标量、向量、矩阵和张量,它们的shape分别为(),(3,),(2,3)和(806,806,3)。

    写入tfrecord

    那应该怎么写入这些形态各异的特征呢?两种方法。

    • 将其flatten成list形式,即rank=1的向量形式,然后按照list形式写入,如int64_list = tf.train.Int64List(value=输入)或float_list = tf.train.FloatList(value=输入)。
    • 转成string类型:将张量用.tostring()转换成string类型,再用tf.train.Feature(bytes_list=tf.train.BytesList(value=[input.tostring()]))来存储。

    这两种方法都会丢失数据的维度,因此需要将其存储以备后续使用或者提前将这些参数预设好即可。

    # 打开一个tfrecord文件,准备进行写入
    writer = tf.python_io.TFRecordWriter('%s.tfrecord' %'test') 
    # 这里我们将会写3个样本,每个样本里有4个feature:标量,向量,矩阵,张量
    for i in range(3):
        # 创建字典
        features={}
        # 写入标量,类型Int64,由于是标量,所以"value=[scalars[i]]" 变成list
        features['scalar'] = tf.train.Feature(int64_list=tf.train.Int64List(value=[scalars[i]]))
        
        # 写入向量,类型float,本身就是list,所以"value=vectors[i]"没有中括号
        features['vector'] = tf.train.Feature(float_list = tf.train.FloatList(value=vectors[i]))
        
        # 写入矩阵,类型float,本身是矩阵,一种方法是将矩阵flatten成list
        features['matrix'] = tf.train.Feature(float_list = tf.train.FloatList(value=matrices[i].reshape(-1)))
        # 然而矩阵的形状信息(2,3)会丢失,需要存储形状信息,随后可转回原形状
        features['matrix_shape'] = tf.train.Feature(int64_list = tf.train.Int64List(value=matrices[i].shape))
        
        # 写入张量,类型float,本身是三维张量,另一种方法是转变成字符类型存储,随后再转回原类型
        features['tensor'] = tf.train.Feature(bytes_list=tf.train.BytesList(value=[tensors[i].tostring()]))
        # 存储丢失的形状信息(806,806,3)
        features['tensor_shape'] = tf.train.Feature(int64_list = tf.train.Int64List(value=tensors[i].shape))
        
        # 将存有所有feature的字典送入tf.train.Features中
        tf_features = tf.train.Features(feature= features)
        # 再将其变成一个样本example
        tf_example = tf.train.Example(features = tf_features)
        # 序列化该样本
        tf_serialized = tf_example.SerializeToString()
        # 写入一个序列化的样本
        writer.write(tf_serialized)
        # 由于上面有循环3次,所以到此我们已经写了3个样本
     # 关闭文件    
    writer.close()
    

    建立Datasets

    由于从tfrecord文件中导入的样本是刚才写入的tf_serialized序列化样本,所以我们需要对每一个样本进行解析。
    这里就用dataset.map(parse_function)来对dataset里的每个样本进行相同的解析操作。而parse_function的解析过程几乎就是上述过程的逆过程。此外,我们还能在parse_function里进行很多其他操作,比如转换数据的dtype,给每个数据加入噪音等等。总之,在parse_function内,我们处理的对象就是一个序列化后的serialized_example,我们要对serialized_example进行解码获得example,然后返回这个example。
    其解析函数的写法为:

    def parse_function(example_proto):
        # 只接受一个输入:example_proto,也就是序列化后的样本tf_serialized
        dics = {# 这里没用default_value,随后的都是None
                'scalar': tf.FixedLenFeature(shape=(), dtype=tf.int64, default_value=None), 
                 
                # vector的shape刻意从原本的(3,)指定成(1,3)
                'vector': tf.FixedLenFeature(shape=(1,3), dtype=tf.float32), 
                
                # 因为这里还不知道matrix的shape,所以使用 VarLenFeature来解析。
                'matrix': tf.VarLenFeature(dtype=dtype('float32')), 
                'matrix_shape': tf.FixedLenFeature(shape=(2,), dtype=tf.int64), 
                
                # tensor在写入时 使用了toString(),shape是()
                # 但这里的type不是tensor的原type,而是字符化后所用的tf.string,随后再回转成原tf.uint8类型
                'tensor': tf.FixedLenFeature(shape=(), dtype=tf.string), 
                'tensor_shape': tf.FixedLenFeature(shape=(3,), dtype=tf.int64)
                }
                
        # 把序列化样本和解析字典送入函数里得到解析的样本
        parsed_example = tf.parse_single_example(example_proto, dics)
        # 解码字符
        parsed_example['tensor'] = tf.decode_raw(parsed_example['tensor'], tf.uint8)
        # 稀疏表示 转为 密集表示
        parsed_example['matrix'] = tf.sparse_tensor_to_dense(parsed_example['matrix'])
        # 转变matrix形状
        parsed_example['matrix'] = tf.reshape(parsed_example['matrix'], parsed_example['matrix_shape'])
        # 转变tensor形状
        parsed_example['tensor'] = tf.reshape(parsed_example['tensor'], parsed_example['tensor_shape'])
        # 返回所有feature
        return parsed_example
    

    此处如果我们有matrix的shape的一些信息,就并不需要用VarLenFeature进行解析,可以直接将matrix的shape中每个数相乘即可得到flatten后的matrix的list的信息,即’matrix’: tf.FixedLenFeature(shape=[matrix.shape()[0]*matrix.shape()[1]],dtype=dtype(‘float32’))。
    写好解析函数以后,将这个解析函数作为dataset的map方法的输入即可。
    剩下的batch,shuffle等操作就不再赘述了。建立迭代器的操作有这篇博客讲得很好了。

    我的破例子

    def filed_based_convert_examples_to_features(
            examples, tokenizer, output_file):
        """
        :param examples:
        :param tokenizer:
        :param output_file:
        :param mode:
        :return: number of small example
        """
        num_examples = 0
        writer = tf.python_io.TFRecordWriter(output_file)
        # 遍历训练数据
        for (ex_index, example) in enumerate(examples):
            # 对于每一个训练样本,
            feature_list = convert_single_example(example, tokenizer)
            num_examples += len(feature_list)
    
            def create_int_feature(values):
                f = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))
                return f
    
            def flatten(tensor):
                return sum(tensor, [])
    
            for f in feature_list:
                if num_examples%5000 == 0:
                    tf.logging.info("Writing example %d of %d" % (num_examples, len(examples)))
                features = collections.OrderedDict()
                # f.input_ids,f.input_mask,f.segment_ids,f.tag_ids为向量,即形如[1,2,3,4...],
                # 其shape为(max_seq_length,)
                features["input_ids"] = create_int_feature(f.input_ids) 
                features["input_mask"] = create_int_feature(f.input_mask) 
                features["segment_ids"] = create_int_feature(f.segment_ids) 
                # f.char_ids为矩阵,形如[[1,2,3],[4,5,6],[7,8,9]],
                # 其shape为(max_seq_length, max_char_length)
                # 因此要先将其flatten为向量,shape为(max_seq_length*max_char_length,),再转化为feature
                features["char_ids"] = create_int_feature(flatten(f.char_ids)) 
                features["tag_ids"] = create_int_feature(f.tag_ids) # 为向量
                # 最后放进字典里,传入tf.train.Example
                tf_example = tf.train.Example(features=tf.train.Features(feature=features))
                writer.write(tf_example.SerializeToString())
        writer.close()
        return num_examples
    
    
    def file_based_input_fn_builder(input_file, seq_length, char_length, is_training, drop_remainder):
    	# 与上述相反的解码过程
        name_to_features = {
            "input_ids": tf.FixedLenFeature([seq_length], tf.int64),
            "input_mask": tf.FixedLenFeature([seq_length], tf.int64),
            "segment_ids": tf.FixedLenFeature([seq_length], tf.int64),
            "char_ids": tf.FixedLenFeature([seq_length * char_length], tf.int64),
            "tag_ids": tf.FixedLenFeature([seq_length], tf.int64),
        }
    
        def _decode_record(record, name_to_features):
            example = tf.parse_single_example(record, name_to_features)
            for name in list(example.keys()):
                t = example[name]
                # 将int64转为int32,因为上面只有tf.train.Int64List而没有int32
                if t.dtype == tf.int64:
                    t = tf.to_int32(t)
                example[name] = t
            # char_ids将其reshape回来即可
            example["char_ids"] = tf.reshape(example["char_ids"],
                                             shape=(seq_length, char_length))
            return example
    
        def input_fn(params):
            batch_size = params["batch_size"]
            d = tf.data.TFRecordDataset(input_file)
            if is_training:
                d = d.repeat()
                d = d.shuffle(buffer_size=100)
            d = d.apply(tf.contrib.data.map_and_batch(
                lambda record: _decode_record(record, name_to_features),
                batch_size=batch_size,
                drop_remainder=drop_remainder
            ))
            return d
    
        return input_fn
    

    第二个函数返回的是一个函数的闭包,主要用于estimator模式下的数据输入。这是本人基于BERT做NER改进的charCNN-BERT-CRF模型,有兴趣的可以去我GitHub看看哈。

    写这篇博客的初衷

    为啥要写这篇博客呢?因为我在解决这个问题时走了一个弯路,就是使用了FeatureList。即将每个单词的字母切分作为Feature,然后添加为FeatureList的元素。然而FeatureList的解码相对比较复杂难写,尽管程序没有报错,但是在运行时,却显示读出的样本数为0,即无法读出样本,一个样本都没有进入网络。当然有了前面提到的方法,这个FeatureList的作用到底大不大呢,应用广不广呢,Feature和它相比有什么做不到的地方吗(我好像看到目标识别好像有用到这个作为data pipeline)?这几天如果有时间我再根据这篇博客介绍的方法试试,到时再更新啦!也欢迎各位大佬对我进行指正!
    今晚对Featurelist的方法实现了一下,发现也是可以实现同样的功能,代码如下:

    def filed_based_convert_examples_to_features(
            examples, tokenizer, output_file):
        """
        :param examples:
        :param tokenizer:
        :param output_file:
        :param mode:
        :return: number of small example
        """
        num_examples = 0
        writer = tf.python_io.TFRecordWriter(output_file)
        # 遍历训练数据
        for (ex_index, example) in enumerate(examples):
            # 对于每一个训练样本,
            example_list = convert_single_example(example, tokenizer)
            num_examples += len(example_list)
    
            def create_int_feature(values):
                f = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))
                return f
    		# 新增一个转化featurelist的方法
            def create_feature_list(values_list):
                fl = tf.train.FeatureList(
                    feature=[tf.train.Feature(int64_list=tf.train.Int64List(value=values)) for values in values_list])
                return fl
    
            def flatten(tensor):
                return sum(tensor, [])
    
            for f in example_list:
                if num_examples%5000 == 0:
                    tf.logging.info("Writing example %d of %d" % (num_examples, len(examples)))
                features = collections.OrderedDict()
                # 给featurelists也申请一个字典
                features_list = collections.OrderedDict()
                features["input_ids"] = create_int_feature(f.input_ids)
                features["input_mask"] = create_int_feature(f.input_mask)
                features["segment_ids"] = create_int_feature(f.segment_ids)
                features["tag_ids"] = create_int_feature(f.tag_ids)
                # 这里转化为featurelist,但是感觉这样的写法,其实也没有方便多少啦!
                # 个人感觉featurelist的用法应该不是单纯这样用的,不然就这样最多也只是能转个二维,有啥意思呢?
                # 欢迎各位指正啦
                features_list["char_ids"] = create_feature_list(f.char_ids)
                # 这里要用SequenceExample啦!同理分别将features和featurelists装进context和feature_lists
                tf_example = tf.train.SequenceExample(context=tf.train.Features(feature=features),
                                                      feature_lists=tf.train.FeatureLists(feature_list=features_list))
                writer.write(tf_example.SerializeToString())
        writer.close()
        return num_examples
    
    
    def file_based_input_fn_builder(input_file, seq_length, char_length, is_training, drop_remainder):
        name_to_features = {
            "input_ids": tf.FixedLenFeature([seq_length], tf.int64),
            "input_mask": tf.FixedLenFeature([seq_length], tf.int64),
            "segment_ids": tf.FixedLenFeature([seq_length], tf.int64),
            "tag_ids": tf.FixedLenFeature([seq_length], tf.int64),
        }
        # featurelist的解码
        name_to_features_list = {
            "char_ids": tf.FixedLenSequenceFeature([char_length], tf.int64),
        }
    
        def _decode_record(record, name_to_features, name_to_features_list):
        	# 这里有两个返回值,一个返回feature即context的内容,另一份是featurelist即sequence的内容
            context_example, sequence_example = tf.parse_single_sequence_example(record,
                                                       context_features=name_to_features,
                                                       sequence_features=name_to_features_list)
            for name in list(context_example.keys()):
                t = context_example[name]
                if t.dtype == tf.int64:
                    t = tf.to_int32(t)
                context_example[name] = t
    
            for name in list(sequence_example.keys()):
                tl = sequence_example[name]
                if tl.dtype == tf.int64:
                    tl = tf.to_int32(tl)
                sequence_example[name] = tl
    
            return context_example, sequence_example
    
        def input_fn(params):
            batch_size = params["batch_size"]
            d = tf.data.TFRecordDataset(input_file)
            if is_training:
                d = d.repeat()
                d = d.shuffle(buffer_size=100)
            d = d.apply(tf.contrib.data.map_and_batch(
                lambda record: _decode_record(record, name_to_features, name_to_features_list),
                batch_size=batch_size,
                drop_remainder=drop_remainder
            ))
            return d
    
        return input_fn
    
    def main(_):
        tf.logging.set_verbosity(tf.logging.INFO)
        train_data_dir = ['training-PHI-Gold-Set2']
        wordpiece_vocab = tokenization_ner.build_wordpiece_vocab(root_path, bert_path, 'vocab.txt')
        wptokenizer = tokenization_ner.WPTokenizer(wordpiece_vocab, FLAGS.max_seq_length, FLAGS.max_char_length)
        train_file = os.path.join(FLAGS.output_dir, "train.tf_record")
        if not os.path.exists(os.path.join(FLAGS.output_dir, "train.tf_record")):
            train_examples = load_examples(train_data_dir)
            num_train_examples = filed_based_convert_examples_to_features(train_examples, wptokenizer, train_file)
        train_input_fn = file_based_input_fn_builder(
            input_file=train_file,
            seq_length=FLAGS.max_seq_length,
            char_length=FLAGS.max_char_length,
            is_training=True,
            drop_remainder=True)
    
        params = {}
        params["batch_size"] = FLAGS.train_batch_size
        dataset = train_input_fn(params)
    
        iterator = dataset.make_one_shot_iterator()
    
        with tf.Session() as sess:
            for _ in range(1):
                try:
                    context, sequence = sess.run(iterator.get_next())
                    print(sequence['char_ids'])
                except tf.errors.OutOfRangeError:
                    break
    

    最后也正确输出啦。。。

    展开全文
  • 【以下资源来自MSDN】 Array.Rank 属性 获取 Array 的(维数)。 Array.GetUpperBound 方法 获取 Array 的指定维度的上限。 Array.Length 属性 获得一个 32 位整数,该整数表示 Array 的所有维数中元素的总数。 ...

    【以下资源来自MSDN】

    Array.Rank 属性

        获取 Array 的秩(维数)。

    Array.GetUpperBound 方法

        获取 Array 的指定维度的上限。

    Array.Length 属性

        获得一个 32 位整数,该整数表示 Array 的所有维数中元素的总数。

    Array.CreateInstance 方法

        初始化 Array 类的新实例

    e.g.
            Dim a(20, 30, 40) As Int32
            MessageBox.Show(a.Rank) '3
            MessageBox.Show(a.GetUpperBound(1)) '20
            MessageBox.Show(a.Length) '26691

            Dim arr As Array = Array.CreateInstance(GetType(Int32), 2, 3, 4, 5, 6)
            arr.SetValue(2004, 1, 2, 3, 4, 5)
            MessageBox.Show(arr.GetValue(1, 2, 3, 4, 5)) '2004

    【注意】
    与大多数类不同,Array 提供CreateInstance方法,以便允许晚期绑定访问,而不是提供公共构造函数。
            Dim arrOk As Array
            arrOk = Array.CreateInstance(GetType(String), 4, 5)
            MessageBox.Show(arrOk.Rank)  '2

            '以下是错误的
            Dim arrErr As Array
            arrErr.SetValue(0, 0)                        '错误提示:未将对象引用设置到对象的实例
            MessageBox.Show(arrErr.Rank)      '错误提示:未将对象引用设置到对象的实例

            Dim arrErr2 As New Array               '错误提示:“New”不能在声明为“MustInherit”的类上使用

    Array的GetHashCode方法:
    Object.GetHashCode 方法
    用作特定类型的哈希函数,适合在哈希算法和数据结构(如哈希表)中使用。
    (明天研究哈希了再说)

     

    展开全文
  • 降维具体到技术就是奇异值分解SVD,SVD怎么去实现数据降维,怎么把这些维度在尽量少的损失原始信息的情况下达到比较好的效果,这是SVD的要做的核心。 为什么要降维 损失掉很小的一部分信息,将他们降到一个低维度...

    降维具体到技术就是奇异值分解SVD,SVD怎么去实现数据降维,怎么把这些维度在尽量少的损失原始信息的情况下达到比较好的效果,这是SVD的要做的核心。

    为什么要降维

    损失掉很小的一部分信息,将他们降到一个低维度的子空间,这损失掉的一部分信息中也有可能是些噪声信息。

    矩阵的秩

    矩阵的行秩和列秩是相等的。

    会有一些损失,因为那些垂直于这个空间的坐标被我们给剔除了。

    SVD

    SVD试图去找到一个正交的基底,很好的把我们的维度给降下来,所以他体现的效果会更好。他的实现很复杂,我们的重点是理解它。

    A[m*n]的理解例如:m(每行)代表一篇文章,n(每列)代表整个词汇表中词是不是在我们的文章里出现。

    奇异值分解

    可以理解成一个列向量乘以一个奇异值再乘以一个行向量 + 第二个列向量乘以第二个奇异值再乘以第二个行向量

    SVD的性质

    正交基:单位向量互相垂直且向量长度为一。

    U和V是不唯一的,他们的行和列可能会交换顺序,对角阵上的奇异值怎么换顺序,你相应的U的列就怎么换顺序和相应的V转置的行就怎么换顺序。

    示例

    U是“用户-主题”相似矩阵,行是用户,列是主题,每一列的得分是他在这个主题上的得分。

    科幻-主题的“强度”,U矩阵的每一列都是单位正交基 也就是说每一列的元素平方和是1,V矩阵每一行也都是单位正交基 每一行的元素平方和也是1,所以U和V矩阵相乘,他的长度不会大于1,需要奇异值对他进行放大和缩小进行规约才能体现出最终计算后得到的矩阵。

    V是“电影-主题”相似矩阵,V矩阵每一行对应一个主题,每一列对应一个电影

    我们选前面两个电影(黑客帝国,异形),把它画成图。横坐标可以理解成黑客帝国,纵坐标可以理解成异形。从坐标图中的可以看出,它搜索黑客帝国的次数越多,搜索异形的次数也越多。如果我们用一条直线强硬的表示他的数据分布的话,假设我就把V1这个向量命名成科幻向量,那么你在科幻这个向量上的得分高,你在黑客帝国和异形上的得分就高。直线周围的距离点,我们可以理解成误差。在这个层面上,我们可以把原来两个坐标归一到一个方向上去,这个方向V1其实就是第一个右奇异向量的那个方向。

    V1坐标轴的方差(“扩散”)其实就是奇异值矩阵对角阵的奇异值的大小。

    SVD怎么降维?

    强制将最小的奇异值设为零,矩阵分解就是约等号。

    A-B是指:约等号左边的矩阵 - 约等号右边的矩阵。

    SVD和PCA本质上是一样,但能用PCA的地方一定能用SVD,能用SVD的地方不一定能用PCA!!

    SVD:最好的低秩近似

    用去掉之后的奇异值矩阵的奇异值平方和 除以 去掉之前的奇异值矩阵的奇异值平方和,在80%-90%范围内就行!!

    SVD:计算复杂度

    实例:

    V1是科幻主题的向量,V2是言情主题的向量,我们想求出的是5维的坐标在2维坐标系上的投影,这个投影就是他的坐标。方法就是做一个内积。

    怎么求呢?其实就是用q这个人的搜索记录 乘以 电影-主题近似转换矩阵V。

    这里的运算结果其实就是下图中把V矩阵移到等号左边运算后的结果。即用户在主题上的得分,把一个5维的降维到2维的情况。

    从上面运算中V得出来的结果m*r,就像是主成分分析(PCA)得到的那个矩阵。SVD与PCA的关系:SVD的右奇异矩阵V就是PCA主成分分析所得到的主成分转换矩阵。

    怎么证明呢?主成分分析,我们要算一个A的主成分矩阵实际上是算A*A的转置,然后求出他的特征根和对应的特征向量矩阵,而这个特征向量矩阵其实就是我们SVD的右奇异向量矩阵(V)

    我们要观察两个用户是否相似,在原始的维度上不好观察,但我们通过将他们降维到主题维度就好观察了。在主题空间中求向量的夹角。如果他们相近的话,那么我们就可以把d看过而q用户没看过的电影推荐推q用户。在原始的坐标系下面q和d他们是完全正交的,看不出他们任何的关系,而降维到主题维度下他们的夹角是相近的,找到了他们的相关性,即对他们进行了聚类,聚在一起他们比较近。

    这就是我们做推荐所用到的一种算法,我们是通过降维来实现的,降维把不是那么重要的特征给剔除出去,然后又保留他的核心主题,找到原本看似不那么相关,实际上在主题层面上有相关的这种相关性,基于这种相关性给用户做推荐。

    这个案例不是因为数据量过大才对他降维,而是因为原始的相关性看不出来,把他降维到主题层面却能够看出相关性,这是更高级的用法。

    疑问?如果没有打分数据怎么办,那就想办法找数据,豆瓣的影评,微博评论中提到某部电影的次数等等,给搜集下来(爬虫)。

    SVD降维的特点

    CUR分解简介

    CUR类似于SVD,SVD的缺点是算的过程比较累,虽然有各自函数去优化,但还是比较慢,然后有人就想用近似的办法去表示。

    思想是:从A中抽出来一些列作为一个新的矩阵C,然后从A中也抽出来一些行作为一个新的矩阵R,而U矩阵我们可以认为是C与R相交的元素位置所对应的那些值(图中画的圆圈)求违逆得到的,保持他们原来的顺序不变。在国内工业界用的不是很多,他的特点是算的特别快。

    SVD vs CUR

    SVD和LFM(在隐语义模型)在推荐系统中那个更常用?其实都很常用,在实际应用时两个都试一下,那个好就用哪个。

    展开全文
  • 一维数据—列表集合类型 2.列表与数组 相同点:都是一组数据的有序结构 区别:列表的数据类型可不同;而数组的数据类型相同。 3.二维数据----列表 由多个一维数据构成,是一维数据的组合形式。 4.多维数据----...
  • 深度学习中的数据维度表示

    千次阅读 2018-03-09 11:17:54
    张量轴的个数又称为它的。>>>import numpy as np >>>x = np.array(12) >>>x array(12) >>>x.ndim 02.矢量(1D 张量) ...
  • 数据降维--低恢复

    2015-06-19 18:28:00
    在实际的信号或图像采集与处理中,数据维度越高, 给数据的采集处理带来越大的限制。例如,在采集三维或四维(三个空间维度再加上一个频谱维度或一个时间维度) 信号时,往往比较困难。然而,随着数据维数的升高,...
  • numpy数组的创建数组的计算用numpy生成数组,得到ndarray类型np.array(range( )) = np.arange( )reshape()并不会对数据本身进行修改np.round(x,n) 对数据x取2位小数a.flatten( )把数据展开降至一维数组其实就可以...
  • NumPy中的维度(dimension)、轴(axis)、(rank)的含义

    千次阅读 多人点赞 2019-06-24 16:43:00
    转载自https://blog.csdn.net/Babyfatliang/article/details/87721282 NumPy的时候,其中最重要的就是学习它的 ndarray 对象,它是多维度的同数据类型的数组。这个Python自带的列表有较大的...
  • 维度归约

    2018-11-01 20:42:20
    复杂度依赖于输入的维度d和数据样本的规模N,为了减少存储量计算时间。 较简单的模型在小数据集上更为鲁棒,较简单的模型具有较小的方差。 当数据能够用较少特征解释时,就能够更好地理解解释数据的过程,使得...
  • 矩阵恢复与非负矩阵分解
  • NumPy的时候,其中最重要的就是学习它的 ndarray 对象,它是多维度的同数据类型的数组。这个Python自带的列表有较大的区别,列表中的元素类型是可以不相同的,如一个列表中,它可以包含数字、字符、字符串等,而在...
  • 使得集合Y的元素集合X的元素相...非常需要注意的是:一定要记住:映射的概念是非常广泛的一个概念,任何两种有关系的事物都可以用映射的概念进行描述,比如张三映射到高三一班,高纬度向量映射到低维度空间。 映射
  • 秩和比法,是我国统计学家田凤调教授于1988年提出的一种综合评价方法,是利用秩和比(RSR, Rank-sum ratio)进行统计分析的一种方法。它不仅适用于四格表资料的综合评价,也适用于n行m列资料的综合评价,同时也适用于...
  • 2016-12-01 16:29:40
    昨天看到一个面试题,让介绍什么是,其实这个可能对学好了线性代数的人来说是很basic的问题吧,可是无奈数学里我最最讨厌的就是线性代数了,当初大一的时候压根没学明白。  言归正传,单独给开一篇博客,是...
  • shape 数组的维度, 例如一个2排3列的矩阵,它的shape属性将是(2,3),这个元组的长度显然是,即维度或者ndim属性 size 数组元素的总个数,等于shape属性中元组元素的乘积。 dtype一个用来描述数组中元素类型的对象,...
  • 向量空间、维度和四大子空间空间的概念欧几里得空间向量空间广义向量空间子空间欧几里得空间的子空间维度概念子空间和维度行空间和矩阵的行空间行列空间与列行空间和列空间对比 空间的概念 空间是一个集合。 ...
  • 例如将图5所示的评分矩阵分解为两个低维度的矩阵,用QP两个矩阵的乘积去估计实际的评分矩阵,而且我们希望估计的评分矩阵实际的评分矩阵不要相差太多,也就是求解下面的目标函数:  这里涉及到最优化理论,在...
  • 3-matlab求秩和比代码

    千次阅读 2018-08-17 09:15:00
    %x1,...,x6的数据和权重数据 % aw = xlsread('E:\a-建模\第六轮\结果\附件2.汽泵前置泵部分监测数据.xls', 2,'J3:P3603'); aw = xlsread('E:\a-建模\第六轮\结果\附件3.汽轮机本体部分监测数据.xlsx', 2,'A17:X5938'...
  • 此文为《python数据分析和数据挖掘》的读书笔记通俗讲,经过我们前期的数据分析,得到了数据的缺陷,那么我们现在要做的就是去对数据进行预处理,可包括四个部分:数据清洗、数据集成、数据变换、数据规约。...
  • 此外,考虑到气体羽流在空间时间维度上都是连续的,我们将总变化正则化包括在约束最小化问题中,我们使用增强的拉格朗日乘数法对其进行求解。 将上述过程应用于每个提取的特征后,提出了一种新颖的融合策略,将...
  • 向量空间、维度和四大子空间零空间的基和-零化度定理零空间及零空间的基-零化度定理列空间与零空间对比零空间与矩阵的逆深入理解零空间左零空间回顾已有的三个子空间第四个子空间研究子空间的意义 零空间的基和...

空空如也

空空如也

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

数据的秩和维度