TensorFlow - zastosowanie w aplikacjach mobilnych

import tensorflow as tf from tensorflow import keras import numpy as np import matplotlib.pyplot as plt import random print(tf.__version__)

mnist = keras.datasets.mnist (train_images, train_labels), (test_images, test_labels) = mnist.load_data()

plt.figure(figsize=(10,10)) plt.subplot(5,5,1) plt.xticks([]) plt.yticks([]) plt.grid(False) plt.imshow(train_images[1], cmap=plt.cm.gray) plt.xlabel(train_labels[1]) plt.show() print(train_images[1])

train_images = train_images / 255.0 test_images = test_images / 255.0

print(train_images[1])

size = 28 model = keras.Sequential([ keras.layers.InputLayer(input_shape=(size, size)), keras.layers.Reshape(target_shape=(size, size, 1)), keras.layers.Conv2D(filters=32, kernel_size=(3, 3), activation=tf.nn.relu), keras.layers.Conv2D(filters=64, kernel_size=(3, 3), activation=tf.nn.relu), keras.layers.MaxPooling2D(pool_size=(2, 2)), keras.layers.Dropout(0.25), keras.layers.Flatten(), keras.layers.Dense(10) ]) # Ustawienie parametrów testowania model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy']) # Rozpoczęcie uczenia na zbiorze treningowym model.fit(train_images, train_labels, epochs=5)

test_loss, test_acc = model.evaluate(test_images, test_labels) print('Test accuracy:', test_acc)

converter = tf.lite.TFLiteConverter.from_keras_model(model) tflite_float_model = converter.convert() float_model_size = len(tflite_float_model) / 1024 print('Float model size = %dKBs.' % float_model_size)

with open('mnist.tflite', 'wb') as f: f.write(tflite_float_model)

converter.optimizations = [tf.lite.Optimize.DEFAULT] new_model = converter.convert() new_model_size = len(new_model) / 1024 print('New model size = %dKBs,' % new_model_size) print('which is about %d%% of the float model size.'\ % (new_model_size * 100 / float_model_size))

with open('mnist_new.tflite', 'wb') as f: f.write(tflite_float_model)

import matplotlib.pyplot as plt import numpy as np import os import PIL import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.models import Sequential

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

image_count = len(list(data_dir.glob('*/*.jpg'))) print(image_count)

print("Róże") roses = list(data_dir.glob('roses/*')) PIL.Image.open(str(roses[3]))

PIL.Image.open(str(roses[1]))

print("Tulipany") tulips = list(data_dir.glob('tulips/*')) PIL.Image.open(str(tulips[0]))

PIL.Image.open(str(tulips[1]))

batch_size = 32 img_height = 180 img_width = 180

train_ds = tf.keras.utils.image_dataset_from_directory( data_dir, validation_split=0.2, subset="training", seed=123, image_size=(img_height, img_width), batch_size=batch_size)

test_ds = tf.keras.utils.image_dataset_from_directory( data_dir, validation_split=0.2, subset="validation", seed=123, image_size=(img_height, img_width), batch_size=batch_size)

class_names = train_ds.class_names print(class_names)

import matplotlib.pyplot as plt plt.figure(figsize=(10, 10)) for images, labels in train_ds.take(1): for i in range(9): ax = plt.subplot(3, 3, i + 1) plt.imshow(images[i].numpy().astype("uint8")) plt.title(class_names[labels[i]]) plt.axis("off")

for image_batch, labels_batch in train_ds: print(image_batch.shape) print(labels_batch.shape) break

AUTOTUNE = tf.data.AUTOTUNE train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE) test_ds = test_ds.cache().prefetch(buffer_size=AUTOTUNE)

normalization_layer = layers.Rescaling(1./255) normalized_ds = train_ds.map(lambda x, y: (normalization_layer(x), y)) image_batch, labels_batch = next(iter(normalized_ds)) first_image = image_batch[0] # Notice the pixel values are now in `[0,1]`. print(np.min(first_image), np.max(first_image))

num_classes = len(class_names) #Tworzenie modelu model = Sequential([ layers.Rescaling(1./255, input_shape=(img_height, img_width, 3)), layers.Conv2D(16, 3, padding='same', activation='relu'), layers.MaxPooling2D(), layers.Conv2D(32, 3, padding='same', activation='relu'), layers.MaxPooling2D(), layers.Conv2D(64, 3, padding='same', activation='relu'), layers.MaxPooling2D(), layers.Flatten(), layers.Dense(128, activation='relu'), layers.Dense(num_classes) ]) #Skompilowanie modelu model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy']) #Podsumowanie wszystkich wart sieci model.summary()

epochs=10 history = model.fit( train_ds, validation_data=test_ds, epochs=epochs )

acc = history.history['accuracy'] val_acc = history.history['val_accuracy'] loss = history.history['loss'] val_loss = history.history['val_loss'] epochs_range = range(epochs) plt.figure(figsize=(8, 8)) plt.subplot(1, 2, 1) 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 = keras.Sequential( [ layers.RandomFlip("horizontal", input_shape=(img_height, img_width, 3)), layers.RandomRotation(0.1), layers.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")

model = Sequential([ data_augmentation, layers.Rescaling(1./255), layers.Conv2D(16, 3, padding='same', activation='relu'), layers.MaxPooling2D(), layers.Conv2D(32, 3, padding='same', activation='relu'), layers.MaxPooling2D(), layers.Conv2D(64, 3, padding='same', activation='relu'), layers.MaxPooling2D(), layers.Dropout(0.2), layers.Flatten(), layers.Dense(128, activation='relu'), layers.Dense(num_classes) ])

model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy'])

model.summary()

epochs = 12 history = model.fit( train_ds, validation_data=test_ds, epochs=epochs )

acc = history.history['accuracy'] val_acc = history.history['val_accuracy'] loss = history.history['loss'] val_loss = history.history['val_loss'] epochs_range = range(epochs) plt.figure(figsize=(8, 8)) plt.subplot(1, 2, 1) 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()

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) img = tf.keras.utils.load_img( sunflower_path, target_size=(img_height, img_width) ) img_array = tf.keras.utils.img_to_array(img) img_array = tf.expand_dims(img_array, 0) # Create a batch predictions = model.predict(img_array) score = tf.nn.softmax(predictions[0]) print( "This image most likely belongs to {} with a {:.2f} percent confidence." .format(class_names[np.argmax(score)], 100 * np.max(score)) )

converter = tf.lite.TFLiteConverter.from_keras_model(model) tflite_model = converter.convert()

with open('model.tflite', 'wb') as f: f.write(tflite_model)