Tensorflow-FeutureColumns

文章转载自https://www.jianshu.com/p/fceb64c790f3

特征列FeatureColumns

特征列是指一组数据的相关特征，包含了数据的相关类型和长度等信息。
在前面的鸢尾花案例中，我们使用了下面的代码拼合特征列,你可以在iris项目中添加新的测试文件test.py并运行它观看输出效果：

import os
import pandas as pd
import tensorflow as tfFUTURES = ['SepalLength', 'SepalWidth','PetalLength', 'PetalWidth', 'Species']
SPECIES = ['Setosa', 'Versicolor', 'Virginica']#格式化数据文件的目录地址
dir_path = os.path.dirname(os.path.realpath(__file__))
train_path=os.path.join(dir_path,'iris_training.csv')
test_path=os.path.join(dir_path,'iris_test.csv')#载入训练数据
train = pd.read_csv(train_path, names=FUTURES, header=0)
train_x, train_y = train, train.pop('Species')#载入测试数据
test = pd.read_csv(test_path, names=FUTURES, header=0)
test_x, test_y = test, test.pop('Species')#拼合特征列
feature_columns = []
for key in train_x.keys():feature_columns.append(tf.feature_column.numeric_column(key=key))print(feature_columns);

以上代码输出如下内容（整理后）

[_NumericColumn(key='SepalLength', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None),_NumericColumn(key='SepalWidth', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), _NumericColumn(key='PetalLength', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), _NumericColumn(key='PetalWidth', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None)
]

feature_columns = []，它是一个列表，被添加append了多个包含了多个feature_column.numeric_column()方法生成的特征列，每个特征列包含五个字段：

关键字key，用来标识每一列的名称，避免混淆。
形状shape, 数据的形状，见下面。
默认值default_value。
数据类型dtype，默认是浮点小数tf.float32。
标准化函数normalizer_fn，可以对每个每行数据进行处理。

形状shape

关于shape，比如shape=3表示[r,g,b]类型的三元列表，类似[0,100,255]。shape=[4,3]表示下图的4行3列的矩阵，类似[[1,0,0] [0,1,0] [0,0,1] [0,0,0]]。

4x3矩阵：4行3列

在python中还有一类和方括号[]列表类似的数据格式：小括号元组()。元组基本上就是每个元素都不重复的列表。
但是这里就有一个问题，mylist=(3)这句话到底是生成(3)这样的元组呢，还是生成一个类似(x,y,z)有三个元素的元组呢？答案是后者！
如果需要生成只包含3这个数字的元组，你需要在3后面强加一个逗号：
mylist=(3,)

转化过程

我们把这段for循环改一下，把train_x，train_x.keys()和key以及转化完毕的特征列column打印出来，仔细看看数据的变化过程：

feature_columns = []
print(train_x);
print(train_x.keys());
for key in train_x.keys():print(key);print(tf.feature_column.numeric_column(key=key));feature_columns.append(tf.feature_column.numeric_column(key=key))

它们的情况：

iris_training.csv是我们的原始数据，如下，具体情况之前文章详细解说过：

120,4,setosa,versicolor,virginica
6.4,2.8,5.6,2.2,2
5.0,2.3,3.3,1.0,1
4.9,2.5,4.5,1.7,2
4.9,3.1,1.5,0.1,0
...

train_x是pandas模块读取的csv数据，使用pd.read_csv()方法，得到的是120行乘以4列的数据表[120 rows x 4 columns]

     SepalLength  SepalWidth  PetalLength  PetalWidth
0            6.4         2.8          5.6         2.2
1            5.0         2.3          3.3         1.0
2            4.9         2.5          4.5         1.7
...
[120 rows x 4 columns]

train_x.keys()包含了四个关键字和一个数据类型对象dtype

Index(['SepalLength', 'SepalWidth', 'PetalLength', 'PetalWidth'], dtype='object')

key是关键字名称，numeric_column(key=key)得到的单个特征列和上面展示的一样

SepalLength
_NumericColumn(key='SepalLength', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None)

数据流程

在之前的鸢尾花案例中，我们从csv读取数据，组织成为特征列feature_columns并编写了喂食数据的函数input_fn，然后利用特征列创建了qiu zh器中的深度神经网络分类器estimator.DNNClassifier，然后利用喂食函数input_fn把读取的数据喂食到DNNClassifier中进行训练、评估和预测。

数值列numeric_column

