def multi_hot_sequences(sequences, dimension):
results = np.zeros((len(sequences), dimension))
for i, word_indices in enumerate(sequences):
results[i, word_indices] = 1.0
return results
train_data = multi_hot_sequences(train_data, dimension=NUM_WORDS)
test_data = multi_hot_sequences(test_data, dimension=NUM_WORDS)
plt.plot(train_data[0])
plt.show()
# 降低正则化：减少模型每层的单元数，降低记忆容量；如果容量优先，则难以与训练数据拟合
baseline_model = keras.Sequential()
baseline_model.add(
keras.layers.Dense(16, activation=tf.nn.relu, input_shape=(NUM_WORDS, )))
baseline_model.add(keras.layers.Dense(16, activation=tf.nn.relu))
baseline_model.add(keras.layers.Dense(1, activation=tf.nn.sigmoid))
baseline_model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy', 'binary_crossentropy'])
baseline_model.summary()
baseline_history = baseline_model.fit(train_data,
train_labels,
epochs=20,
batch_size=512,
validation_data=(test_data, test_labels),
verbose=2)
import numpy as np
import matplotlib.pyplot as plt
fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
train_images = train_images / 255.0
test_images = test_images / 255.0
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)), # input data
keras.layers.Dense(128, activation='relu'), # hidden layer
keras.layers.Dense(10, activation='softmax') # output data
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=10) # epochs rodando 10 vezes
#evaluating the model
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=1)
print('Test accuracy:', test_acc)
#previsao
strip_chars = "!\"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"
strip_chars = strip_chars.replace("<", "")
strip_chars = strip_chars.replace(">", "")
vectorization = TextVectorization(
max_tokens=VOCAB_SIZE,
output_mode="int",
output_sequence_length=SEQ_LENGTH,
standardize=custom_standardization,
)
vectorization.adapt(text_data)
# Data augmentation for image data
image_augmentation = keras.Sequential([
layers.RandomFlip("horizontal"),
layers.RandomRotation(0.2),
layers.RandomContrast(0.3),
])
"""
## Building a `tf.data.Dataset` pipeline for training
We will generate pairs of images and corresponding captions using a `tf.data.Dataset` object.
The pipeline consists of two steps:
1. Read the image from the disk
2. Tokenize all the five captions corresponding to the image
"""
def decode_and_resize(img_path):
img = tf.io.read_file(img_path)
plt.show()
# Building the neural network requires configuring the layers of the model and building it
# Basic building block of a neural network is a layer
# Layers extract representations from the data fed into them
# Most of deep learning consists of chaining together layers
# Most layers have parameters that are learned during training
# Keras is a high level API to build and train deep learning models
# Can put these together and extend functionality
model = keras.Sequential([
keras.layers.Flatten(
input_shape=(28, 28)), # Flattens from 2d array to on 1d array
keras.layers.Dense(128, activation=tf.nn.relu
), # 128 nodes or neuron densely connected neural layer
keras.layers.Dense(10, activation=tf.nn.softmax)
])
# 10 node or neuron softmax layer. Returns array of 10 probability
# Input shape has to be defined on the first layer in sequential model
# Compile step below:
# Optimizer: This is how the the model is updated based on data it sees and loss function
# Loss function: measures how accurate the model is during training.
# Goal is to minimize this function to steer the model in right direction
# Metrics: self explanatory. This one measures how many are labeled correctly
model.compile(optimizer='adam',
# In this example, we build a simple model to learn to do xor operation.
#%%
import tensorflow as tf
from tensorflow import keras
import numpy as np
from random import uniform
#%%
# Definition of the model.
model = keras.Sequential([
keras.layers.Dense(4, activation='relu', input_shape=(2, )),
keras.layers.Dense(4, activation='relu'),
keras.layers.Dense(1, activation='sigmoid')
])
#%%
model.compile(optimizer='sgd',
loss='binary_crossentropy',
metrics=['accuracy'])
#%%
data = []
for i in range(0, 200):
data.append([uniform(-10, 10), uniform(-10, 10)])
data = np.array(data)
def xor(pair):
x1, x2 = pair
if (x1 >= 0 and x2 < 0) or (x1 < 0 and x2 >= 0):
rotation_range=2, horizontal_flip=True, zoom_range=.1)
train_generator.fit(x_train)
test_generator.fit(x_test)
lrr = K.callbacks.ReduceLROnPlateau(monitor='val_acc',
factor=.01,
patience=3,
min_lr=1e-5)
base_model_1 = K.applications.VGG19(include_top=False,
weights='imagenet',
input_shape=(32, 32, 3),
classes=y_train.shape[1])
model_1 = K.Sequential()
model_1.add(base_model_1)
model_1.add(K.layers.Flatten())
model_1.add(K.layers.Dense(1024, activation=('relu'), input_dim=512))
model_1.add(K.layers.Dense(512, activation=('relu')))
model_1.add(K.layers.Dense(256, activation=('relu')))
model_1.add(K.layers.Dropout(.3))
model_1.add(K.layers.Dense(128, activation=('relu')))
model_1.add(K.layers.Dropout(.2))
model_1.add(K.layers.Dense(10, activation=('softmax')))
model_1.summary()
batch = 100
epochs = 1
learn_rate = .001
def create_model(X_train, Y_train, X_test, Y_test):
initial_size = {{choice([12, 32, 64, 128])}}
model = keras.Sequential([
keras.layers.Conv2D(filters=initial_size,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu',
input_shape=(192, 192, 1)),
keras.layers.Conv2D(filters=initial_size,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu'),
keras.layers.Conv2D(filters=initial_size,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu'),
keras.layers.MaxPooling2D(pool_size=(2, 2), padding='valid'),
keras.layers.Conv2D(filters=initial_size * 2,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu'),
keras.layers.Conv2D(filters=initial_size * 2,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu'),
keras.layers.Conv2D(filters=initial_size * 2,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu'),
keras.layers.MaxPooling2D(pool_size=(2, 2), padding='valid'),
keras.layers.Conv2D(filters=initial_size * 4,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu'),
keras.layers.Conv2D(filters=initial_size * 4,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu'),
keras.layers.Conv2D(filters=initial_size * 4,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu'),
keras.layers.MaxPooling2D(pool_size=(2, 2), padding='valid'),
keras.layers.Conv2D(filters=initial_size * 8,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu'),
keras.layers.Conv2D(filters=initial_size * 8,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu'),
keras.layers.Conv2D(filters=initial_size * 8,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu'),
keras.layers.MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
padding='valid'),
# first flatten
keras.layers.GlobalAveragePooling2D(),
keras.layers.Flatten(),
keras.layers.Dense(8, activation=tf.nn.softmax)
])
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.summary()
result = model.fit(X_train,
Y_train,
validation_split=0.1,
epochs=4,
verbose=1,
batch_size=32,
shuffle=True)
print(result.history)
validation_acc = np.amax(result.history['val_accuracy'])
return {'loss': -validation_acc, 'status': STATUS_OK, 'model': model}
train_stats = train_stats.transpose()
train_labels = train_dataset.pop('MPG')
test_labels = test_dataset.pop('MPG')
def norm(x):
return (x - train_stats['mean']) / train_stats['std']
normed_train_data = norm(train_dataset)
normed_test_data = norm(test_dataset)
model = keras.Sequential([
keras.layers.Dense(64, activation=tf.nn.relu, input_shape=[len(train_dataset.keys())]),
keras.layers.Dense(64, activation=tf.nn.relu),
keras.layers.Dense(1)
])
optimizer = tf.keras.optimizers.RMSprop(0.001)
model.compile(loss='mean_squared_error',
optimizer=optimizer,
metrics=['mean_absolute_error', 'mean_squared_error'])
# Display training progress by printing a single dot for each completed epoch
class PrintDot(keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs):
if epoch % 100 == 0:
print('')
def run(data_dir, **kwargs):
# Load configuration file for the FootDownNetwork
config_path = os.path.join(
os.path.dirname(__file__),
os.path.pardir,
"module",
"platform",
"darwin",
"SensorFilter",
"data",
"config",
"FootDownNetwork.yaml",
)
with open(config_path, "r") as f:
config = yaml.safe_load(f)
lr_duplicate = config["train"]["lr_duplicate"]
foot_delta = config["train"]["foot_delta"]
servos = config["network"]["input"]["servos"]
fields = config["network"]["input"]["fields"]
use_accel = config["network"]["input"]["accelerometer"]
use_gyro = config["network"]["input"]["gyroscope"]
print("Loading data from NBS files")
group_xs = []
group_ys = []
group_desc = []
for state in tqdm(os.listdir(data_dir), dynamic_ncols=True,
unit="dir"):
state_dir = os.path.join(data_dir, state)
if os.path.isdir(state_dir):
state_info = re.match(
"left_(up|down|mixed)_right_(up|down|mixed)", state)
if state_info is not None:
l_state = state_info.group(1)
r_state = state_info.group(2)
for group in tqdm(os.listdir(state_dir),
dynamic_ncols=True,
unit="group"):
group_dir = os.path.join(state_dir, group)
if os.path.isdir(group_dir):
# Gather all groups into a single dataset for this specific type
xs = []
ys = []
for nbs in tqdm(os.listdir(group_dir),
dynamic_ncols=True,
unit="file"):
nbs_path = os.path.join(group_dir, nbs)
if nbs_path.endswith(
(".nbs.gz", ".nbs", ".nbz")):
# Load the file
x, y = dataset(
nbs_path,
r_state,
l_state,
servos,
fields,
lr_duplicate,
foot_delta,
use_accel,
use_gyro,
)
# Cut off the end 10% to account for nonsense setup and teardown
x = x[len(x) // 10:-len(x) // 10]
y = y[len(y) // 10:-len(y) // 10]
xs.append(x)
ys.append(y)
group_desc.append(group)
group_xs.append(np.concatenate(xs, axis=0))
group_ys.append(np.concatenate(ys, axis=0))
# Find the largest size we have and replicate random elements in the other dataset to fill
mx = max([x.shape[0] for x in group_xs])
# Oversample our categories so they are the same size
xs = []
ys = []
for x, y in zip(group_xs, group_ys):
idx = np.random.randint(0, len(x), mx)
xs.append(x[idx])
ys.append(y[idx])
# Join into single dataset
xs = np.concatenate(xs)
ys = np.concatenate(ys)
# Random shuffle the data
idx = np.arange(len(xs))
np.random.shuffle(idx)
xs = xs[idx]
ys = ys[idx]
# Split into training and validation
split = int(len(xs) * 0.8)
train_x = xs[:split]
train_y = ys[:split]
valid_x = xs[split:]
valid_y = ys[split:]
# Build our model
model = keras.Sequential([
keras.layers.Dense(8, activation=tf.nn.relu),
keras.layers.Dense(2, activation=tf.nn.sigmoid)
])
model.compile(
optimizer=keras.optimizers.Adam(),
loss=keras.losses.BinaryCrossentropy(),
metrics=[keras.metrics.BinaryAccuracy()],
)
history = model.fit(
train_x,
train_y,
batch_size=4096,
epochs=1000,
validation_data=(valid_x, valid_y),
callbacks=[keras.callbacks.EarlyStopping(patience=5)],
)
print("Final Accuracy", history.history["val_binary_accuracy"][-1])
for desc, x, y in zip(group_desc, group_xs, group_ys):
print("Evaluating", desc)
model.evaluate(x, y)
config["network"] = {
"input": {
"servos": servos,
"fields": fields,
"accelerometer": use_accel,
"gyroscope": use_gyro
},
"layers": [],
}
for layer in model.layers:
h = layer.get_weights()
weights = np.array(h[0]).tolist()
biases = np.array(h[1]).tolist()
config["network"]["layers"].append({
"weights": weights,
"biases": biases
})
with open(config_path, "w") as f:
f.write(yaml.dump(config, width=120))
(train_images, train_labels), (test_images, test_labels) = data.load_data()
print("Number train images:\t"+str(len(train_images)))
print("Number test images:\t"+str(len(test_images)))
# Train the model
if(not os.path.exists(model_file_name)):
#To make it easier to work with the model but matplot will show the same image.
train_images = train_images/255.0
test_images = test_images/255.0
# Since we are working with 28x28 images we are going to have 784 input nodes
# and since we have 10 labels we are going to have 10 output nodes.
# We are going to have a hidden layer with 128 nodes.
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28,28)),
keras.layers.Dense(128, activation="relu"), # rectifier linear unit
keras.layers.Dense(10, activation="softmax") # probability for each given class.
])
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
model.fit(train_images, train_labels, epochs=10) #how many times your are going to see the sane image
# Save model in a file
model.save(model_file_name)
# Evaluate accuracy
test_loss, test_acc = model.evaluate(test_images, test_labels)
print("Tested Acc: ", test_acc)
# Load the model
else:
model = keras.models.load_model(model_file_name)
# Show how to the user how the input should be
prediction = model.predict(test_images)
def __create_base_model(self, **kwargs):
base_model = keras.Sequential([])
return base_model
print("x_train_shape:", x_train.shape)
print(x_train.shape[0], "train samples")
print(x_test.shape[0], "test samples")
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
# Build the model
model = keras.Sequential(
[
keras.Input(shape=input_shape),
layers.Conv2D(32, kernel_size=(3,3), activation="relu"),
layers.MaxPooling2D(pool_size=(2,2)),
layers.Conv2D(64, kernel_size=(3,3), activation="relu"),
layers.MaxPooling2D(pool_size=(2,2)),
layers.Flatten(),
layers.Dropout(0.5),
layers.Dense(num_classes, activation="softmax"),
]
)
model.summary()
# train the model
batch_size = 128
epochs = 15
model.compile(loss="categorical_crossentropy", optimizer = "adam", metrics=["accuracy"])
model.fit(x_train, y_train, batch_size = batch_size, epochs=epochs, validation_split=0.1)
# Evaluation
def __init__(self,
width,
height,
dim_action,
gamma=0.9,
load_name=None,
use_prior=False,
use_image=False):
# tf.enable_eager_execution()
self.width = width
self.height = height
# tf.logging.set_verbosity(tf.logging.ERROR)
self.priority = use_prior
if use_image:
self.state_space = (self.height, self.width, 1)
else:
self.state_space = (5, )
self.action_space = dim_action
self.use_image = use_image
self.gamma = gamma
self.memory = ReplayMemory(10000)
# self.priority_memory = PrioritizedReplayBuffer(10000,0.5)
self.epsilon = EPS_START
# self.pesos = np.ones(BATCH_SIZE, dtype=np.float32)
# self.global_step = tfe.Variable(0)
# self.loss_avg = tfe.metrics.Mean()
self.mapeo = {
"%": 10,
"<": 30,
">": 30,
"v": 30,
"^": 30,
".": 150,
"G": 90,
" ": 1,
"o": 10
}
self.escala = 255
if self.use_image:
self.model = keras.Sequential([
keras.layers.Conv2D(32, (3, 3), input_shape=self.state_space),
keras.layers.BatchNormalization(),
keras.layers.Activation("relu"),
keras.layers.Conv2D(64, (3, 3), strides=[2, 2],
use_bias=False),
keras.layers.BatchNormalization(),
keras.layers.Activation("relu"),
keras.layers.Conv2D(64, (3, 3), use_bias=False),
keras.layers.BatchNormalization(),
keras.layers.Activation("relu"),
keras.layers.Flatten(),
keras.layers.Dense(7 * 7 * 64,
activation=tf.nn.tanh,
use_bias=False),
keras.layers.Dense(512, activation=tf.nn.tanh, use_bias=False),
# keras.layers.Dropout(rate=0.6),
keras.layers.Dense(self.action_space, activation="linear")
])
if not use_prior:
self.model.compile(loss=tf.compat.v1.losses.huber_loss,
optimizer=keras.optimizers.RMSprop(
learning_rate=0.0002, momentum=0.01))
else:
self.model = keras.Sequential([
# keras.layers.Dense(128, activation=tf.nn.tanh, use_bias=False, input_shape=(self.height * self.width,)),
keras.layers.Dense(32,
activation=tf.nn.tanh,
use_bias=False,
input_shape=self.state_space),
# keras.layers.Dropout(rate=0.6),
keras.layers.Dense(self.action_space, activation="linear")
])
self.model.compile(
loss=lambda y_t, y_pred: self.func(y_pred=y_pred, y_true=y_t),
optimizer=tf.train.RMSPropOptimizer(0.01))
if not use_prior:
self.model.compile(loss="mse",
optimizer=tf.train.RMSPropOptimizer(0.01))
if load_name is not None:
self.model = keras.models.load_model(load_name)
## Inference
An important feature of the
[preprocessing layers provided by Keras](https://keras.io/guides/preprocessing_layers/)
is that they can be included inside a `tf.keras.Model`. We will export an inference model
by including the `text_vectorization` layer on top of `shallow_mlp_model`. This will
allow our inference model to directly operate on raw strings.
**Note** that during training it is always preferable to use these preprocessing
layers as a part of the data input pipeline rather than the model to avoid
surfacing bottlenecks for the hardware accelerators. This also allows for
asynchronous data processing.
"""
# Create a model for inference.
model_for_inference = keras.Sequential([text_vectorizer, shallow_mlp_model])
# Create a small dataset just for demoing inference.
inference_dataset = make_dataset(test_df.sample(100), is_train=False)
text_batch, label_batch = next(iter(inference_dataset))
predicted_probabilities = model_for_inference.predict(text_batch)
# Perform inference.
for i, text in enumerate(text_batch[:5]):
label = label_batch[i].numpy()[None, ...]
print(f"Abstract: {text}")
print(f"Label(s): {invert_multi_hot(label[0])}")
predicted_proba = [proba for proba in predicted_probabilities[i]]
top_3_labels = [
x for _, x in sorted(
zip(predicted_probabilities[i], lookup.get_vocabulary()),
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
def print_title(title_sent):
print('\n', title_sent)
return
print_title('Sequential 모델을 사용하는 경우 예제')
# Define Sequential model with 3 layers
model = keras.Sequential(
[
layers.Dense(2, activation="relu", name="layer1"),
layers.Dense(3, activation="relu", name="layer2"),
layers.Dense(4, name="layer3"),
]
)
# Call model on a test input
x = tf.ones((3, 3))
y = model(x)
# 다음과 동일
# Create 3 layers
layer1 = layers.Dense(2, activation="relu", name="layer1")
layer2 = layers.Dense(3, activation="relu", name="layer2")
layer3 = layers.Dense(4, name="layer3")
# Call layers on a test input
x = tf.ones((3, 3))
y = layer3(layer2(layer1(x)))
def _createSimpleSequentialModel(self):
model = keras.Sequential()
model.add(keras.layers.Reshape([2, 3], input_shape=[6]))
model.add(keras.layers.LSTM(10))
model.add(keras.layers.Dense(1, activation='sigmoid'))
return model
projection_dim * 2,
projection_dim,
] # Size of the transformer layers
transformer_layers = 8
mlp_head_units = [2048,
1024] # Size of the dense layers of the final classifier
"""
## Use data augmentation
"""
data_augmentation = keras.Sequential(
[
layers.experimental.preprocessing.Normalization(),
layers.experimental.preprocessing.Resizing(image_size, image_size),
layers.experimental.preprocessing.RandomFlip("horizontal"),
layers.experimental.preprocessing.RandomRotation(factor=0.02),
layers.experimental.preprocessing.RandomZoom(height_factor=0.2,
width_factor=0.2),
],
name="data_augmentation",
)
# Compute the mean and the variance of the training data for normalization.
data_augmentation.layers[0].adapt(x_train)
"""
## Implement multilayer perceptron (MLP)
"""
def mlp(x, hidden_units, dropout_rate):
for units in hidden_units:
x = layers.Dense(units, activation=tf.nn.gelu)(x)
def _createNestedSequentialModel(self):
model = keras.Sequential()
model.add(keras.layers.Dense(6, input_shape=[10], activation='relu'))
model.add(self._createSimpleSequentialModel())
return model
test_images, test_labels = data.train.next_batch(10000)
train_images = np.array([i.reshape(28, 28) for i in train_images])
test_images = np.array([i.reshape(28, 28) for i in test_images])
#For each clothing object, the name is going to be assosciated with its index
#I.e. if the model returns 3 we know it's dress
class_names = [
'T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt',
'Sneaker', 'Bag', 'Ankle boot'
]
#Creates the model, first flattens all inputs from matrices to arrays, then adds two layers to the NN
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation=tf.nn.relu),
keras.layers.Dense(10, activation=tf.nn.softmax)
])
print("shape of the training data", train_images.shape)
#Compiles the model so it can be used, loss is the function used to determine the accuracy while training
#Metrics is what's monitored during the training
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
#Train the model with the given images and their respective tags
#Epochs: number of times data passed through the neural network
model.fit(train_images, train_labels, epochs=5, verbose=0)
plt.show()
cpu_utilization_values = cpu_utilization.value.to_list()
# print(cpu_utilization_values)
normalized_cpu_utilization_values, training_mean, training_std = normalize(cpu_utilization_values)
x_train = create_sequences(normalized_cpu_utilization_values, time_steps=32)
print("Training data shape: ", x_train.shape)
# Conv1D based auto-encoder model.
model = keras.Sequential([layers.Input(shape=(x_train.shape[1], x_train.shape[2])),
layers.Conv1D(filters=18, kernel_size=7, padding="same", strides=2, activation="relu"),
layers.Dropout(rate=0.2),
layers.Conv1D(filters=9, kernel_size=7, padding="same", strides=2, activation="relu"),
layers.Conv1DTranspose(filters=9, kernel_size=7, padding="same", strides=2,
activation="relu"),
layers.Dropout(rate=0.2),
layers.Conv1DTranspose(filters=18, kernel_size=7, padding="same", strides=2,
activation="relu"),
layers.Conv1DTranspose(filters=1, kernel_size=7, padding="same")])
model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001), loss="mse")
model.summary()
history = model.fit(x_train, x_train, epochs=50, batch_size=128, validation_split=0.1,
callbacks=[keras.callbacks.EarlyStopping(monitor="val_loss", patience=5, mode="min")])
# Plotting the training and validation losses.
plt.figure(figsize=(15, 7))
plt.plot(history.history["loss"], label="Training Loss")
plt.plot(history.history["val_loss"], label="Validation Loss")
plt.legend()
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
# Data Augmentation
data_augmentation = keras.Sequential([
layers.experimental.preprocessing.RandomFlip("horizontal",
input_shape=(img_height,
img_width, 3)),
layers.experimental.preprocessing.RandomRotation(0.1),
layers.experimental.preprocessing.RandomZoom(0.1),
])
plt.figure(figsize=(10, 10))
for images, _ in train_ds.take(1):
for i in range(9):
augmented_images = data_augmentation(images)
ax = plt.subplot(3, 3, i + 1)
plt.imshow(augmented_images[0].numpy().astype("uint8"))
plt.axis("off")
plt.show()
sunflower_url = "https://storage.googleapis.com/download.tensorflow.org/example_images/592px-Red_sunflower.jpg"
sunflower_path = tf.keras.utils.get_file('Red_sunflower', origin=sunflower_url)
# indices = [3, 40, 600, 800]
# class_names = ['Tshirt', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Boot']
# for i in indices:
# image = train_images[i]
# image = np.array(image, dtype='float')
# pixels = image.reshape((28, 28))
# im = Image.fromarray(pixels).convert("L")
# im.save("images/" + str(class_names[train_labels[i]]) + str(i) + ".jpeg")
train_labels = tf.one_hot(train_labels, 10)
test_labels = tf.one_hot(test_labels, 10)
model = keras.Sequential([
keras.layers.Reshape((28, 28, 1), input_shape=(28, 28)),
keras.layers.Conv2D(8, (3, 3), activation=tf.nn.relu),
keras.layers.Flatten(input_shape=()),
keras.layers.Dense(128, activation=tf.nn.relu),
keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=20, steps_per_epoch=10)
test_loss, test_acc = model.evaluate(test_images, test_labels, steps=10)
print('Test accuracy:', test_acc)
from tensorflow.keras import layers
# https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz下载解压到C:\Users\codewj\.keras\datasets\cifar-10-batches-py
cifar = keras.datasets.cifar10 # 10分类
(train_image, train_label), (test_image, test_label) = cifar.load_data()
print(
train_image.shape,
test_image.shape,
) # (50000, 32, 32, 3) (10000, 32, 32, 3)
print(train_label)
# 归一化处理
train_image = train_image / 255
test_image = test_image / 255
model = keras.Sequential()
model.add(layers.Conv2D(64, (3, 3), activation='relu',
input_shape=(32, 32, 3)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D())
model.add(layers.Dropout(0.25))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
"""
BatchNormalization:
将该层特征值分布重新拉回标准正态分布，特征值将落在激活函数对于输入较为敏感的区间，输入的小变化可导致损失函数较大的变化，使得梯度变大，避免梯度消失，同时也可加快收敛。
需要计算均值与方差，不适合动态网络或者RNN。计算均值方差依赖每批次，因此数据最好足够打乱
"""
model.add(layers.BatchNormalization())
# train_images = train_images[:1000].reshape(-1, 28, 28, 1) / 255.0 #.reshape(-1, 28 * 28, 1) / 255.0
# test_images = test_images[:1000].reshape(-1, 28, 28, 1) / 255.0 #.reshape(-1, 28 * 28, 1) / 255.0
print('...creating model...')
model = keras.Sequential([
keras.layers.Conv2D(32,
kernel_size=(5, 5),
strides=(1, 1),
activation='relu',
input_shape=(TestImageGen.size_th,
TestImageGen.size_th, 1),
name='Conv2D_first'),
keras.layers.MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
name='Pooler_first'),
keras.layers.Dropout(0.1, noise_shape=None, seed=None, name='Dropper_one'),
keras.layers.Conv2D(64, (5, 5), activation='relu', name='Conv2D_second'),
keras.layers.MaxPooling2D(pool_size=(2, 2), name='Pooler_second'),
keras.layers.Dropout(0.1, noise_shape=None, seed=None, name='Dropper_two'),
keras.layers.Flatten(name='Flattener'),
keras.layers.Dense(1000, activation='relu', name='Dense_Relu'),
keras.layers.Dense(TestImageGen.num_classes,
activation='softmax',
name='Dense_Softmax')
])
model.compile(optimizer=tf.train.AdamOptimizer(),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
from tensorflow import keras import numpy as np ''' This NN learns simple relationships between two series of numbers. In this case, the second series of numbers is always three times the first. This relationship is recognized so that new inputs (to_predict) can be predicted based on the model. ''' model = keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])]) model.compile(optimizer='sgd', loss='mean_squared_error') xs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] ys = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30] model.fit(xs, ys, epochs=4000) to_predict = 50 result = model.predict([to_predict]) rounded_result = np.round(result[0][0], 2) print(50 * '-') print(rounded_result)
test_images = test_images / 255.0
plt.figure(figsize=(10, 10))
for i in range(25):
plt.subplot(5, 5, i + 1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(train_images[i], cmap=plt.cm.binary)
plt.xlabel(class_names[train_labels[i]])
plt.show()
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=10)
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print('\nTest accuracy:', test_acc)
predictions = model.predict(test_images)
print("encoder.decode(train_example)", encoder.decode(train_example))
BUFFER_SIZE = 1000
train_batches = (train_data.shuffle(BUFFER_SIZE).padded_batch(
32, train_data.output_shapes))
test_batches = (test_data.padded_batch(32, train_data.output_shapes))
for example_batch, label_batch in train_batches.take(2):
print("Batch shape:", example_batch.shape)
print("label shape:", label_batch.shape)
model = keras.Sequential([
keras.layers.Embedding(encoder.vocab_size, 16),
keras.layers.GlobalAveragePooling1D(),
keras.layers.Dense(1, activation='sigmoid')
])
model.summary()
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
history = model.fit(train_batches,
epochs=10,
validation_data=test_batches,
validation_steps=30)
loss, accuracy = model.evaluate(test_batches)
batch_graph = tfg.BatchGraph.from_graphs(batch_graph_list)
# print("num_nodes: ", batch_graph.num_nodes)
yield batch_graph
if not infinite:
break
batch_size = 100
drop_rate = 0.2
gin0 = tfg.layers.GIN(100, activation=tf.nn.relu)
gin1 = tfg.layers.GIN(100, activation=tf.nn.relu)
mlp = keras.Sequential([
keras.layers.Dense(50),
keras.layers.Dropout(drop_rate),
keras.layers.Dense(num_classes)
])
# dense = keras.layers.Dense(num_classes)
def forward(batch_graph, training=False, pooling="sum"):
# GCN Encoder
h = gin0([batch_graph.x, batch_graph.edge_index, batch_graph.edge_weight])
h = gin1([h, batch_graph.edge_index, batch_graph.edge_weight])
# Pooling
if pooling == "mean":
h = tfg.nn.mean_pool(h, batch_graph.node_graph_index)
elif pooling == "sum":
h = tfg.nn.mean_pool(h, batch_graph.node_graph_index)
results = np.zeros((len(sequences), dimension))
for i, word_indices in enumerate(sequences):
results[i, word_indices] = 1
return results
train_data = multi_hot_sequences(train_data, NUM_WORDS)
test_data = multi_hot_sequences(test_data, NUM_WORDS)
plt.plot(train_data[0])
# %%
baseline_model = keras.Sequential([
# `input_shape` is only required here so that `.summary` works.
keras.layers.Dense(16, activation=tf.nn.relu, input_shape=(NUM_WORDS,)),
keras.layers.Dense(16, activation=tf.nn.relu),
keras.layers.Dense(1, activation=tf.nn.sigmoid)
])
baseline_model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy', 'binary_crossentropy'])
baseline_model.summary()
baseline_history = baseline_model.fit(train_data,
train_labels,
epochs=20,
batch_size=512,
validation_data=(test_data, test_labels),
verbose=2)
# keras.layers.Conv2D(64, (3,3), activation='relu'),
# keras.layers.MaxPooling2D(2,2),
# keras.layers.Flatten(),
# keras.layers.Dropout(0.5),
# keras.layers.Dense(2048, activation='relu'),
# keras.layers.Dense(2, activation="softmax")
# ])
model = keras.Sequential([
keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=shape),
keras.layers.MaxPooling2D(),
keras.layers.Conv2D(128, (3,3), activation='relu'),
keras.layers.MaxPooling2D(),
keras.layers.Conv2D(192, (3,3), activation='relu'),
keras.layers.MaxPooling2D(),
keras.layers.Conv2D(256, (3,3), activation='relu'),
keras.layers.MaxPooling2D(),
keras.layers.Flatten(),
keras.layers.Dropout(0.5),
keras.layers.Dense(1024, activation='relu'),
keras.layers.Dense(1024, activation='relu'),
keras.layers.Dense(2, activation="softmax")
])
filepath = "saved-model.h5"
#model.summary()
#model.compile(optimizer='adam', loss="sparse_categorical_crossentropy", metrics=['accuracy'])
#model.fit_generator(datagen.flow(train_images,train_labels,shuffle=True),epochs=30,validation_data=(test_images,test_labels),callbacks = [keras.callbacks.EarlyStopping(patience=8,verbose=1,restore_best_weights=True),keras.callbacks.ReduceLROnPlateau(factor=0.5,patience=3,verbose=1),keras.callbacks.ModelCheckpoint(filepath, monitor='val_loss', verbose=0, save_best_only=False, save_weights_only=False, mode='auto', period=1)])
chara_model = keras.models.load_model('saved-model.h5')
chara_model.compile(optimizer='adam', loss="sparse_categorical_crossentropy", metrics=['accuracy'])
