tf.config.experimental.list_physical_devices()
tf.config.experimental.list_physical_devices("GPU")
tf.config.experimental.list_physical_devices("CPU")

x = tf.random.uniform([3, 3])
x.device

import os
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"

tf.debugging.set_log_device_placement(True)  # 每个算子都会显示详细信息

with tf.device('/device:GPU:0'):
    a = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
    b = tf.constant([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
    c = tf.matmul(a, b)

print(c)

tf.zeros([10, 5])

tf.add(1, 2)
tf.add([1, 2], [3, 4])
tf.square(5)
tf.reduce_sum([1, 2, 3])
tf.square(2) + tf.square(3)

tf.matmul([[1]], [[2, 3]])

tf.data.Dataset.from_tensor_slices([1, 2, 3, 4, 5, 6])
ds_tensors.shuffle(2).batch(2).map(tf.square)
# 这是个 <dataset> 用法见于相关内容

x = tf.ones((2, 2))

# persistent=True 就可以多次运行 t.gradient，否则只能运行一次
with tf.GradientTape(persistent=True) as t:
  t.watch(x)
  y = tf.reduce_sum(x)
  z = tf.multiply(y, y)

# Derivative of z with respect to the original input tensor x
dz_dx = t.gradient(z, x)
dz_dx

dz_dy = t.gradient(z, y)
dz_dy

x = tf.Variable(1.0)  # Create a Tensorflow variable initialized to 1.0

with tf.GradientTape() as t:
  with tf.GradientTape() as t2:
    y = x * x * x
  # Compute the gradient inside the 't' context manager
  # which means the gradient computation is differentiable as well.
  dy_dx = t2.gradient(y, x)
d2y_dx2 = t.gradient(dy_dx, x)

v = tf.Variable(3.0)
v.assign(tf.square(v))
tf.assign_sub # 手写梯度下降时用的多

import tensorflow as tf
import numpy as np


class MyModel():
    def __init__(self):
        self.W = tf.Variable(1.0)
        self.b = tf.Variable(1.0)

    def __call__(self, x):
        return self.W * x + self.b


my_model = MyModel()

# %%
n_samples = 1000
X = np.random.rand(n_samples, 1) * 5
y = 5 * X + np.random.randn(n_samples, 1) + 2

import matplotlib.pyplot as plt

plt.plot(X, y, '.', label='true')
plt.plot(X, my_model(X), '.', label='predict')
plt.legend()
plt.show()


# %%

def loss(predict_y, true_y):
    return tf.reduce_mean(tf.square(predict_y - true_y))


def train(model, X, y, learning_rate):
    with tf.GradientTape() as t:
        current_loss = loss(my_model(X), y)
        dW, db = t.gradient(current_loss, [my_model.W, my_model.b])
        model.W.assign_sub(learning_rate * dW)
        model.b.assign_sub(learning_rate * db)


# %%
Ws, bs = [], []
losses = []

for epoch in range(100):
    Ws.append(my_model.W.numpy())
    bs.append(my_model.b.numpy())
    losses.append(loss(my_model(X), y))
    train(my_model, X, y, learning_rate=0.01)

# %%
fig, ax = plt.subplots(3, 1)
ax[0].plot(Ws, label='W')
ax[0].plot(bs, label='b')
ax[1].plot(losses, label='loss')
ax[2].plot(X, y, '.', label='true')
ax[2].plot(X, my_model(X), '.', label='predict')
ax[0].legend()
ax[1].legend()
ax[2].legend()

plt.show()

@tf.function
def add(a, b):
    return a + b

# 注意，shape也要严格满足，不然也会报错
@tf.function(input_signature=(tf.TensorSpec(shape=[None,None], dtype=tf.int32),))
def next_collatz(x):
  print("Tracing with", x)
  return tf.where(x % 2 == 0, x // 2, 3 * x + 1)

next_collatz(tf.constant([[1, 2], [3, 4]]))


# 或者用现成的
@tf.function
def double(a):
    return a + a

double_string = double.get_concrete_function(tf.TensorSpec(shape=None, dtype=tf.string))

double_string(tf.constant(["a"]))

my_feature_columns = [
    tf.feature_column.numeric_column(key='feature_name1',dtype=tf.float32) # 实数特征
    tf.feature_column.categorical_column_with_vocabulary_list(key='feature_name2', vocabulary_list=['A', 'B', 'C', 'D']) # 分类特征
    tf.feature_column.crossed_column(['age', 'sex'], hash_bucket_size=100) # 字段之间的交叉特征

]

classifier = tf.estimator.DNNClassifier(
    feature_columns=my_feature_columns,
    # Two hidden layers of 30 and 10 nodes respectively.
    hidden_units=[30, 10],
    # The model must choose between 3 classes.
    n_classes=3)

#  linear classifier (logistic regression model)
tf.estimator.LinearClassifier(feature_columns)

classifier.train(
    input_fn=lambda: input_fn(train, train_y, training=True),
    steps=5000)

print('\nTest set accuracy: {accuracy:0.3f}\n'.format(**eval_result))

predictions = classifier.predict(
    input_fn=lambda: input_fn(predict_x))

# predictions 是一个 generator

classifier.evaluate(input_fn)

# Since data fits into memory, use entire dataset per layer. It will be faster.
# Above one batch is defined as the entire dataset.
n_batches = 1
est = tf.estimator.BoostedTreesClassifier(feature_columns,
                                          n_batches_per_layer=n_batches)

# The model will stop training once the specified number of trees is built, not
# based on the number of steps.
est.train(train_input_fn, max_steps=100)

# Eval.
result = est.evaluate(eval_input_fn)

# 注：参数

params = {
  'n_trees': 50,
  'max_depth': 3,
  'n_batches_per_layer': 1,
  # You must enable center_bias = True to get DFCs. This will force the model to
  # make an initial prediction before using any features (e.g. use the mean of
  # the training labels for regression or log odds for classification when
  # using cross entropy loss).
  'center_bias': True
}

TRAIN_DATA_URL = "https://storage.googleapis.com/tf-datasets/titanic/train.csv"
train_file_path = tf.keras.utils.get_file("train.csv", TRAIN_DATA_URL)
# 从网上下载csv，并存到  ~\.keras\datasets 这个文件夹下。
# 返回的 train_file_path 是一个str，内容是存储路径

dataset = tf.data.experimental.make_csv_dataset(
    file_pattern=train_file_path,
    batch_size=5, # Artificially small to make examples easier to show.
    label_name='survived',
    na_value="?",
    num_epochs=1,
    ignore_errors=True)

dataset.take(1) # 返回的是一个generator

# dataset.take(1) 是一个 generator，里面是一个 batch
for batch, label in dataset.take(1):
    for key, value in batch.items():
          # 这里的key是 str，内容是 字段名
          # value是tf.Tensor，内容是 值（batch_size维）
          print(key, value)

from sklearn import datasets

X, y = datasets.make_classification(n_samples=1000, n_features=10)

dataset = tf.data.Dataset.from_tensor_slices((X, y))
# dataset 的类型是 <BatchDataset>
dataset = dataset.shuffle(100).batch(64)

# 取一个batch
dataset.take(1)

# 可以直接使用
model.fit(dataset, epochs=10)
model.evaluate(dataset)

import numpy as np

ndarray = np.ones([3, 3])

import pathlib
data_dir = tf.keras.utils.get_file(origin='https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
                                         fname='flower_photos', untar=True)
data_dir = pathlib.Path(data_dir)

import tensorflow_hub as hub

embed = hub.load("https://hub.tensorflow.google.cn/google/tf2-preview/gnews-swivel-20dim/1")
embeddings = embed(["cat is on the mat", "dog is in the fog"])

hub_layer = hub.KerasLayer("https://hub.tensorflow.google.cn/google/tf2-preview/gnews-swivel-20dim/1", output_shape=[20],
                           input_shape=[], dtype=tf.string)

model = keras.Sequential()
model.add(hub_layer)
model.add(keras.layers.Dense(16, activation='relu'))
model.add(keras.layers.Dense(1, activation='sigmoid'))

model.summary()

import tensorflow as tf

!pip install -q tensorflow-hub
!pip install -q tensorflow-datasets
import tensorflow_hub as hub
import tensorflow_datasets as tfds


print("Version: ", tf.__version__)
print("Eager mode: ", tf.executing_eagerly())
print("Hub version: ", hub.__version__)
print("GPU is", "available" if tf.config.experimental.list_physical_devices("GPU") else "NOT AVAILABLE")



train_validation_split = tfds.Split.TRAIN.subsplit([6, 4])

(train_data, validation_data), test_data = tfds.load(
    name="imdb_reviews",
    split=(train_validation_split, tfds.Split.TEST),
    as_supervised=True)



train_examples_batch, train_labels_batch = next(iter(train_data.batch(10)))
train_examples_batch

embedding = "https://hub.tensorflow.google.cn/google/tf2-preview/gnews-swivel-20dim/1"
hub_layer = hub.KerasLayer(embedding, input_shape=[],
                           dtype=tf.string, trainable=True)
hub_layer(train_examples_batch[:3])

model = tf.keras.Sequential()
model.add(hub_layer)
model.add(tf.keras.layers.Dense(16, activation='relu'))
model.add(tf.keras.layers.Dense(1, activation='sigmoid'))

model.summary()

model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

history = model.fit(train_data.shuffle(10000).batch(512),
                    epochs=20,
                    validation_data=validation_data.batch(512),
                    verbose=1)

results = model.evaluate(test_data.batch(512), verbose=2)

for name, value in zip(model.metrics_names, results):
    print("%s: %.3f" % (name, value))