Load and preprocess images in Tensorflow Keras

В этом посте показано, как загрузить и предварительно обработать набор данных изображения тремя способами: Во-первых, вы будете использовать высокоуровневые утилиты предварительной обработки Keras (такие как tf.keras.utils.image_dataset_from_directory) и слои (такие как tf.keras.layers.Rescaling) для чтения каталога изображений на диске. Далее вы напишете свой собственный конвейер ввода с нуля, используя tf.data. Наконец, вы загрузите набор данных из большого каталога, доступного в наборах данных TensorFlow.

Code 1

(.env) [boris@fedora34server FLOWERS]$ cat tulipTensor2.py

import numpy as np

import os

import PIL

import PIL.Image

import tensorflow as tf

import tensorflow_datasets as tfds

# print(tf.__version__)

import pathlib

dataset_url = "https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz"

data_dir = tf.keras.utils.get_file(origin=dataset_url,fname='flower_photos', untar=True)

data_dir = pathlib.Path(data_dir)

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

print(image_count)

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)

print(train_ds)

val_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)

print(val_ds)

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")

# Стандартизируйте данные

# Значения канала RGB находятся в диапазоне [0, 255]. Это не идеально для нейронной сети; 

# в общем, вы должны стремиться к тому, чтобы ваши входные значения были небольшими.

# Здесь вы стандартизируете значения в диапазоне [0, 1] с помощью tf.keras.layers.Rescaling:

normalization_layer = tf.keras.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))

# Dataset.cache хранит изображения в памяти после их загрузки с диска в течение первой эпохи. 

# Это гарантирует, что набор данных не станет узким местом при обучении вашей модели. 

# Если ваш набор данных слишком велик, чтобы поместиться в память, вы также можете 

# использовать 

# этот метод для создания производительного кэша на диске.

# Dataset.prefetch перекрывает предварительную обработку данных и выполнение 

# модели во время обучения.

AUTOTUNE = tf.data.AUTOTUNE

train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)

val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

num_classes = 5

model = tf.keras.Sequential([

  tf.keras.layers.Rescaling(1./255),

  tf.keras.layers.Conv2D(32, 3, activation='relu'),

  tf.keras.layers.MaxPooling2D(),

  tf.keras.layers.Conv2D(32, 3, activation='relu'),

  tf.keras.layers.MaxPooling2D(),

  tf.keras.layers.Conv2D(32, 3, activation='relu'),

  tf.keras.layers.MaxPooling2D(),

  tf.keras.layers.Flatten(),

  tf.keras.layers.Dense(128, activation='relu'),

  tf.keras.layers.Dense(num_classes)

])

# Выберите оптимизатор tf.keras.optimizers.Adam и функцию потерь 

# tf.keras.losses.SparseCategoricalCrossentropy. Чтобы просмотреть 

# точность обучения и проверки для каждой эпохи обучения, 

# передайте аргумент метрики в Model.compile

model.compile(

  optimizer='adam',

  loss=tf.losses.SparseCategoricalCrossentropy(from_logits=True),

  metrics=['accuracy'])

model.fit(train_ds,validation_data=val_ds, epochs=3)

# Использование tf.data для более тонкого контроля

# Для более точного управления вы можете написать свой 

# собственный входной конвейер,

# используя tf.data. В этом разделе показано, как это сделать, 

# начиная с путей к файлам из загруженного ранее файла TGZ.

list_ds = tf.data.Dataset.list_files(str(data_dir/'*/*'), shuffle=False)

list_ds = list_ds.shuffle(image_count, reshuffle_each_iteration=False)

for f in list_ds.take(5):

  print(f.numpy())

class_names = np.array(sorted([item.name for item in data_dir.glob('*') if item.name != "LICENSE.txt"]))

print(class_names)

val_size = int(image_count * 0.2)

train_ds = list_ds.skip(val_size)

val_ds = list_ds.take(val_size)

