Untitled

# -*- coding: utf-8 -*-
"""Untitled0.ipynb

Automatically generated by Colaboratory.

Original file is located at
    https://colab.research.google.com/drive/173DAOLC4qtF-AwGc_T59qgbYsbivco8C
"""

#otworzymy archiwum do katalogu tmp
import os
import zipfile

local_zip = 'C:/Users/Pepsi/Downloads/cats_and_dogs_face.zip'
zip_ref = zipfile.ZipFile(local_zip, 'r')
zip_ref.extractall('tmp')
zip_ref.close()


#bazowy katalog:
base_dir = 'tmp/cats_and_dogs_filtered'
#katolog ze zbiorem treningowym:
train_dir = os.path.join(base_dir, 'train')
#katolog ze zbiorem walidacyjnym:
validation_dir = os.path.join(base_dir, 'validation')

#katalog ze zbiorem trenognowym zdjęć kotów
train_cats_dir = os.path.join(train_dir, 'cats')

#katalog ze zbiorem trenognowym zdjęć psów
train_dogs_dir = os.path.join(train_dir, 'dogs')

#katalog ze zbiorem trenognowym zdjęć psów
train_face_dir = os.path.join(train_dir, 'face')

#katalog ze zbiorem walidacyjnym zdjęć kotów
validation_cats_dir = os.path.join(validation_dir, 'cats')

#katalog ze zbiorem walidacyjnym zdjęć psów
validation_dogs_dir = os.path.join(validation_dir, 'dogs')

#katalog ze zbiorem walidacyjnym zdjęć psów
validation_face_dir = os.path.join(validation_dir, 'face')

#test: czy katalogi zawietają odpowiednie zdjęcia? sprawdzenie nazw
train_cat_fnames = os.listdir(train_cats_dir)
print(train_cat_fnames[:10])

train_dog_fnames = os.listdir(train_dogs_dir)
train_dog_fnames.sort()
print(train_dog_fnames[:10])

train_face_fnames = os.listdir(train_face_dir)
train_face_fnames.sort()
print(train_face_fnames[:10])

#sprawdzenie liczby plików w katalogach
print('total training cat images:', len(os.listdir(train_cats_dir)))
print('total training dog images:', len(os.listdir(train_dogs_dir)))
print('total training face images:', len(os.listdir(train_face_dir)))
print('total validation cat images:', len(os.listdir(validation_cats_dir)))
print('total validation dog images:', len(os.listdir(validation_dogs_dir)))
print('total validation face images:', len(os.listdir(validation_face_dir)))

# Commented out IPython magic to ensure Python compatibility.
#wyświetlnie przykładowych 16 zdjęć ze zbioru treningowego
# %matplotlib inline

import matplotlib.pyplot as plt
import matplotlib.image as mpimg

#Liczba wierszy i kolumn
nrows = 4
ncols = 8

#indeks do pętli
pic_index = 0

#ustawienia matplotlib fig, ramka o wymiarze 4x4
fig = plt.gcf()
fig.set_size_inches(ncols * 4, nrows * 4)

pic_index += 8
next_cat_pix = [os.path.join(train_cats_dir, fname) 
                for fname in train_cat_fnames[pic_index-8:pic_index]]
next_dog_pix = [os.path.join(train_dogs_dir, fname) 
                for fname in train_dog_fnames[pic_index-8:pic_index]]
next_face_pix = [os.path.join(train_face_dir, fname) 
                for fname in train_face_fnames[pic_index-8:pic_index]]

for i, img_path in enumerate(next_cat_pix+next_dog_pix+next_face_pix):
  #przejście pętlą po obrazach
  sp = plt.subplot(nrows, ncols, i + 1)
  sp.axis('Off') #nie pokazuj osi

  img = mpimg.imread(img_path)
  plt.imshow(img)

plt.show()

from tensorflow.keras import layers
from tensorflow.keras import Model
from tensorflow.keras.applications.vgg16 import VGG16
from tensorflow.keras.optimizers import Adam

# define cnn model
def define_model():
	# load model
	model = VGG16(include_top=False, input_shape=(150, 150, 3))
	# mark loaded layers as not trainable
	for layer in model.layers:
		layer.trainable = False
	# add new classifier layers
	flat1 = layers.Flatten()(model.layers[-1].output)
	class1 = layers.Dense(128, activation='relu')(flat1)
	output = layers.Dense(3, activation='softmax')(class1)
	# define new model
	model = Model(inputs=model.inputs, outputs=output)
	# compile model
	#opt = SGD(lr=0.001, momentum=0.9)
	opt = Adam(lr=0.01)
	model.compile(optimizer=opt, loss='binary_crossentropy', metrics=['accuracy'])
	return model