我们在上面使用的就是数值列numeric_column，它的默认格式如下

numeric_column(key,shape=(1,),default_value=None,dtype=tf.float32,normalizer_fn=None
)

你可以用下面的代码测试：

import tensorflow as tfprice = {'price': [[1.], [2.], [3.], [4.]]}  # 4行样本column = tf.feature_column.numeric_column('price', normalizer_fn=lambda x:x+2)
tensor = tf.feature_column.input_layer(price,[column])with tf.Session() as session:print(session.run([tensor]))

将会输出以下内容，每个数值都被+2处理了:

[array([[3.],[4.],[5.],[6.]], dtype=float32)]

分箱列Bucketized column

分箱是指把一个连续的数字范围分成几段，比如我们经常说的【80后，90后，00后，10后】这些就是把一个连续的年份（1980～现在2018）分成了4段，我们把这些年份分别写在39张卡片上，然后准备四个箱子，分别标上【0号箱80后】【1号箱90后】【2号箱00后】【3号箱10后】，卡片1980～1989放入【0号箱】，卡片1990～1999放入【1号箱】...

为什么这样做？

在我们分箱之前，我们的用excel填写100个人的出生年代，那么会是

如果我们要用这些数据分析90后的身高分布情况，那么这样的数据看起来就比较麻烦。而分箱后的数据就好多了，我们用0表示80后，1表示90后，2表示00后，3表示10后：

  years
0  0  #1988
1  1  #1999
2  3  #2013
3  2  #2004
...

我们继续更进一步，比起简单的数字，Tensorflow更喜欢列表类型，更善于从列表或矩阵中估算出变化规律。
共有4段年代，我们表示为包含4个元素的列表[y0,y1,y2,y3],80后第一个元素中招，标记为[1,0,0,0]；90后第二个元素中招，[0,1,0,0],以此类推，我们得到

0  [1,0,0,0]  #1988
1  [0,1,0,0]  #1999
2  [0,0,0,1]  #2013
3  [0,0,1,0]  #2004

在这个例子中，我们把1980～now年份用3个边界(1990，2000，2010)划为4段（假设我们的数据不存在早于1980出生的人），我们可以使用下面的代码进行测试:

import tensorflow as tfyears = {'years': [1999,2013,1987,2005]}  years_fc = tf.feature_column.numeric_column('years')
column = tf.feature_column.bucketized_column(years_fc, [1990, 2000, 2010])tensor = tf.feature_column.input_layer(years, [column])with tf.Session() as session:print(session.run([tensor]))

运行得到下面的输出，可以看到每一个年份的列表对应的元素变成了1，而其他元素为0:

[array([[0., 1., 0., 0.],  #1999[0., 0., 0., 1.],  #2013[1., 0., 0., 0.],  #1987[0., 0., 1., 0.]],  #2005dtype=float32)]

Bucketized也被称作分桶，在这里参考谷歌官方说法统一称为分箱。

关于独热编码one-hot

顾名思义，在上面的列表中[0,1,0,0]中只有第二个元素为1，热起来了，其他元素都是0。所以叫独热。

可以这样说，如果某个特征有M种可能，而我们有三个数据[m1,m2,m3]，可以把它变成一个由0和1组成3xM的二维矩阵,类似下图：

分箱特征栏Bucketized column就是把一维的普通列表变成了二维矩阵，升维了！

为什么会这样做？不是把数据复杂化了吗？
其实是把数据简化了，独热之后我们只剩下0或1，1只是代表一个位置，并不关注这一行具体代表什么含义。

首先，升维往往能让数据直接的关系更加清楚，更易于找到规律。其次，也是更重要的，分箱之后可以让无序数据之间关系更加正确。

比如我们有三种商品分类，['服装','食品','化妆品']，如果我们只是把它转化为[0,1,2]，那么我们如果在几何空间中计算它们之间的距离关系，三个类别代表线段上的三个点，我们会得到服装距离食品是1-0=1，食品距离化妆品是2-1=1，而服装距离化妆品是2-0=2；计算机就会误以为化妆品和服装关系很远。但实际上这毫无依据，这种错误关系完全是由于我们的数据格式引发的。

直线上两点间距离公式

再看分箱后的结果，三种类别变为服装[1,0,0],食品[0,1,0],化妆品[0,0,1],它们代表三维空间中的三个点，利用距离平方等于每个维度平方之和，我们得到它们三者之间的距离都是根号2，完全相等，没有任何偏倚。

空间中两点间距离公式

分类识别列Categorical identity column

很多数据都不是数字格式的，比如动物的类别“猫狗牛羊”、商品的类别“食品服装数码”、人的姓氏“张王李赵”...这些都是文字格式的。

但是，Tensorflow只能处理数字。

我们必须把字符名称变为数字模式，或者说我们必须用数字来表示文字。
参照上面的分箱的方法，我们可以创建很多箱子表示各种动物，把每个种类动物名称写在卡片上，放到对应的箱子里。

假设我们有4种宠物分类：猫，狗，兔子，猪，对应列表[a1,a2,a3,a4]那么就有:

宠物类别的独热编码

语法格式

categorical_column_with_identity(key,num_buckets,default_value=None
)

测试代码

import tensorflow as tfpets = {'pets': [2,3,0,1]}  #猫0，狗1，兔子2，猪3column = tf.feature_column.categorical_column_with_identity(key='pets',num_buckets=4)indicator = tf.feature_column.indicator_column(column)
tensor = tf.feature_column.input_layer(pets, [indicator])with tf.Session() as session:print(session.run([tensor]))

运行输出结果

[array([[0., 0., 1., 0.], #兔子[0., 0., 0., 1.], #猪[1., 0., 0., 0.], #猫[0., 1., 0., 0.]], dtype=float32)] #狗

分类词汇列Categorical vocabulary column

在上面的示例图中我们看到，必须手工在excel里面把cat、dog、rabbit、pig转为0123才行，能不能更快一些？
tf.feature_column.categorical_column_with_vocabulary_list这个方法就是将一个单词列表生成为分类词汇特征列的。

语法格式

categorical_column_with_vocabulary_list(key,vocabulary_list,dtype=None,default_value=-1,num_oov_buckets=0
)

num_ovv_buckets，Out-Of-Vocabulary，如果数据里面的某个单词没有对应的箱子，比如出现了老鼠mouse，那么就会在【箱子总数4～num_ovv_buckets+ 箱子总数=7】，如果num_ovv=3,那么老鼠mouse会被标记为4～7中的某个数字，可能是5，也可能是4或6。num_ovv不可以是负数。

测试代码

import tensorflow as tfpets = {'pets': ['rabbit','pig','dog','mouse','cat']}  column = tf.feature_column.categorical_column_with_vocabulary_list(key='pets',vocabulary_list=['cat','dog','rabbit','pig'], dtype=tf.string, default_value=-1,num_oov_buckets=3)indicator = tf.feature_column.indicator_column(column)
tensor = tf.feature_column.input_layer(pets, [indicator])with tf.Session() as session:session.run(tf.global_variables_initializer())session.run(tf.tables_initializer())print(session.run([tensor]))

输出结果如下，注意到独热list 有7个元素，这是由于【猫狗兔子猪4个+num_oov_buckets】得到的。

[array([[0., 0., 1., 0., 0., 0., 0.], #'rabbit'[0., 0., 0., 1., 0., 0., 0.], #'pig'[0., 1., 0., 0., 0., 0., 0.], #'dog'[0., 0., 0., 0., 0., 1., 0.], #mouse[1., 0., 0., 0., 0., 0., 0.]], dtype=float32)] #'cat'

单词有些时候会比较多，这时候我们可以直接从文件中读取文字列表：

import os
import tensorflow as tfpets = {'pets': ['rabbit','pig','dog','mouse','cat']}  dir_path = os.path.dirname(os.path.realpath(__file__))
fc_path=os.path.join(dir_path,'pets_fc.txt')column=tf.feature_column.categorical_column_with_vocabulary_file(key="pets",vocabulary_file=fc_path,num_oov_buckets=0)indicator = tf.feature_column.indicator_column(column)
tensor = tf.feature_column.input_layer(pets, [indicator])with tf.Session() as session:session.run(tf.global_variables_initializer())session.run(tf.tables_initializer())print(session.run([tensor]))

其中pets_fc.txt每行一个单词如：

cat
dog
rabbit
pig

管理员权限运行，得到以下结果，这次我们oov使用了0，并没有增加元素数量，但是也导致了mouse变成了全部是0的列表

[array([[0., 0., 1., 0.], #rabbit[0., 0., 0., 1.], #pig[0., 1., 0., 0.], #dog[0., 0., 0., 0.],#mosue[1., 0., 0., 0.]], dtype=float32)] #cat

哈希栏Hashed Column

仍然是分箱，但是这一次我们更加关心“我希望有多少分类？”，也许我们有150个单词，但我们只希望分成100个分类，多下来50个的怎么处理？

取余数！101除以100余1，我们就把第101种单词也标记为1，和我们的第1种单词变成了同一类，如此类推，第102种和2种同属第2类,第103种和3种同属第3类...

我们把计算余数的操作写为%；那么第N个单词属于N%100类。

feature_id = hash(raw_feature) % hash_buckets_size

哈希列HashedColumn对于大数量的类别很有效（vocabulary的file模式也不错），尤其是语言文章处理，将文章分句切词之后，往往得到大数量的单词，每个单词作为一个类别，对于机器学习来说，更容易找到潜在的单词之间的语法关系。

但哈希也会带来一些问题。如下图所示，我们把厨房用具kitchenware和运动商品sports都标记成了分类12。这看起来是错误的，不过很多时候tensorflow还是能够利用其他的特征列把它们区分开。所以，为了有效减少内存和计算时间，可以这么做。

语法格式

categorical_column_with_hash_bucket(key,hash_bucket_size,dtype=tf.string
)

测试代码

import tensorflow as tfcolors = {'colors': ['green','red','blue','yellow','pink','blue','red','indigo']}  column = tf.feature_column.categorical_column_with_hash_bucket(key='colors',hash_bucket_size=5,)indicator = tf.feature_column.indicator_column(column)
tensor = tf.feature_column.input_layer(colors, [indicator])with tf.Session() as session:session.run(tf.global_variables_initializer())session.run(tf.tables_initializer())print(session.run([tensor]))

运行得到如下的输出,我们注意到red和blue转化后都是一样的，yellow，indigo，pink也都一样，这很糟糕。

[array([[0., 0., 0., 0., 1.],#green[1., 0., 0., 0., 0.],#red[1., 0., 0., 0., 0.],#blue[0., 1., 0., 0., 0.],#yellow[0., 1., 0., 0., 0.],#pink[1., 0., 0., 0., 0.],#blue[1., 0., 0., 0., 0.],#red[0., 1., 0., 0., 0.]], dtype=float32)]#indigo

将hash_bucket_size箱子数量设置为10，这个问题可以得到解决。箱子数量的旋转很重要，越大获得的分类结果越精确。

交叉列Crossed column

交叉列可以把多个特征合并成为一个特征，比如把经度longitude、维度latitude两个特征合并为地理位置特征location。
如下图，我们把Atlanda城市范围的地图横向分成100区间，竖向分成100区间，总共分割成为10000块小区域。（也许接下来我们需要从数据分析出哪里是富人区哪里是穷人区）

测试代码如下：

import tensorflow as tffeatrues = {'longtitude': [19,61,30,9,45],'latitude': [45,40,72,81,24]}longtitude = tf.feature_column.numeric_column('longtitude')
latitude = tf.feature_column.numeric_column('latitude')longtitude_b_c = tf.feature_column.bucketized_column(longtitude, [33,66])
latitude_b_c  = tf.feature_column.bucketized_column(latitude,[33,66])column = tf.feature_column.crossed_column([longtitude_b_c, latitude_b_c], 12)indicator = tf.feature_column.indicator_column(column)
tensor = tf.feature_column.input_layer(featrues, [indicator])with tf.Session() as session:session.run(tf.global_variables_initializer())session.run(tf.tables_initializer())print(session.run([tensor]))

上面的代码中进行了分箱操作，分成～33，33～66，66～三箱，运行得到下面输出

[array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],[0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],[0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],[0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],[0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.]], dtype=float32)]

指示列Indicator Columns和嵌入列Embeding Columns

我们在上面的代码中使用了很多次指示列命令

indicator = tf.feature_column.indicator_column(column)
tensor = tf.feature_column.input_layer(featrues, [indicator])

指示列并不直接操作数据，但它可以把各种分类特征列转化成为input_layer()方法接受的特征列。

当我们遇到成千上万个类别的时候，独热列表就会变的特别长[0,1,0,0,0,....0,0,0]。嵌入列可以解决这个问题，它不再限定每个元素必须是0或1，而可以是任何数字，从而使用更少的元素数表现数据。

如下图，我们最初的数据可能是4个单词比如dog、spoon、scissors、guitar，然后这些单词被分类特征列Categorical处理成为数字0、32、79、80，接下来我们可以使用指示列来处理成为独热的01列表（图中假设我们有81种单词分类），也可以按照嵌入Embeding列来处理成小数元素组成的3元素数列。

分类列Categorical、指示列Indicator和嵌入列Embeding

嵌入列中的小数只在train训练的时候自动计算生成，能够有效增加训练模型的效率和性能，同时又能便于机器学习从数据中发现潜在的新规律。

为什么嵌入Embeding的都是[0.421,0.399,0.512]这样的3元素列表，而不是4元5元？实际上有下面的参考算法：

嵌入列表的维数等于类别总数开4次方，也就是3的4次方等于81种类。

嵌入列语法

embedding_column(categorical_column,dimension,combiner='mean',initializer=None,ckpt_to_load_from=None,tensor_name_in_ckpt=None,max_norm=None,trainable=True
)

dimention维度，即每个列表元素数
combiner组合器，默认meam，在语言文字处理中选sqrtn可能更好
initializer初始器
tensor_name_in_ckpt可以从check point中恢复
ckpt_to_load_from恢复文件

示例代码

import tensorflow as tffeatures = {'pets': ['dog','cat','rabbit','pig','mouse']}  pets_f_c = tf.feature_column.categorical_column_with_vocabulary_list('pets',['cat','dog','rabbit','pig'], dtype=tf.string, default_value=-1)column = tf.feature_column.embedding_column(pets_f_c, 3)
tensor = tf.feature_column.input_layer(features, [column])with tf.Session() as session:session.run(tf.global_variables_initializer())session.run(tf.tables_initializer())print(session.run([tensor]))

运行得到输出,我们看到由于老鼠mouse没有对应的箱子，所以元素都为0

[array([[ 0.15651548, -0.620424  ,  0.41636208],[-1.0857592 ,  0.03593585,  0.20340031],[-0.6021426 , -0.48347804, -0.7165713 ],[-0.36875582,  0.4034163 , -1.0998975 ],[ 0.        ,  0.        ,  0.        ]], dtype=float32)]

特征列和估算器Estimator

在鸢尾花的案例中，我们拼接多个数值特征列numeric column成为feature_columns列表

feature_columns = []
for key in train_x.keys():feature_columns.append(tf.feature_column.numeric_column(key=key))

然后利用特征列创建了深度神经网络分类器tf.estimator.DNNClassifier：

classifier = tf.estimator.DNNClassifier(feature_columns=feature_columns,hidden_units=[10, 10],n_classes=3,model_dir=models_path,config=ckpt_config) #

有了这个DNNClassifier我们就能对原始数据进行train、evaluate、pedict。
Tensorflow提供了多个评估器，但不是每种评估器都能够接收所有类型的特征列feature column。

线性分类器 linearClassifier和线性回归器linearRegressor，接收所有类型特征列；
深度神经网络分类器DNNClassifier和深度神经网络回归器DNNRegressor，仅接收密集特征列dense column,其他类型特征列必须用指示列indicatorColumn或嵌入列embedingColumn进行包裹
线性神经网络合成分类器linearDNNCombinedClassifier和线性神经网络合成回归器linearDNNCombinedRegressor：
- linear_feature_columns参数接收所有类型特征列
- dnn_feature_columns只接收密度特征列dense column

分类列CategoricalColumn和密集列DenseColumn

上面介绍了Tensorflow用于生成特征列的9个方法（tf.feature_column...），每个方法最终都会得到分类列或者密集列：

权重分类列WeightedCategoricalColumn

默认的CategoricalColumn所有分类的权重都是一样的，没有轻重主次。而权重分类特征列则可以为每个分类设置权重。
语法格式

weighted_categorical_column(categorical_column,weight_feature_key,dtype=tf.float32
)

测试代码

import tensorflow as tf
from tensorflow.python.feature_column.feature_column import _LazyBuilderfeatures = {'color': [['R'], ['A'], ['G'], ['B'],['R']],'weight': [[1.0], [5.0], [4.0], [8.0],[3.0]]}color_f_c = tf.feature_column.categorical_column_with_vocabulary_list('color', ['R', 'G', 'B','A'], dtype=tf.string, default_value=-1
)column = tf.feature_column.weighted_categorical_column(color_f_c, 'weight')indicator = tf.feature_column.indicator_column(column)
tensor = tf.feature_column.input_layer(features, [indicator])with tf.Session() as session:session.run(tf.global_variables_initializer())session.run(tf.tables_initializer())print(session.run([tensor]))

运行之后得到下面输出，权重改变了独热模式，不仅包含0或1，还带有权重值

[array([[1., 0., 0., 0.],[0., 0., 0., 5.],[0., 4., 0., 0.],[0., 0., 8., 0.],[3., 0., 0., 0.]], dtype=float32)]

线性模型LinearModel

对所有特征进行线性加权操作（数值和权重值相乘）。
语法格式

linear_model(features,feature_columns,units=1,sparse_combiner='sum',weight_collections=None,trainable=True
)

测试代码

import tensorflow as tf
from tensorflow.python.feature_column.feature_column import _LazyBuilderdef get_linear_model_bias():with tf.variable_scope('linear_model', reuse=True):return tf.get_variable('bias_weights')def get_linear_model_column_var(column):return tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,'linear_model/' + column.name)[0]featrues = {'price': [[1.0], [5.0], [10.0]],'color': [['R'], ['G'], ['B']]}price_column = tf.feature_column.numeric_column('price')
color_column = tf.feature_column.categorical_column_with_vocabulary_list('color',['R', 'G', 'B'])
prediction = tf.feature_column.linear_model(featrues, [price_column, color_column])bias = get_linear_model_bias()
price_var = get_linear_model_column_var(price_column)
color_var = get_linear_model_column_var(color_column)with tf.Session() as sess:sess.run(tf.global_variables_initializer())sess.run(tf.local_variables_initializer())sess.run(tf.tables_initializer())sess.run(bias.assign([7.0]))sess.run(price_var.assign([[10.0]]))sess.run(color_var.assign([[2.0], [2.0], [2.0]]))predication_result = sess.run([prediction])print(prediction)print(predication_result)

运行结果得到

[array([[ 19.],[ 59.],[109.]], dtype=float32)]

Tensorflow-FeutureColumns相关推荐

tensorflow 1.x Saver(保存与加载模型) 预测
20201231 tensorflow 1.X 模型保存 https://blog.csdn.net/qq_35290785/article/details/89646248 保存模型 saver=t ...
python 虚拟环境 tensorflow GPU
拿到一个新的容器之后,怎么创建一个独立的GPU训练环境呢?之前弄的时候总是零零散散的,现在把它总结在这里,供自己以及有需要的朋友查阅. conda创建 1.1 下载anaconda wget -c h ...
API pytorch tensorflow
pytorch与tensorflow API速查表方法名称 pytroch tensorflow numpy 裁剪 torch.clamp(x, min, max) tf.clip_by_value ...
tensor转换 pytorch tensorflow
一.tensorflow的numpy与tensor互转 1.数组(numpy)转tensor 利用tf.convert_to_tensor(numpy),将numpy转成tensor >> ...
Tensorflow会话
Tensorflow中的会话是来执行定义好的运算的.会话拥有并管理Tensorflow程序运行时的所有资源.当计算完成之后需要关闭会话来帮助系统回收资源,否则可能出现资源泄露的问题. Tensorfl ...
tensorflow问题
20210121 ImportError: No module named 'tensorflow.python' https://stackoverflow.com/questions/414156 ...
tensorflow兼容处理 tensorflow.compat.v1 tf.contrib
20201130 问题提出: v1版本中tensorflow中contrib模块十分丰富,但是发展不可控,因此在v2版本中将这个模块集成到其他模块中去了.在学习tensorflow经常碰到tf.con ...
ImportError: No module named tensorflow.compat.v1 忽略已经安装的某个包版本忽略已安装版本...
ImportError: No module named tensorflow.compat.v1 版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声 ...
请注意更新TensorFlow 2.0的旧代码
TensorFlow 2.0 将包含许多 API 变更,例如,对参数进行重新排序.重新命名符号和更改参数的默认值.手动执行所有这些变更不仅枯燥乏味,而且容易出错.为简化变更过程并让您尽可能顺畅地过渡到 ...
独家 | TensorFlow 2.0将把Eager Execution变为默认执行模式，你该转向动态计算图了...
机器之心报道作者:邱陆陆 8 月中旬,谷歌大脑成员 Martin Wicke 在一封公开邮件中宣布,新版本开源框架--TensorFlow 2.0 预览版将在年底之前正式发布.今日,在上海谷歌开发者 ...

Tensorflow-FeutureColumns

Tensorflow-FeutureColumns相关推荐

最新文章

热门文章