认识Pandas

Pandas 是 Python 语言的一个扩展程序库，用于 数据挖掘和 数据分析，同时也提供 数据清洗功能。

pandas（panel data & data analysis），是基于 numpy（提供高性能的矩阵运算）专门用于数据分析的工具，是一个强大的分析结构化数据（表格数据）的工具集；

Pandas所有的操作都基于两种结构： DataFrame结构和 Series结构

Dataframe 结构

DataFrame 是 Pandas 中的一个 表格型 的数据结构，是一个二维的数组结构，类似 二维数组。包含有一组有序的列，每列可以是不同的值类型(数值、字符串、布尔型等)。

该表由三部分组成，标题(列索引)、行名(行索引)和数据元素部分。

[En]

The table consists of three parts, the header (column index), the row name (row index), and the data element section.

【数据分析】认识Pandas：DataFrame和Series结构、属性

; DataFrame 构造方法

pandas.DataFrame( data, index, columns, dtype, copy)

data：数据(array-like 类型：可以是ndarray、series, map, lists, dict 等类型)。
index：行索引，如果不指定行索引—默认给一个0、1、2、3、... 这样的序号行索引。
columns：列索引，如果不指定列索引—默认给一个0、1、2、3、... 这样的序号列索引。
dtype：数据类型。
copy：拷贝数据，默认为 False。

方式 1：使用列表 逐个传入行索引、列索引和 数据元素
df = pd.DataFrame(

    data=[
        ['zs', 19, 1],
        ['ls', 20, 1],
        ['ww', 19, 2]
    ],
    index=['stu0', 'stu1', 'stu2'],
    columns=['name', 'age', 'group']

)
print('df:\n', df)
print('df_type:\n', type(df))
"""
df:
      name  age  group
stu0   zs   19      1
stu1   ls   20      1
stu2   ww   19      2
df_type:

"""

方式 2：借助字典
df = pd.DataFrame(

    data={
        'name': ['zs', 'ls', 'ww'],
        'age': [18, 19, 29],
        'group': [1, 1, 2]
    },
    index=['stu0', 'stu1', 'stu2'],
)
print('df:\n', df)
print('df_type:\n', type(df))
"""
df:
      name  age  group
stu0   zs   18      1
stu1   ls   19      1
stu2   ww   29      2
df:

"""

方式 3：由 ndarray 转化为 dataframe结构
import numpy
values = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print('values:\n', values)
print('values_type：', type(values))
"""
values:
 [[1 2 3 4]
 [5 6 7 8]]
values_type：

"""
df = pd.DataFrame(
    data=values,
    columns=['一','二','三','四'],
)
print('df:\n', df)
print('df_type:\n', type(df))
"""
df:
   一  二  三  四
0  1  2  3  4
1  5  6  7  8
df_type:

"""

注：关于参数元素缺失

df = pd.DataFrame(
    data=[
        ['zs', 19, 1],
        ['ls', 20, 1],
        ['ww', 19]
    ],
    index=['stu0', 'stu1', 'stu2'],
    columns=['name', 'age', 'group']
)
print('df:\n', df)
"""
df:
      name  age  group
stu0   zs   19    1.0
stu1   ls   20    1.0
stu2   ww   19    NaN
"""

dtype参数

data=[
    ['zs', 19, 1],
    ['ls', 20, 1],
    ['ww', 19, 2]
],
df = pd.DataFrame(
    data=data
    columns=['name', 'age', 'group'],
)
print('dtypes:\n', df.dtypes)
'''
dtypes:
 name     object
age       int64
group     int64
dtype: object
'''

df = pd.DataFrame(
    data=data
    columns=['name', 'age', 'group'],
    dtype="int32"
)
print('dtypes:\n', df.dtypes)
'''
df:
 name     object
age       int32
group     int32
dtype: object
'''

df = pd.DataFrame(
    data=data
    columns=['name', 'age', 'group'],
    dtype=numpy.

)
print('dtypes:\n', df.dtypes)
'''
df:
 name     object
age       int32
group     int32
dtype: object
'''

Series 结构

Series 类似表格中的一个列（column），类似于 一维数组，可以保存任何数据类型。Series 由索引（index）和列组成

DataFrame结构就是由多个Series结构组成的：


