from sklearn.datasets import load_sample_images
import tensorflow as tf

images = load_sample_images()["images"]
images = tf.keras.layers.CenterCrop(height=70, width=120)(images)
images = tf.keras.layers.Rescaling(scale=1 / 255)(images)

max_pool = tf.keras.layers.MaxPool2D(pool_size=2)
To create an average pooling layer, just use AveragePooling2D, alias AvgPool2D, instead of MaxPool2D.

class DepthPool(tf.keras.layers.Layer):
    def __init__(self, pool_size=2, **kwargs):
        super().__init__(**kwargs)
        self.pool_size = pool_size

    def call(self, inputs):
        shape = tf.shape(inputs)  # shape[-1] is the number of channels
        groups = shape[-1] // self.pool_size  # number of channel groups
        new_shape = tf.concat([shape[:-1], [groups, self.pool_size]], axis=0)
        return tf.reduce_max(tf.reshape(inputs, new_shape), axis=-1)

global_avg_pool = tf.keras.layers.GlobalAvgPool2D()

# 它等效于此简单的Lambda层，该层计算空间维度（高度和宽度）上的平均值：
global_avg_pool = tf.keras.layers.Lambda(lambda X: tf.reduce_mean(X, axis=[1, 2]))


# 例如
>>> global_avg_pool(images)
<tf.Tensor: shape=(2, 3), dtype=float32, numpy=
array([[0.64338624, 0.5971759 , 0.5824972 ],
    [0.76306933, 0.26011038, 0.10849128]], dtype=float32)>

from functools import partial

DefaultConv2D = partial(tf.keras.layers.Conv2D, kernel_size=3, padding="same",
                        activation="relu", kernel_initializer="he_normal")
model = tf.keras.Sequential([
    # the images are 28 × 28 pixels, with a single color channel
    DefaultConv2D(filters=64, kernel_size=7, input_shape=[28, 28, 1]),
    tf.keras.layers.MaxPool2D(),
    DefaultConv2D(filters=128),
    DefaultConv2D(filters=128),
    tf.keras.layers.MaxPool2D(),
    DefaultConv2D(filters=256),
    DefaultConv2D(filters=256),
    tf.keras.layers.MaxPool2D(),

    # 接下来是全连接的网络
    # 请注意，我们必须将其输入展平，因为密集网络需要每个
    # 实例的一维特征阵列。我们还添加了两个dropout层，每层的dropout率
    # 均为50％，以减少过拟合的情况。
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(units=128, activation="relu",
                          kernel_initializer="he_normal"),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(units=64, activation="relu",
                          kernel_initializer="he_normal"),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(units=10, activation="softmax")
])

DefaultConv2D = partial(tf.keras.layers.Conv2D, kernel_size=3, strides=1,
                        padding="same", kernel_initializer="he_normal",
                        use_bias=False)

class ResidualUnit(tf.keras.layers.Layer):
    def __init__(self, filters, strides=1, activation="relu", **kwargs):
        super().__init__(**kwargs)
        self.activation = tf.keras.activations.get(activation)
        self.main_layers = [
            DefaultConv2D(filters, strides=strides),
            tf.keras.layers.BatchNormalization(),
            self.activation,
            DefaultConv2D(filters),
            tf.keras.layers.BatchNormalization()
        ]
        self.skip_layers = []
        if strides > 1:
            self.skip_layers = [
                DefaultConv2D(filters, kernel_size=1, strides=strides),
                tf.keras.layers.BatchNormalization()
            ]

    def call(self, inputs):
        Z = inputs
        for layer in self.main_layers:
            Z = layer(Z)
        skip_Z = inputs
        for layer in self.skip_layers:
            skip_Z = layer(skip_Z)
        return self.activation(Z + skip_Z)


# 接下来，我们可以使用Sequential模型来构建ResNet-34
# 实际上只是一个很长的层序列
model = tf.keras.Sequential([
    DefaultConv2D(64, kernel_size=7, strides=2, input_shape=[224, 224, 3]),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Activation("relu"),
    tf.keras.layers.MaxPool2D(pool_size=3, strides=2, padding="same"),
])
prev_filters = 64
for filters in [64] * 3 + [128] * 4 + [256] * 6 + [512] * 3:
    strides = 1 if filters == prev_filters else 2
    model.add(ResidualUnit(filters, strides=strides))
    prev_filters = filters

model.add(tf.keras.layers.GlobalAvgPool2D())
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(10, activation="softmax"))

model = tf.keras.applications.ResNet50(weights="imagenet")

images = load_sample_images()["images"]
images_resized = tf.keras.layers.Resizing(height=224, width=224, crop_to_aspect_ratio=True)(images)


# 每个模型都提供一个preprocess_input（）函数，你可以用来预处理图像
inputs = tf.keras.applications.resnet50.preprocess_input(images_resized)

# Now we can use the pretrained model to make predictions:

>>> Y_proba = model.predict(inputs)
>>> Y_proba.shape
(2, 1000)