model = define_model()
#wyświetlnie podsumowania modelu
model.summary()

from tensorflow.keras.preprocessing.image import ImageDataGenerator

# skalowanie wartości pikseli obrazka poprzez podzielenie ich przez 255
train_datagen = ImageDataGenerator(rescale=1./255)
val_datagen = ImageDataGenerator(rescale=1./255)

# wykonanie zbioru treningowego na podstawie zdjęć z katalogu
train_generator = train_datagen.flow_from_directory(
        train_dir,  # katalog ze zdjęciami
        target_size=(150, 150),  # wszystkie obrazki będą zeskalowane do rozmiaru 150x150
        batch_size=20, #rozmiar batcha
        shuffle=True,
        # ponieważ używamy binarycrossentropy, używamy binarnych etykiet klas
        class_mode='categorical')

# wykonanie zbioru walidacyjnego na podstawie zdjęć z katalogu
validation_generator = val_datagen.flow_from_directory(
        validation_dir,
        target_size=(150, 150),
        shuffle=True,
        batch_size=20,
        class_mode='categorical')

#uruchomienie treningu, 15 epok po 100 kroków na epokę
history = model.fit_generator(
      train_generator,
      steps_per_epoch=120,  # 2000 images = batch_size * steps
      epochs=15,
      validation_data=validation_generator,
      validation_steps=62,  # 1000 images = batch_size * steps
      verbose=True)

import numpy as np
import random
from tensorflow.keras.preprocessing.image import img_to_array, load_img

# Wyświetlenie wyników z poszczególnych warstw dla losowego obrazka
successive_outputs = [layer.output for layer in model.layers[1:]]
visualization_model = Model(model.inputs[0], successive_outputs)

# pobranie losowego obrazka
cat_img_files = [os.path.join(train_cats_dir, f) for f in train_cat_fnames]
dog_img_files = [os.path.join(train_dogs_dir, f) for f in train_dog_fnames]
face_img_files = [os.path.join(train_fece_dir, f) for f in train_face_fnames]
img_path = random.choice(cat_img_files + dog_img_files + face_img_files)

img = load_img(img_path, target_size=(150, 150))  # obrazek wygenerowany prz klasę PIL
x = img_to_array(img)  # przerobienie na numpy o rozmiarze 150x150x3
x = x.reshape((1,) + x.shape)  # dodanie dodatkowego wymiaru na początku (1, 150, 150, 3)

# przeskalowanie do 1/255
x /= 255

# dokonanie predykcji na 
successive_feature_maps = visualization_model.predict(x)

# These are the names of the layers, so can have them as part of our plot
layer_names = [layer.name for layer in model.layers[1:]]

# Now let's display our representations
for layer_name, feature_map in zip(layer_names, successive_feature_maps):
  if len(feature_map.shape) == 4:
    # Just do this for the conv / maxpool layers, not the fully-connected layers
    n_features = feature_map.shape[-1]  # number of features in feature map
    # mapa cech ma rozmiar (1, size, size, n_features)
    size = feature_map.shape[1]
    # We will tile our images in this matrix
    display_grid = np.zeros((size, size * n_features))
    for i in range(n_features):
      # przeskalowanie obrazków do 0-255, aby można je było wyświetlić
      x = feature_map[0, :, :, i]
      x -= x.mean()
      x /= x.std()
      x *= 64
      x += 128
      x = np.clip(x, 0, 255).astype('uint8')
      # wynik każdego filtru idzie do poprzecznej siatki
      display_grid[:, i * size : (i + 1) * size] = x
    # wyświetl jedną warstwę
    scale = 20. / n_features
    plt.figure(figsize=(scale * n_features, scale))
    plt.title(layer_name)
    plt.grid(False)
    plt.imshow(display_grid, aspect='auto', cmap='viridis')

# pobranie acc dla treningowego i walidacyjnego zbioru danych
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']

# pobranie loss dla treningowego i walidacyjnego zbioru danych
loss = history.history['loss']
val_loss = history.history['val_loss']

# liczba epok
epochs = range(len(acc))

# wykres dokładności dla zbioru treningowego i walidacyjnego
plt.plot(epochs, acc)
plt.plot(epochs, val_acc)
plt.title('Training and validation accuracy')

plt.figure()

# wykres loss dla zbioru treningowego i walidacyjnego
plt.plot(epochs, loss)
plt.plot(epochs, val_loss)
plt.title('Training and validation loss')