print(tf.data.experimental.cardinality(train_ds).numpy())

print(tf.data.experimental.cardinality(val_ds).numpy())

def get_label(file_path):

  # Convert the path to a list of path components

  parts = tf.strings.split(file_path, os.path.sep)

  # The second to last is the class-directory

  one_hot = parts[-2] == class_names

  # Integer encode the label

  return tf.argmax(one_hot)

def decode_img(img):

  # Convert the compressed string to a 3D uint8 tensor

  img = tf.io.decode_jpeg(img, channels=3)

  # Resize the image to the desired size

  return tf.image.resize(img, [img_height, img_width])

def process_path(file_path):

  label = get_label(file_path)

  # Load the raw data from the file as a string

  img = tf.io.read_file(file_path)

  img = decode_img(img)

  return img, label

# Используйте Dataset.map для создания набора данных пар изображений и меток

# Set `num_parallel_calls` so multiple images are loaded/processed in parallel.

train_ds = train_ds.map(process_path, num_parallel_calls=AUTOTUNE)

val_ds = val_ds.map(process_path, num_parallel_calls=AUTOTUNE)

for image, label in train_ds.take(1):

  print("Image shape: ", image.numpy().shape)

  print("Label: ", label.numpy())

# Чтобы обучить модель с этим набором данных, вам понадобятся данные:

# Чтобы хорошо перетасовать.Для пакетирования.

# Партии должны быть доступны как можно скорее.

# Эти функции можно добавить с помощью API tf.data.

def configure_for_performance(ds):

  ds = ds.cache()

  ds = ds.shuffle(buffer_size=1000)

  ds = ds.batch(batch_size)

  ds = ds.prefetch(buffer_size=AUTOTUNE)

  return ds

train_ds = configure_for_performance(train_ds)

val_ds = configure_for_performance(val_ds)

image_batch, label_batch = next(iter(train_ds))

plt.figure(figsize=(10, 10))

for i in range(9):

  ax = plt.subplot(3, 3, i + 1)

  plt.imshow(image_batch[i].numpy().astype("uint8"))

  label = label_batch[i]

  plt.title(class_names[label])

  plt.axis("off")

  # plt.show()

# Теперь вы вручную создали набор tf.data.Dataset, аналогичный тому, который 

# был создан с помощью tf.keras.utils.image_dataset_from_directory выше. 

# С ним вы можете продолжить обучение модели. Как и прежде, вы будете 

# тренироваться всего несколько эпох, чтобы сократить время бега.

model.fit(

  train_ds,

  validation_data=val_ds,

  epochs=3

)

# Поскольку ранее вы загрузили набор данных Flowers с диска, 

# давайте теперь импортируем его с помощью наборов данных TensorFlow.

# Загрузите набор данных Flowers с помощью наборов данных TensorFlow.

(train_ds, val_ds, test_ds), metadata = tfds.load(

    'tf_flowers',

    split=['train[:80%]', 'train[80%:90%]', 'train[90%:]'],

    with_info=True,

    as_supervised=True,

)

num_classes = metadata.features['label'].num_classes

print(num_classes)

# Получить изображение из набора данных.

get_label_name = metadata.features['label'].int2str

image, label = next(iter(train_ds))

_ = plt.imshow(image)

_ = plt.title(get_label_name(label))

plt.show()

References

https://www.tensorflow.org/tutorials/load_data/images

Load NumPy data via tf.data API

 Code 1

(.env) [boris@fedora34server KERAS]$ cat tfdataLoad.py

import numpy as np

import tensorflow as tf

DATA_URL = 'https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz'

path = tf.keras.utils.get_file('mnist.npz', DATA_URL)

with np.load(path) as data:

  train_examples = data['x_train']

  train_labels = data['y_train']

  test_examples = data['x_test']

  test_labels = data['y_test']

train_dataset = tf.data.Dataset.from_tensor_slices((train_examples, train_labels))