df = pd.DataFrame(
    data=[
        ['zs', 19, 1],
        ['ls', 20, 1],
        ['ww', 19, 2]
    ],
    index=['stu0', 'stu1', 'stu2'],
    columns=['name', 'age', 'group'],
)
print('name:\n', df["name"])
print("*"*20)
print('name_type:\n', type(df["name"]))
'''
name:
 stu0    zs
stu1    ls
stu2    ww
Name: name, dtype: object
********************
name_type:

'''

Series 构造方法

pandas.Series( data, index, dtype, name, copy)

Serise的参数与Dataframe的参数相似：

data：一组数据(array-like 类型)。
index：数据索引标签，不指定默认从 0 开始。可指定array-like 类型需和data长度相同。
dtype：数据类型，默认会自己判断。
name：设置名称（str 类型）， 相当于Dataframe结构指定多列名称的Columns 变为单列的name。
copy：拷贝数据，默认为 False。

df= pd.Series([1, 2, 3])
print("df:\n", df)
'''
df:
0    1
1    2
2    3
dtype: int64
'''

se = pd.Series(
    data={'zs': 17, 'ls': '18', 'ww': 18},

    index=['zs', 'ls', 'ww', 'jj'],

)
print('se:\n',se)
print('se_type:\n',type(se))
'''
se:
 zs     17
ls     18
ww     18
jj    NaN
dtype: object
se_type:

'''

DataFrame和Series属性

import pandas as pd

df = pd.DataFrame(
    data=[
        ['zs', 19, 1],
        ['ls', 20, 1],
        ['ww', 19, 2]
    ],
    index=['stu0', 'stu1', 'stu2'],
    columns=['name', 'age', 'group']
)
print('df:\n', df)
print('df_type:\n', type(df))

print('ndim:', df.ndim)
print('shape:', df.shape)
print('size:', df.size)

print('dtypes:\n', df.dtypes)

print('index:', df.index)
print('columns:', df.columns)
print('values:\n', df.values)
print('values_type:\n', type(df.values))

print("-"*80)

se = df['name']
print('se:\n', se)
print('se:\n', type(se))

print('ndim:', se.ndim)
print('shape:', se.shape)
print('size:', se.size)
print('name:', se.name)

print('dtype:', se.dtype)
print('dtypes:', se.dtypes)

print('index:',se.index)
print('values:',se.values)

【数据分析】认识Pandas：DataFrame和Series结构、属性

Original: https://blog.csdn.net/weixin_45760274/article/details/123380834
Author: 胡桃の壶
Title: 【数据分析】认识Pandas：DataFrame和Series结构、属性

Title: TensorFlow实现条件批归一化（Conditional Batch Normalization）

条件批归一化（Conditional Batch Normalization）

批归一化 (Batch Normalization, BN) 是深度学习中常用的网络训练技巧，它不仅可以加快了模型的收敛速度，而且更重要的是在一定程度缓解了深层网络中"梯度弥散"的问题，从而使得训练深层网络模型更加容易和稳定，所以目前 BN 已经成为几乎所有卷积神经网络的标配技巧了，简单回顾下批 BN 的方程式：
B N ( x ) = γ ( x − μ ( x ) σ ( x ) ) + β BN(x) = \gamma (\frac {x-\mu(x)}{\sigma(x)}) + \beta B N (x )=γ(σ(x )x −μ(x ))+β
其中，均值 µ µµ 和标准差 σ σσ 是在 (N, H, W) 维度上进行计算的，每个规范化层只有一个仿射变换参数对 γ γγ 和 β ββ，它们是在训练时网络自己学习得到的。
但是在生成对抗网络 (Generative Adversarial Networks, GAN) 中使用 BN 会导致生成图片在一定程度上出现同质化的缺点。例如，在 CIFAR10 数据集中，有10类图片：6种是动物(分别为：鸟，猫，鹿，狗，青蛙和马)，4种是交通工具(分别是：飞机，汽车，轮船和卡车)。显然，不同类别的图片在外观上看起来截然不同——交通往往具有坚硬而笔直的边缘，而动物倾向于具有弯曲的边缘和较柔和的纹理。
在风格迁移中我们已经了解了，激活的统计数据决定了图像样式。因此，混合批统计信息可以创建看上去有点像动物同时也有点像交通工具(例如，汽车形状的猫)的图像。这是因为批归一化在由不同类别图片组成的整个批次中仅使用一个 γ \gamma γ 和一个 β \beta β。如果每种类别都有一个 γ \gamma γ 和一个 β \beta β，则该问题得以解决，而这正是条件批规范化的意义所在。每个类别有一个 γ \gamma γ 和一个 β \beta β，因此CIFAR10中的10个类别每层有10个 γ \gamma γ 和10个 β \beta β。

