db_test = db_test.map(preprocess).batch(batchSize)
model = Sequential([
layers.Dense(768, activation=tf.nn.relu),
layers.Dense(512, activation=tf.nn.relu),
layers.Dense(384, activation=tf.nn.relu),
layers.Dense(256, activation=tf.nn.relu),
layers.Dense(192, activation=tf.nn.relu),
layers.Dense(128, activation=tf.nn.relu),
layers.Dense(96, activation=tf.nn.relu),
layers.Dense(64, activation=tf.nn.relu),
layers.Dense(42, activation=tf.nn.relu),
layers.Dense(32, activation=tf.nn.relu),
layers.Dense(10)
])
model.build(input_shape=[None, inputShape])
model.summary()
optimizer = optimizers.Adam(lr=1e-3)
lossMean = metrics.Mean()
accuracy = metrics.Accuracy()
def main():
for epoch in range(20):
for step, (x, y) in enumerate(db):
x = tf.reshape(x, (-1, inputShape))
y_onehot = tf.one_hot(y, depth=10)
with tf.GradientTape() as tape:
logits = model(x)
from tensorflow.keras import datasets, layers, optimizers, Sequential, metrics
(xs, ys), _ = datasets.mnist.load_data()
print('datasets:', xs.shape, ys.shape, xs.min(), xs.max())
xs = tf.convert_to_tensor(xs, dtype=tf.float32) / 255.
db = tf.data.Dataset.from_tensor_slices((xs, ys))
db = db.batch(32).repeat(10)
network = Sequential([
layers.Dense(256, activation='relu'),
layers.Dense(256, activation='relu'),
layers.Dense(256, activation='relu'),
layers.Dense(10)
])
network.build(input_shape=(None, 28 * 28))
network.summary()
optimizer = optimizers.SGD(lr=0.01)
acc_meter = metrics.Accuracy()
for step, (x, y) in enumerate(db):
with tf.GradientTape() as tape:
# [b, 28, 28] => [b, 784]
x = tf.reshape(x, (-1, 28 * 28))
# [b, 784] => [b, 10]
out = network(x)
# [b] => [b, 10]
y_onehot = tf.one_hot(y, depth=10)
# [b, 10]
# x = tf.constant([2.,1.,0.1])#创建输入张量
# layer = layers.Softmax(axis = -1)#创建Softmax层
# out = layer(x)#调用softmax前向计算，输出为out
# #经过Softmax网络层后，得到概率分布out
# out = tf.nn.softmax(x)#调用softmax函数完成前向计算
#网络容器
#例如，2层的全连接层加上单独的激活函数层，可以通过Sequential容器封装为一个网络
#导入Sequential容器
from tensorflow.keras import layers,Sequential
network = Sequential([ #封装为一个网络
layers.Dense(3,activation=None),#全连接层，此处不使用激活函数
layers.ReLU(),#激活函数层
layers.Dense(2,activation=None),#全连接层，此处不使用激活函数
layers.ReLU()#激活函数层
])
x = tf.random.normal([4,3])
out = network(x) #输入从第一层开始，逐层传播至输出层，并返回输出层的输出
#Sequential容器也可以通过add()方法继续追加新的网络层，实现动态创建网络的功能
layers_num = 2#堆叠2次
network = Sequential([])#先创建空的网络容器
for _in range(layers_num):
network.add(layers.Dense(3))#添加全连接层
network.add(layers.ReLU())#添加激活函数层
network.build(input_shape=(4,4))#创建网络参数
network.summary()
#打印网络的待优化参数名与shape
for p in network.trainable_variables:
print(p.name,p.shape)#参数名和形状
(xs, ys), _ = datasets.mnist.load_data()
print('datasets:', xs.shape, ys.shape, xs.min(), xs.max())
batch_size = 32
xs = tf.convert_to_tensor(xs, dtype=tf.float32) / 255.
db = tf.data.Dataset.from_tensor_slices((xs, ys))
db = db.batch(batch_size).repeat(30)
model = Sequential([
layers.Dense(256, activation='relu'),
layers.Dense(128, activation='relu'),
layers.Dense(10)
])
model.build(input_shape=(4, 28 * 28))
model.summary()
optimizers = optimizers.SGD(lr=0.01)
acc_meter = metrics.Accuracy()
for step, (x, y) in enumerate(db):
with tf.GradientTape() as tap:
x = tf.reshape(x, (-1, 28 * 28))
out = model(x)
y_onehot = tf.one_hot(y, depth=10)
loss = tf.square(out - y_onehot)
loss = tf.reduce_sum(loss) / x.shape[0]
acc_meter.update_state(tf.argmax(out, axis=1), y)
grads = tap.gradient(loss, model.trainable_variables)
layers.Conv2D(192,
kernel_size=3,
strides=1,
padding=[[0, 0], [1, 1], [1, 1], [0, 0]],
activation='relu'), # 13*13*192
# 第四层
layers.Conv2D(192,
kernel_size=3,
strides=1,
padding=[[0, 0], [1, 1], [1, 1], [0, 0]],
activation='relu'), # 13*13*192
# 第五层
layers.Conv2D(128,
kernel_size=3,
strides=1,
padding=[[0, 0], [1, 1], [1, 1], [0, 0]],
activation='relu'), # 13*13*128
layers.MaxPooling2D(pool_size=3, strides=2), # 6*6*128
layers.Flatten(), # 6*6*128=4608
# 第六层
layers.Dense(1024, activation='relu'),
layers.Dropout(rate=0.5),
# 第七层
layers.Dense(128, activation='relu'),
layers.Dropout(rate=0.5),
# 第八层（输出层）
layers.Dense(5)
])
network.build(input_shape=(32, 224, 224, 3)) # 设置输入格式
network.summary() # 显示出每层的待优化参数量
x_train = x_train.reshape((-1, 28, 28, 1))
x_test = x_test.reshape((-1, 28, 28, 1))
x_train = x_train / 255.
x_test = x_test / 255.
model = Sequential([
layers.Conv2D(16, (3, 3), activation='relu'),
layers.MaxPool2D((2, 2)),
layers.Conv2D(32, (3, 3), activation='relu'),
layers.MaxPool2D((2, 2)),
layers.Flatten(),
layers.Dense(64, activation='relu'),
layers.Dense(32, activation='relu'),
layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.build(input_shape=(None, 28, 28, 1))
model.summary()
history = model.fit(x_train, y_train, epochs=10)
test_loss = model.evaluate(x_test, y_test)
print(test_loss)
tf.saved_model.save(model, "saved/1")
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, Sequential, losses, optimizers, datasets
# 获取所有 GPU 设备列表
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
# 设置 GPU 显存占用为按需分配，增长式，默认会占用全部显存
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
except RuntimeError as e:
# 异常处理
print(e)
# 创建 4 层全连接网络
model = Sequential([
layers.Dense(256, activation='relu'),
layers.Dense(256, activation='relu'),
layers.Dense(256, activation='relu'),
layers.Dense(10),
])
# build 模型，并打印模型信息
model.build(input_shape=(4, 784))
model.summary()
layers.Conv2D(64,
kernel_size=[3, 3],
padding="same",
activation=tf.nn.relu),
layers.Conv2D(64,
kernel_size=[3, 3],
padding="same",
activation=tf.nn.relu),
layers.MaxPool2D(pool_size=[2, 2], strides=2, padding="same"),
layers.Flatten(),
layers.Dense(512, activation=tf.nn.relu),
layers.Dropout(rate=0.5),
layers.Dense(2, activation=None)
]
my_net = Sequential(my_layers)
my_net.build(input_shape=[None, 64, 64, 3])
my_net.summary()
optimizer = optimizers.Adam(lr=1e-3)
acc_best = 0
patience_num = 10
no_improved_num = 0
for epoch in range(50):
for step, (x, y) in enumerate(db_train):
with tf.GradientTape() as tape:
out = my_net(x)
# print('out', out.shape)
logits = out
y_onehot = tf.one_hot(y, depth=2)
loss = tf.losses.categorical_crossentropy(y_onehot,
logits,
])
net_batch= Sequential([ layers.Dropout(0.5),
layers.BatchNormalization()])
net_LSTM = Sequential([layers.LSTM(64, dropout=0.5, return_sequences=True, unroll=True),
layers.LSTM(64, dropout=0.5, unroll=True)
])
net_Dense=Sequential([layers.Dense(1)])
optimizer = optimizers.Adam(lr=1e-3)
net_embedding.build(input_shape=[None, 80])
net_conv.build(input_shape=[None, 80,100,1])
net_batch.build(input_shape=[None, 78,1,126])
net_LSTM.build(input_shape=[None, 78,126])
net_Dense.build(input_shape=[None, 64])
variables_Dense_Conv = net_Dense.trainable_variables + net_conv.trainable_variables
variables = net_embedding.trainable_variables + net_conv.trainable_variables + net_LSTM.trainable_variables + net_Dense.trainable_variables + net_batch.trainable_variables
for epoch in range(100):
for step, (x, y) in enumerate(db_train):
with tf.GradientTape() as tape:
y=tf.cast(y,dtype=tf.float32)
y=tf.expand_dims(y,axis=-1)
out1=net_embedding(x)
print(train_inputs.shape)
#%%
### 신경망 학습을 위한 모듈 가져오기
import tensorflow as tf
from tensorflow.keras import datasets, layers, Sequential
#%%
# 모델 만들기
model = Sequential()
model.add(layers.Dense(40, activation='relu'))
model.add(layers.Dense(50, activation='relu'))
model.add(layers.Dense(40, activation='relu'))
model.add(layers.Dense(30, activation='relu'))
model.add(layers.Dense(len(labels), activation='softmax'))
model.build(input_shape=(None, 40))
model.summary()
#%%
# 훈련 시작
model.compile(
optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy']
)
model.fit(train_inputs, label_inputs, epochs=500)
#%%
# 모델 평가
test_loss, test_acc = model.evaluate(train_inputs, label_inputs, verbose=2)
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,Sequential
network=Sequential([layers.Dense(600,activation='relu'),
#layers.Dense(1200,activation='relu'),
#layers.Dense(1200,activation='relu'),
layers.Dense(600,activation='relu'),
layers.Dense(300,activation='relu'),
layers.Dense(6)])
network.build(input_shape=[None,150])
network.load_weights('.//weight/')
def GetValue(x):
x=tf.reshape(x,[-1,150])
out=network(x)
out=tf.nn.softmax(out,axis=1)
out=tf.argmax(out,axis=1)
out=tf.cast(out,dtype=tf.int32)
return int(out)
(train_images, train_labels), (test_images,
test_labels) = datasets.mnist.load_data()
train_images = train_images.reshape(60000, 28 * 28).astype('float32') / 255.0
test_images = test_images.reshape(10000, 28 * 28).astype('float32') / 255.0
# 对标签进行分类编码
train_labels = tf.keras.utils.to_categorical(train_labels)
test_labels = tf.keras.utils.to_categorical(test_labels)
# 2、构建模型(顺序)
model = Sequential([
Dense(256, activation='relu'),
Dense(128, activation='relu'),
Dense(28, activation='relu'),
Dense(10, activation='softmax')
])
model.build(input_shape=(None, 28 * 28))
# 3、编译模型
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc'])
# 4、拟合模型
history = model.fit(train_images,
train_labels,
epochs=50,
batch_size=512,
validation_data=(test_images, test_labels))
# 5、评估模型
model.evaluate(test_images, test_labels)
# 6、保存权重
os.remove('./mnist_model.h5')
activation='relu',
input_shape=(MAX_LEN, WORD_DEPTH)))
model.add(layers.MaxPool1D())
model.add(layers.Dropout(0.5))
#Not in original model, but I need 1 d output
model.add(layers.Flatten())
model.add(layers.Dense(100))
model.add(layers.Dense(1))
model.build()
model.compile(optimizer=keras.optimizers.Adadelta(),
loss=losses.MeanSquaredError())
print("Model built, training model. See ya in a few years")
symbols = [equity['symbol'] for equity in fh_client.stock_symbols('US')]
print("Train")
#Create Data
for symbol in symbols:
try:
fin_data = fh_client.financials(symbol, 'ic',
freq='quarterly')['financials'][:39]
eps_estimates = fh_client.company_eps_estimates(
symbol, freq='quarterly')['data'][9:(39 + 8)]
def main():
# 利用前面创建的层列表构建网络容器
conv_net = Sequential(conv_layers)
# 创建3层全连接层子网络
fc_net = Sequential([
layers.Dense(256, activation=tf.nn.relu),
layers.Dense(128, activation=tf.nn.relu),
layers.Dense(10, activation=None)
])
# build 2个子网络，并打印网络参数信息
conv_net.build(input_shape=[None, 32, 32, 3])
fc_net.build(input_shape=[None, 512])
conv_net.summary()
fc_net.summary()
optimizer = optimizers.Adam(lr=1e-4)
# 列表合并，合并2个子网络的参数
variables = conv_net.trainable_variables + fc_net.trainable_variables
for epoch in range(50):
for step, (_x, _y) in enumerate(train_db):
with tf.GradientTape() as tape:
# [b, 32, 32, 3] => [b, 1, 1, 512]
out = conv_net(_x)
# flatten, => [b, 512]
out = tf.reshape(out, [-1, 512])
# [b, 512] => [b, 10]
logits = fc_net(out)
# [b] => [b, 10]
y_onehot = tf.one_hot(_y, depth=10)
# compute loss
loss = tf.losses.categorical_crossentropy(y_onehot,
logits,
from_logits=True)
loss = tf.reduce_mean(loss)
# 对所有参数求梯度
grads = tape.gradient(loss, variables)
optimizer.apply_gradients(zip(grads, variables))
if step % 100 == 0:
print(epoch, step, 'loss:', float(loss))
total_num = 0
total_correct = 0
for _x, _y in test_db:
out = conv_net(_x)
out = tf.reshape(out, [-1, 512])
logits = fc_net(out)
prob = tf.nn.softmax(logits, axis=1)
pred = tf.argmax(prob, axis=-1)
pred = tf.cast(pred, dtype=tf.int32)
correct = tf.cast(tf.equal(pred, _y), dtype=tf.int32)
correct = tf.reduce_sum(correct)
total_num += _x.shape[0]
total_correct += int(correct)
acc = total_correct / total_num
print(epoch, 'acc:', acc)
from tensorflow.keras import Sequential
network = Sequential([ # 网络容器
layers.Conv2D(6,kernel_size=3,strides=1), # 第一个卷积层, 6个3x3卷积核
layers.MaxPooling2D(pool_size=2,strides=2), # 高宽各减半的池化层
layers.ReLU(), # 激活函数
layers.Conv2D(16,kernel_size=3,strides=1), # 第二个卷积层, 16个3x3卷积核
layers.MaxPooling2D(pool_size=2,strides=2), # 高宽各减半的池化层
layers.ReLU(), # 激活函数
layers.Flatten(), # 打平层，方便全连接层处理
layers.Dense(120, activation='relu'), # 全连接层，120个节点
layers.Dense(84, activation='relu'), # 全连接层，84节点
layers.Dense(10) # 全连接层，10个节点
])
# build一次网络模型，给输入X的形状，其中4为随意给的batchsz
network.build(input_shape=(4, 28, 28, 1))
# 统计网络信息
network.summary()
# %%
# 导入误差计算，优化器模块
from tensorflow.keras import losses, optimizers
# 创建损失函数的类，在实际计算时直接调用类实例即可
criteon = losses.CategoricalCrossentropy(from_logits=True)
optimizer = optimizers.Adam()
# %%
# 构建梯度记录环境
with tf.GradientTape() as tape:
print(x.shape)
net = Sequential([
layers.Conv2D(6, kernel_size=3, strides=1),
layers.BatchNormalization(),
layers.MaxPooling2D(pool_size=2, strides=2),
layers.ReLU(),
layers.Conv2D(16, kernel_size=3, strides=1),
layers.BatchNormalization(),
layers.MaxPooling2D(pool_size=2, strides=2),
layers.ReLU(),
layers.Flatten(),
layers.Dense(120, activation='relu'),
layers.Dense(84, activation='relu'),
layers.Dense(10)
])
net.build(input_shape=(None, 28, 28, 1))
criterion = losses.CategoricalCrossentropy(from_logits=True)
optimizer = optimizers.Adam(learning_rate=1e-3)
loss_meter = metrics.Mean()
acc_meter = metrics.Accuracy()
for epoch in range(10):
for step, (x, y) in enumerate(train_db):
with tf.GradientTape() as tape:
x = tf.expand_dims(x, axis=3)
out = net(tf.cast(x, dtype=tf.float32), training=True)
y_onehot = tf.one_hot(
tf.cast(y, dtype=tf.int32),depth=10
)
loss = criterion(y_onehot, out)
import tensorflow as tf
from tensorflow.keras import Sequential
from hanser.models.layers import Conv2d, Act, Norm, set_defaults
set_defaults({
'weight_decay': 1e-4,
})
m = Sequential([
Conv2d(3, 32, 3, norm='def'),
Act(name='act1'),
Conv2d(32, 32, 3, stride=1, bias=False, name='depthwise1'),
Conv2d(32, 32, 1, bias=False, name='pointwise1'),
Norm(32, name='norm1'),
])
m.build((None, 32, 32, 3))
len(m.losses)
db_test = db_test.map(preprocess).batch(batchsz)
sample = next(iter(db))
print(sample[0].shape, sample[1].shape)
network = Sequential([
layers.Dense(256, activation='relu'),
layers.Dropout(0.5),
# layers.Dense(64, activation='relu'),
layers.Dense(64, activation='relu'),
layers.Dropout(0.5),
layers.Dense(32, activation='relu'),
layers.Dense(10, activation='relu'),
layers.Dense(2)
])
network.build(input_shape=(None, 2080))
network.summary()
network.compile(optimizer=optimizers.Adam(lr=0.001),
loss=tf.losses.CategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
network.fit(db, epochs=40, validation_data=ds_val, validation_steps=2)
network.evaluate(db_test)
# sample = next(iter(db_test))
# x = sample[0]
# y = sample[1] # one-hot
# pred = network.predict(x) # [b, 10]
# # convert back to number
# fourth layer
layers.Conv2D(192, kernel_size=3, strides=1, padding=[[0, 0], [1, 1], [1, 1], [0, 0]], activation='relu'), # 13*13*192
# fifth layer
layers.Conv2D(128, kernel_size=3, strides=1, padding=[[0, 0], [1, 1], [1, 1], [0, 0]], activation='relu'), # 13*13*128
layers.MaxPooling2D(pool_size=3, strides=2), # 6*6*128
layers.Flatten(), # 6*6*128=4608
# 6th layer
layers.Dense(1024, activation='relu'),
layers.Dropout(rate=0.5),
# 7th layer
layers.Dense(128, activation='relu'),
layers.Dropout(rate=0.5),
# 8th layer（output）
layers.Dense(5)
])
network.build(input_shape=(32, 224, 224, 3))
network.summary()
# In[ ]:
# training
from tensorflow.python.client import device_lib
print(device_lib.list_local_devices())
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.9)
with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,log_device_placement=True),graph=detection_graph) as sess:
with tf.device("/gpu:0"):
optimizer = optimizers.SGD(lr=0.01) # Batch Gradient Descent Learning rate=0.01
# write by Mrlv
# coding:utf-8
import tensorflow as tf
from tensorflow.keras import layers, Sequential
import pandas as pd
a = tf.random.uniform([4, 256], maxval=50)
model = Sequential([
layers.Dense(128, activation='relu'),
layers.Dense(64, activation='relu'),
layers.Dense(10)
])
model.build([None, 256])
model.summary()
for p in model.variables:
print(p.name, p.shape)
from tensorflow.keras import losses, optimizers
network = Sequential([ # 网络容器
layers.Conv2D(6, kernel_size=3, strides=1), # 第一个卷积层, 6 个 3x3 卷积核
layers.MaxPooling2D(pool_size=2, strides=2), # 高宽各减半的池化层
layers.ReLU(), # 激活函数
layers.Conv2D(16, kernel_size=3, strides=1), # 第二个卷积层, 16 个 3x3 卷积核
layers.MaxPooling2D(pool_size=2, strides=2), # 高宽各减半的池化层
layers.ReLU(), # 激活函数
layers.Flatten(), # 打平层,方便全连接层处理
layers.Dense(120, activation='relu'), # 全连接层,120 个节点
layers.Dense(84, activation='relu'), # 全连接层,84 节点
layers.Dense(10) # 全连接层,10 个节点
])
# build 一次网络模型,给输入 X 的形状,其中 4 为随意给的 batchsz10.4 LeNet-5 实战
network.build(input_shape=(4, 28, 28, 1))
# 统计网络信息
network.summary()
# 创建损失函数的类,在实际计算时直接调用类实例即可
criteon = losses.CategoricalCrossentropy(from_logits=True)
# 构建梯度记录环境
with tf.GradientTape() as tape:
# 插入通道维度,=>[b,28,28,1]
x = tf.expand_dims(x, axis=3)
# 前向计算,获得 10 类别的概率分布,[b, 784] => [b, 10]
out = network(x)
# 真实标签 one-hot 编码,[b] => [b, 10]
y_onehot = tf.one_hot(y, depth=10)
# 计算交叉熵损失函数,标量
loss = criteon(y_onehot, out)
def main():
# 输入：[b, 32, 32, 3]
model = ResNet18()
# model = resnet1.ResNet([2, 2, 2], 10)
model.build(input_shape=(None, 32, 32, 3))
model.summary()
mydense = layers.Dense(100, activation=None)
fc_net = Sequential([mydense])
fc_net.build(input_shape=(None, 512))
fc_net.summary()
lr = 0.1
optimizer = optimizers.SGD(lr=lr, momentum=0.9, decay=5e-4)
variables = model.trainable_variables + fc_net.trainable_variables
for epoch in range(500):
for step, (x, y) in enumerate(train_db):
with tf.GradientTape() as tape:
# [b, 32, 32, 3] => [b, 100]
out = model(x, training=True)
avgpool = layers.GlobalAveragePooling2D()(out)
logits = fc_net(avgpool)
y_onehot = tf.one_hot(y, depth=100)
# 多类别交叉熵损失 结果维度[b]
loss = tf.reduce_mean(
tf.losses.categorical_crossentropy(y_onehot,
logits,
from_logits=True))
# 添加正则项，所有可以训练的权重添加l2正则项
loss_regularization = []
for p in variables:
loss_regularization.append(tf.nn.l2_loss(p))
loss_regularization = tf.reduce_sum(
tf.stack(loss_regularization))
loss = loss + 5e-4 * loss_regularization
# 梯度求解
grads = tape.gradient(loss, variables)
# 梯度更新
optimizer.apply_gradients(zip(grads, variables))
# 学习率动态调整
lr = lr_schedule_200ep(epoch)
# 每100个step打印一次
if step % 100 == 0:
print('epoch:', epoch, 'step:', step, 'loss:', float(loss),
'lr:', lr)
# 做测试
total_num = 0
total_correct = 0
for x, y in test_db:
out = model(x, training=False)
avgpool = layers.GlobalAveragePooling2D()(out)
output = fc_net(avgpool)
# 预测可能性。
prob = tf.nn.softmax(output, axis=1)
pred = tf.argmax(prob, axis=1) # 还记得吗pred类型为int64,需要转换一下。
pred = tf.cast(pred, dtype=tf.int32)
# 拿到预测值pred和真实值比较。
correct = tf.cast(tf.equal(pred, y), dtype=tf.int32)
correct = tf.reduce_sum(correct)
total_num += x.shape[0]
total_correct += int(correct) # 转换为numpy数据
acc = total_correct / total_num
print('epoch:', epoch, 'test_acc:', acc)
# 单元5，输出通道提升道512，高宽大小减半
layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
layers.MaxPool2D(pool_size=[2, 2], strides=2, padding="same")
]
conv_net = Sequential(conv_layers)
fc_net = Sequential([
layers.Dense(256, activation=tf.nn.relu),
layers.Dense(128, activation=tf.nn.relu),
layers.Dense(10, activation=tf.nn.relu)
])
conv_net.build(input_shape=[None, 32, 32, 3])
fc_net.build(input_shape=[None, 512])
optimizer = optimizers.Adam(lr=1e-4)
# 列表合并，合并2个子网络的参数
variables = conv_net.trainable_variables + fc_net.trainable_variables
for epoch in range(50):
for step, (x, y) in enumerate(train_db):
with tf.GradientTape() as tape:
# [b, 32, 32, 3] => [b, 1, 1, 512]
out = conv_net(x)
# flatten, => [b, 512]
db = db.map(preprocess).shuffle(x.shape[0]).batch(batchSize)
db_test = tf.data.Dataset.from_tensor_slices((x_test, y_test))
db_test = db_test.map(preprocess).batch(batchSize)
network = Sequential([
layers.Dense(inputShape, activation=tf.sigmoid),
layers.Dense(768, activation=tf.nn.relu),
layers.Dense(512, activation=tf.nn.relu),
layers.Dense(384, activation=tf.nn.relu),
layers.Dense(256, activation=tf.nn.relu),
layers.Dense(192, activation=tf.nn.relu),
layers.Dense(128, activation=tf.nn.relu),
layers.Dense(96, activation=tf.nn.relu),
layers.Dense(64, activation=tf.nn.relu),
layers.Dense(42, activation=tf.nn.relu),
layers.Dense(32, activation=tf.nn.relu),
layers.Dense(22, activation=tf.nn.relu),
layers.Dense(10)
])
network.build(input_shape=[None, inputShape])
network.summary()
network.compile(optimizer=optimizers.Adam(lr=1e-3),
loss=tf.losses.CategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
network.fit(db, epochs=10, validation_data=db_test, validation_steps=1)
network.evaluate(db_test)
def main():
# [b, 32, 32, 3] => [b, 1, 1, 512]
conv_net = Sequential(conv_layers)
fc_net = Sequential([
layers.Dense(256, activation=tf.nn.relu),
layers.Dense(128, activation=tf.nn.relu),
layers.Dense(10, activation=None),
])
conv_net.build(input_shape=[None, 32, 32, 3])
fc_net.build(input_shape=[None, 512])
conv_net.summary()
fc_net.summary()
optimizer = optimizers.Adam(lr=1e-4)
# [1, 2] + [3, 4] => [1, 2, 3, 4]
variables = conv_net.trainable_variables + fc_net.trainable_variables
for epoch in range(50):
for step, (x, y) in enumerate(train_db):
with tf.GradientTape() as tape:
# [b, 32, 32, 3] => [b, 1, 1, 512]
out = conv_net(x)
# flatten, => [b, 512]
out = tf.reshape(out, [-1, 512])
# [b, 512] => [b, 10]
logits = fc_net(out)
# [b] => [b, 10]
y_onehot = tf.one_hot(y, depth=10)
# compute loss
loss = tf.losses.categorical_crossentropy(y_onehot,
logits,
from_logits=True)
loss = tf.reduce_mean(loss)
grads = tape.gradient(loss, variables)
optimizer.apply_gradients(zip(grads, variables))
if step % 100 == 0:
print(epoch, step, "loss:", float(loss))
total_num = 0
total_correct = 0
for x, y in test_db:
out = conv_net(x)
out = tf.reshape(out, [-1, 512])
logits = fc_net(out)
prob = tf.nn.softmax(logits, axis=1)
pred = tf.argmax(prob, axis=1)
pred = tf.cast(pred, dtype=tf.int32)
correct = tf.cast(tf.equal(pred, y), dtype=tf.int32)
correct = tf.reduce_sum(correct)
total_num += x.shape[0]
total_correct += int(correct)
acc = total_correct / total_num
print(epoch, "acc:", acc)
layers.MaxPool2D([2, 2]), # 4x4
layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
layers.MaxPool2D([2, 2]), # 2x2
# 转换形状
# layers.Reshape((-1, 512), input_shape=(-1, 1, 1, 512)), # 这里加一个 Reshape层就好啦
layers.Flatten(),
layers.Dense(256, activation=tf.nn.relu),
layers.Dense(128, activation=tf.nn.relu),
layers.Dense(100, activation=None),
])
network.build(input_shape=[None, 32, 32, 3])
network.summary()
# 用 keras 的高层API直接训练
#network.compile(
# optimizer=optimizers.Adam(lr=1e-4),
# loss=tf.losses.categorical_crossentropy, # MSE 是个对象， CategoricalCrossentropy 是个类
# metrics=['accuracy']
#)
network.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
network.fit(train_db, epochs=20, validation_data=test_db, validation_freq=2)
network.save('./model.h5')
print('batch:', sample[0].shape, sample[1].shape)
# 进行5层变换。构建出5层的全连接层
# sequential容器，可以将多个Dense层包含起来，可以逐次进行
model = Sequential([
# x的shape=(b,784) w(784,256)
# 第一层 输出维度是256，推断，kernel(即w)为[784, 256]，这样x@w才是[b, 256]
layers.Dense(256, activation=tf.nn.relu), # [b, 784] -> [b,256]
# 第一层 输出维度是128。kernel(即w)为[256, 128]
layers.Dense(128, activation=tf.nn.relu), # [b, 256] -> [b,128]
layers.Dense(64, activation=tf.nn.relu), # [b, 128] -> [b,64]
layers.Dense(32, activation=tf.nn.relu), # [b, 64] -> [b,32]
layers.Dense(10) # [b, 32] -> [b,10]
])
# 输入的维度，28*28=784,即和上面的第一层联系起来.此时就可以推断出w和b的shape
model.build(input_shape=[None, 28 * 28])
model.summary() # 调试功能
'''
# ----- 模型训练----
# 声明优化器
# 他的作用是更新优化参数，即w = w - lr*grad这样更新
optimizer = optimizers.Adam(lr=1e-3)
# 30次训练
for epoch in range(30):
# 遍历数据集.由于db一共是60k个数据，而batch是128,所以一共循环60k/128次
for step, (x, y) in enumerate(db):
# x:[b, 28, 28],其中b=128,因为batch是128
def main():
conv_net = Sequential([conv_layers])
conv_net.build(input_shape=[None, 32, 32, 3])
x = tf.random.normal([4, 32, 32, 3])
out = conv_net(x)
print(out.shape)
db = db.map(preprocess).shuffle(60000).batch(batchsz).repeat(10)
db_val = tf.data.Dataset.from_tensor_slices((x_val, y_val))
db_val = db_val.map(preprocess).batch(batchsz)
optimizer = optimizers.Adam(learning_rate=1e-3)
network = Sequential([layers.Dense(256, activation='relu'),
layers.Dropout(0.5),
layers.Dense(128, activation='relu'),
layers.Dropout(0.5),
layers.Dense(64, activation='relu'),
layers.Dense(32, activation='relu'),
layers.Dense(10)
])
network.build(input_shape=[None, 28*28])
network.summary()
for step, (x, y) in enumerate(db):
with tf.GradientTape() as tape:
x = tf.reshape(x, [-1, 28*28])
out = network(x, training=True)
y_onehot = tf.one_hot(y, depth=10)
loss = tf.reduce_sum(tf.losses.categorical_crossentropy(y_onehot, out, from_logits=True))
loss_regularizaton = []
for p in network.trainable_variables:
loss_regularizaton.append(tf.nn.l2_loss(p))
loss_regularizaton = tf.reduce_sum(loss_regularizaton)
loss += 0.0001*loss_regularizaton
grads = tape.gradient(loss, network.trainable_variables)
optimizer.apply_gradients(zip(grads, network.trainable_variables))
def train322(trainx, trainy, testx, testy):
conv_layers = [
# layers.Conv2D(8, kernel_size=[3, 3], padding="same", activation=tf.nn.relu), # 卷积核数量，卷积核大小，填充方式，激活函数
# layers.MaxPool2D(pool_size=[2, 2], strides=2, padding='same'),
# layers.Dropout(0.5),
#
#
# layers.Conv2D(16, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
# layers.MaxPool2D(pool_size=[2, 2], strides=2, padding='same'), # strides代表步长
# layers.Dropout(0.5),
#
#
# layers.Conv2D(32, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
# layers.MaxPool2D(pool_size=[2, 2], strides=2, padding='same'),
# layers.Dropout(0.5),
#设置卷积和池化层数，加入dropout层是防止过拟合
layers.Conv2D(32,
kernel_size=[3, 3],
padding="same",
activation=tf.nn.relu), # 卷积核数量，卷积核大小，填充方式，激活函数
layers.MaxPool2D(pool_size=[2, 2], strides=2, padding='same'),
layers.Dropout(0.25),
layers.Conv2D(32,
kernel_size=[3, 3],
padding="same",
activation=tf.nn.relu),
layers.MaxPool2D(pool_size=[2, 2], strides=2, padding='same'),
layers.Dropout(0.5),
layers.Conv2D(64,
kernel_size=[3, 3],
padding="same",
activation=tf.nn.relu),
layers.MaxPool2D(pool_size=[2, 2], strides=2, padding='same'),
layers.Dropout(0.5),
# 扁平化
tf.keras.layers.Flatten(),
layers.Dense(1024, activation=tf.nn.relu), # 1024代表神经元的数量
layers.Dense(20), #根据所分类的类别数来确定参数的值
]
net = Sequential(conv_layers)
# 输入数据为(x, 28, 28, 1)
# 构建
net.build(input_shape=(None, 128, 128, 1))
net.summary()
# 设置模型训练方法
net.compile(optimizer=optimizers.Adam(lr=0.001),
loss=tf.losses.CategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
# 训练
net.fit(trainx,
trainy,
batch_size=100,
epochs=15,
verbose=1,
callbacks=[],
validation_data=(testx, testy),
shuffle=True)
# 对模型进行评估
net.evaluate(testx, testy)
# 保存模型
net.save('model/model.h5')
# 保存参数
net.save_weights('model/weights.ckpt')