test_dataset = tf.data.Dataset.from_tensor_slices((test_examples, test_labels))

BATCH_SIZE = 64 

SHUFFLE_BUFFER_SIZE = 100

train_dataset = train_dataset.shuffle(SHUFFLE_BUFFER_SIZE).batch(BATCH_SIZE)

test_dataset = test_dataset.batch(BATCH_SIZE)

model = tf.keras.Sequential([

    tf.keras.layers.Flatten(input_shape=(28, 28)),

    tf.keras.layers.Dense(128, activation='relu'),

    tf.keras.layers.Dense(10)

])

model.compile(optimizer=tf.keras.optimizers.RMSprop(),

              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),

              metrics=['sparse_categorical_accuracy'])

model.fit(train_dataset, epochs=15)

print(model.evaluate(test_dataset))

***************

Run Code 1

***************

Building MultiLayers neural network in keras with several outputs

Cтруктурирование любого проекта глубокого обучения.

Предварительная обработка и загрузка данных. Как мы уже говорили, данные являются ключом к работе нейронной сети, и нам необходимо обработать их перед подачей в нейронную сеть. На этом этапе мы также визуализируем данные, которые помогут нам получить представление о данных.

Определить модель. Теперь нам нужна модель нейронной сети. Это означает, что нам нужно указать количество скрытых слоев в нейронной сети и их размер, размер входа и выхода.

Потери и оптимизатор. Теперь нам нужно определить функцию потерь в соответствии с нашей задачей. Нам также необходимо указать оптимизатор для использования со скоростью обучения и другие гиперпараметры оптимизатора.

Подходящая модель — это этап обучения нейронной сети. Здесь нам нужно определить количество эпох, на которое нам нужно обучить нейронную сеть. 

После обучения модели мы можем протестировать ее на тестовых данных, чтобы проверить, нет ли случая переобучения. Мы можем сохранить веса модели и использовать их позже, когда это необходимо.

*********************************

model.add используется для добавления слоя в нашу нейронную сеть. Нам нужно указать в качестве аргумента, какой тип слоя мы хотим. Dense используется для указания полносвязного слоя. Аргументами Dense являются выходное измерение, которое равно 16 в первом случае, входное измерение, которое равно 20 для входного измерения, и используемая функция активации, которая в этом случае является relu. Второй и третий слои аналогичны, нам не нужно указывать входное измерение, поскольку мы определили модель как последовательную, поэтому keras автоматически будет считать входное измерение таким же, как и выходное значение последнего слоя, т.е. 16. В третьем слое (выходном слое) выходное измерение равно 4 (количество классов). Теперь, как мы обсуждали ранее, выходной слой принимает разные функции активации, и в случае многоклассовой классификации это softmax.

***********************************

train.csv загружен в Exсel

Code 1

(.env) [boris@fedora34server DATASET]$ cat trainKerasPlot.py

from tensorflow.keras.optimizers import Adam

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from sklearn.metrics import accuracy_score

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.preprocessing import OneHotEncoder

import matplotlib.pyplot as plt

import numpy as np

import pandas as pd

dataset = pd.read_csv('train.csv') #You need to change #directory accordingly

# Changing pandas dataframe to numpy array

X = dataset.iloc[:,:20].values

y = dataset.iloc[:,20:21].values

# Normalizing the data

sc = StandardScaler()

X = sc.fit_transform(X)

# Next step is to one hot encode the classes

ohe = OneHotEncoder()

y = ohe.fit_transform(y).toarray()

X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.1)

# Model layers

model = Sequential()

model.add(Dense(16, input_dim=20, activation='relu'))

model.add(Dense(12, activation='relu'))

model.add(Dense(4, activation='softmax'))

adam = Adam()

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])

y_pred = model.predict(X_test)

# Converting predictions to label

pred = list()

for i in range(len(y_pred)):

    pred.append(np.argmax(y_pred[i]))