TensorFlow实现条件批归一化

现在，我们可以构造条件批处理规范化所需的变量，如下所示：

利用自定义层实现条件批归一化，首先创建所需变量：

class ConditionBatchNorm(Layer):
    def __init__(self, n_class=2, decay_rate=0.999, eps=1e-7):
        super(ConditionBatchNorm, self).__init__()
        self.n_class = n_class
        self.decay = decay_rate
        self.eps = 1e-5

    def build(self, input_shape):
        self.input_size = input_shape
        n, h, w, c = input_shape
        self.gamma = self.add_weight(shape=[self.n_class, c],
            initializer='zeros', trainable=True, name='gamma')
        self.moving_mean = self.add_weight(shape=[1, 1, 1, c],
            initializer='zeros', trainable=False, name='moving_mean')
        self.moving_var = self.add_weight(shape=[1, 1, 1, c],
            initializer='zeros', trainable=False, name='moving_var')

当运行条件批归一化时，为标签检索正确的 β \beta β 和 γ \gamma γ。这是使用 tf.gather(self.beta, labels) 完成的，它在概念上等效于 beta = self.beta[labels]，如下所示：

    def call(self, x, labels, trainable=False):
        beta = tf.gather(self.beta, labels)
        beta = tf.expand_dims(beta, 1)
        gamma = tf.gather(self.gamma, labels)
        gamma = tf.expand_dims(gamma, 1)
        if training:
            mean, var = tf.nn.moments(x, axes=(0,1,2), keepdims=True)
            self.moving_mean.assign(self.decay * self.moving_mean + (1-self.decay)*mean)
            self.moving_var.assign(self.decay * self.moving_var + (1-self.decay)*var)
            output = tf.nn.batch_normalization(x, mean, var, beta, gamma, self.eps)
        else:
            output = tf.nn.batch_normalization(x, self.moving_mean, self.moving_var, beta, gamma, self.eps)
        return output

在残差块中应用条件批归一化

条件批处理标准化的使用方式与批处理标准化相同，作为示例，我们现在将条件批处理标准化添加到残差块中：

[En]

Conditional batch normalization is used in the same way as batch normalization, and as an example, we now add conditional batch normalization to the residual block:

class ResBlock(Layer):
    def build(self, input_shape):
        input_filter = input_shape[-1]
        self.conv_1 = Conv2D(self.filters, 3, padding='same', name='conv2d_1')
        self.conv_2 = Conv2D(self.filters, 3, padding='same', name='conv2d_2')
        self.cbn_1 = ConditionBatchNorm(self.n_class)
        self.cbn_2 = ConditionBatchNorm(self.n_class)
Self.Studed_skip=FALSE<details><summary>*<font color='gray'>[En]</font>*</summary>*<font color='gray'>Self.learned_skip = False</font>*</details>
        if self.filters != input_filter:
            self.learned_skip = True
            self.conv_3 = Conv2D(self.filters, 1, padding='same', name='conv2d_3')
            self.cbn_3 = ConditionBatchNorm(self.n_class)

以下是使用条件批归一化残差块的前向计算代码：

    def call(self, input_tensor, labels):
        x = self.conv_1(input_tensor)
        x = self.cbn_1(x, labels)
        x = tf.nn.leaky_relu(x, 0.2)
        x = self.conv_2(x)
        x = tf.cbn_2(x, labels)
        x = tf.nn.leaky_relu(x, 0.2)
        if self.learned_skip:
            skip = self.conv_3(input_tensor)
            skip = self.cbn_3(skip, labels)
            skip = tf.nn.leaky_relu(skip, 0.2)
        else:
            skip = input_tensor
        output = skip + x
        return output

Original: https://blog.csdn.net/LOVEmy134611/article/details/119114925
Author: 盼小辉丶
Title: TensorFlow实现条件批归一化（Conditional Batch Normalization）

Original: https://blog.csdn.net/LOVEmy134611/article/details/119114925
Author: 盼小辉丶
Title: TensorFlow实现条件批归一化（Conditional Batch Normalization）