# 通常Y_proba输出一个矩阵，每个图像一行，每个类一列（在此例
# 中，共有1000个类）。如果要显示前K个预测（包括类名和每个预测类
# 的估计概率），请使用encode_predictions（）函数。
# 对于每个图像，它返回一个包含前K个预测的数组，其中每个预测都表示为一个包
# 含类标识符、其名称和对应置信度得分的数组：
top_K = tf.keras.applications.resnet50.decode_predictions(Y_proba, top=3)
for image_index in range(len(images)):
    print(f"Image #{image_index}")
    for class_id, name, y_proba in top_K[image_index]:
        print(f"  {class_id} - {name:12s} {y_proba:.2%}")

# The output looks like this:

# Image #0
#   n03877845 - palace       54.69%
#   n03781244 - monastery    24.72%
#   n02825657 - bell_cote    18.55%
# Image #1
#   n04522168 - vase         32.66%
#   n11939491 - daisy        17.81%
#   n03530642 - honeycomb    12.06%

# 先导入数据
import tensorflow_datasets as tfds
# 通过设置with_info=True获得有关数据集的信息。
dataset, info = tfds.load("tf_flowers", as_supervised=True, with_info=True)
dataset_size = info.splits["train"].num_examples  # 3670
class_names = info.features["label"].names  # ["dandelion", "daisy", ...]
n_classes = info.features["label"].num_classes  # 5



# 由于只有训练集，没有其他数据集，因此进行拆分
test_set_raw, valid_set_raw, train_set_raw = tfds.load(
    "tf_flowers",
    split=["train[:10%]", "train[10%:25%]", "train[25%:]"],
    as_supervised=True)
# 10％用于测试，接下来的15％用于验证，其余的75％用于训练


# 接下来必须确保输入数据的大小符合要求
batch_size = 32
preprocess = tf.keras.Sequential([
    tf.keras.layers.Resizing(height=224, width=224, crop_to_aspect_ratio=True),
    tf.keras.layers.Lambda(tf.keras.applications.xception.preprocess_input)
])
train_set = train_set_raw.map(lambda X, y: (preprocess(X), y))
train_set = train_set.shuffle(1000, seed=42).batch(batch_size).prefetch(1)
valid_set = valid_set_raw.map(lambda X, y: (preprocess(X), y)).batch(batch_size)
test_set = test_set_raw.map(lambda X, y: (preprocess(X), y)).batch(batch_size)

# Now each batch contains 32 images, all of them 224 × 224 pixels, 
# with pixel values ranging from –1 to 1. Perfect!

# Since the dataset is not very large, a bit of data augmentation will certainly help.
data_augmentation = tf.keras.Sequential([
    tf.keras.layers.RandomFlip(mode="horizontal", seed=42),
    tf.keras.layers.RandomRotation(factor=0.05, seed=42),
    tf.keras.layers.RandomContrast(factor=0.2, seed=42)
])

# 接下来，我们加载一个在ImageNet上预训练的Xception模型。我
# 们通过设置include_top=False排除网络的顶部：这排除了全局平均池
# 化层和密集输出层。然后，根据基本模型的输出，添加我们自己的全
# 局平均池化层，再跟一个每个类一个单位的密集输出层，使用softmax
# 激活函数。最后我们创建Keras模型：
base_model = tf.keras.applications.xception.Xception(weights="imagenet", include_top=False)
avg = tf.keras.layers.GlobalAveragePooling2D()(base_model.output)
output = tf.keras.layers.Dense(n_classes, activation="softmax")(avg)
model = tf.keras.Model(inputs=base_model.input, outputs=output)

# 在训练开始时冻结预训练层的权重
for layer in base_model.layers:
    layer.trainable = False
# 由于我们的模型直接使用基本模型的层，而不是使用
# base_model对象本身，因此设置base_model.trainable=False无效。

# Finally, we can compile the model and start training:
optimizer = tf.keras.optimizers.SGD(learning_rate=0.1, momentum=0.9)
model.compile(loss="sparse_categorical_crossentropy", optimizer=optimizer,
              metrics=["accuracy"])
history = model.fit(train_set, validation_data=valid_set, epochs=3)


# 对模型进行几个轮次的训练后，其验证准确率应该达到80%以上,
# 并且不再取得很大进展。这意味着顶层现在已经受过良好的训练，因
# 此我们准备解冻所有层（或者你可以尝试只解冻顶层）并继续进行训
# 练（在冻结或解冻时不要忘记编译模型）。这次我们使用低得多的学
# 习率来避免损坏预训练的权重：
for layer in base_model.layers[56:]:
    layer.trainable = True
# Don’t forget to compile the model whenever you freeze or unfreeze layers. 
# Also make sure to use a much lower learning rate to avoid damaging the pretrained weights:
optimizer = tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)
model.compile(loss="sparse_categorical_crossentropy", optimizer=optimizer, metrics=["accuracy"])
history = model.fit(train_set, validation_data=valid_set, epochs=10)