# Converting one hot encoded test label to label

test = list()

for i in range(len(y_test)):

    test.append(np.argmax(y_test[i]))

a = accuracy_score(pred,test)

print('Accuracy is:', a*100)

history = model.fit(X_train, y_train,validation_data = (X_test,y_test), epochs=100, batch_size=64)

plt.figure(1)

plt.subplot(211)

plt.plot(history.history['acc'])

plt.plot(history.history['val_acc'])

plt.title('Model Accuracy')

plt.ylabel('Accuracy')

plt.xlabel('Epoch')

plt.legend(['Training', 'Validation'], loc='lower right')

plt.subplot(212)

plt.plot(history.history['loss'])

plt.plot(history.history['val_loss'])

plt.title('Model Loss')

plt.ylabel('Loss')

plt.xlabel('Epoch')

plt.legend(['Training', 'Validation'], loc='upper right')

plt.tight_layout()

plt.show()

References

https://towardsdatascience.com/building-our-first-neural-network-in-keras-bdc8abbc17f5

Building your first Neural Network in a couple lines of code like a Deep Learning in Python

 Code 1

(.env) [boris@fedora34server DATASET]$ cat makeAdamRegL2.py

from tensorflow.keras.layers import Dropout

from tensorflow.keras import regularizers

from tensorflow.keras.optimizers import Adam

from tensorflow.keras.optimizers import SGD

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from sklearn.model_selection import train_test_split

from sklearn import preprocessing

import pandas as pd

import matplotlib.pyplot as plt

df = pd.read_csv('housepricedata.csv')

# print(df)

dataset = df.values

X = dataset[:,0:10]

Y = dataset[:,10]

min_max_scaler = preprocessing.MinMaxScaler()

X_scale = min_max_scaler.fit_transform(X)

# print(X_scale)

# This tells scikit-learn that your val_and_test size will be 30% of the 

# overall dataset. The code will store the split data into the first four 

# variables on the left of the equal sign as the variable names suggest.

X_train, X_val_and_test, Y_train, Y_val_and_test = train_test_split(X_scale, Y, test_size=0.3)

# The code below will split the val_and_test size equally to the 

# validation set and the test set.

X_val, X_test, Y_val, Y_test = train_test_split(X_val_and_test, Y_val_and_test, test_size=0.5)

# print(X_train.shape, X_val.shape, X_test.shape, Y_train.shape, Y_val.shape, Y_test.shape)

model_3 = Sequential([

    Dense(1000, activation='relu', kernel_regularizer=regularizers.l2(0.01), input_shape=(10,)),

    Dropout(0.3),

    Dense(1000, activation='relu', kernel_regularizer=regularizers.l2(0.01)),

    Dropout(0.3),

    Dense(1000, activation='relu', kernel_regularizer=regularizers.l2(0.01)),

    Dropout(0.3),

    Dense(1000, activation='relu', kernel_regularizer=regularizers.l2(0.01)),

    Dropout(0.3),

    Dense(1, activation='sigmoid', kernel_regularizer=regularizers.l2(0.01)),

])

adam = Adam()

model_3.compile(optimizer='adam',

              loss='binary_crossentropy',

              metrics=['acc'])

hist_3 = model_3.fit(X_train, Y_train,

          batch_size=32, epochs=100,

          validation_data=(X_val, Y_val))

plt.figure(1)

plt.subplot(211)

plt.plot(hist_3.history['acc'])

plt.plot(hist_3.history['val_acc'])

plt.title('Model Accuracy')

plt.ylabel('Accuracy')

plt.xlabel('Epoch')

plt.legend(['Training', 'Validation'], loc='lower right')

# summarize history for loss

plt.subplot(212)

plt.plot(hist_3.history['loss'])

plt.plot(hist_3.history['val_loss'])

plt.title('Model Loss')

plt.ylabel('Loss')

plt.xlabel('Epoch')

plt.legend(['Training', 'Validation'], loc='upper right')

plt.tight_layout()

plt.show()

References

https://www.freecodecamp.org/news/how-to-build-your-first-neural-network-to-predict-house-prices-with-keras-f8db83049159/

https://www.codesofinterest.com/2020/01/fixing-keyerror-acc-valacc-keras.html

Random Forest Hyperparameters Python

Code 1

 (.env) [boris@fedora34server THREAD]$ cat randomForrestHyperv.py

# explore random forest bootstrap sample size on performance

from numpy import mean

from numpy import std

from numpy import arange

from sklearn.datasets import make_classification

from sklearn.model_selection import cross_val_score

from sklearn.model_selection import RepeatedStratifiedKFold

from sklearn.ensemble import RandomForestClassifier

from matplotlib import pyplot

# get the dataset

def get_dataset():

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=3)

return X, y

# get a list of models to evaluate

def get_models():

models = dict()

# explore ratios from 10% to 100% in 10% increments

for i in arange(0.1, 1.1, 0.1):

key = '%.1f' % i

# set max_samples=None to use 100%

if i == 1.0:

i = None

models[key] = RandomForestClassifier(max_samples=i)

return models

 

# evaluate a given model using cross-validation

def evaluate_model(model, X, y):

# define the evaluation procedure

cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)

# evaluate the model and collect the results

scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=4)

return scores

 

# define dataset

X, y = get_dataset()

# get the models to evaluate

models = get_models()

# evaluate the models and store results

results, names = list(), list()

for name, model in models.items():

# evaluate the model

scores = evaluate_model(model, X, y)

# store the results

results.append(scores)

names.append(name)

# summarize the performance along the way

print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))

# plot model performance for comparison

pyplot.boxplot(results, labels=names, showmeans=True)

pyplot.show(block=False)

Code 2

# explore random forest number of features effect on performance

from numpy import mean

from numpy import std

from sklearn.datasets import make_classification

from sklearn.model_selection import cross_val_score

from sklearn.model_selection import RepeatedStratifiedKFold

from sklearn.ensemble import RandomForestClassifier

from matplotlib import pyplot

 

# get the dataset

def get_dataset():

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=3)

return X, y

 

# get a list of models to evaluate

def get_models():

models = dict()

# explore number of features from 1 to 7

for i in range(1,8):

models[str(i)] = RandomForestClassifier(max_features=i)

return models

 

# evaluate a given model using cross-validation

def evaluate_model(model, X, y):

# define the evaluation procedure

cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)

# evaluate the model and collect the results

scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=4)

return scores

 

# define dataset

X, y = get_dataset()

# get the models to evaluate

models = get_models()

# evaluate the models and store results

results, names = list(), list()

for name, model in models.items():

# evaluate the model

scores = evaluate_model(model, X, y)

# store the results

results.append(scores)

names.append(name)

# summarize the performance along the way

print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))

# plot model performance for comparison

pyplot.boxplot(results, labels=names, showmeans=True)

pyplot.show(block=False)

Code 3

(.env) [boris@fedora34server THREAD]$ cat jobsMulti.py from sklearn.ensemble import RandomForestClassifier from sklearn.feature_selection import RFE from sklearn.pipeline import Pipeline from sklearn.preprocessing import StandardScaler from sklearn.datasets import make_classification X, y = make_classification(n_samples=1000, n_features=3200, n_informative=100, \

n_redundant=3100, n_classes=2, n_clusters_per_class=30) pipe = Pipeline([ ('slr', StandardScaler()), ('fs', RFE(RandomForestClassifier(n_estimators=1000, max_features='auto', \

class_weight='balanced', n_jobs=4), step=0.01, n_features_to_select=10)) ]) pipe.fit(X, y)

References

 https://machinelearningmastery.com/random-forest-ensemble-in-python/

 https://github.com/scikit-learn/scikit-learn/issues/12482