Long story short

Создают ли повороты ложные зависимости в датасете?

Небольшое исследование свойств rotate.

Представим себе, в существенно упрощенном виде, процесс скоринга.

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

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

Если банк использует только предсказание сети, то он прогорит, но об этом другая статья.

И представим для простоты, ~~что человеческое тело это шар~~ соискатель предоставляет просто матрицу W_SIZE x W_SIZE, ну или 128х128, например.
Почему бы и нет!

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

Мы возьмем матрицу w_size х w_size, заполненную случайно, мы же не знаем, что там, в реальности, и нам годятся все матрицы такого размера, и проверим, не поворачивал ли некто эту картинку(матрицу).

Т.е. будем решать максимально упрощенную задачу - в последовательности матриц/картинок будем искать те, что искусственно были повернуты. Ну и на такой же последовательности матриц будем и учить.

Использовать будем простую сеть на keras и обычные пакеты обработки, в которых есть функция "поворот"

Обычным способом грузим

import numpy as np
import cv2

from scipy import ndimage, misc, stats
from skimage import exposure

from matplotlib import pyplot as plt, colors
# work in interactive moode
%matplotlib inline 

from tensorflow import keras
from tensorflow.keras import layers

from math import sqrt, sin, cos, radians

import tqdm

Теперь создадим обучающую и тестовую последовательности. Создадим одну и поделим её пополам. Картинки/матрицы у нас будут такие - круг на черном фоне заполненный случайными значениями с заранее определенным распределением. При поворотах границы вносят существенные искажения, поэтому и берем круг в квадрате.

w_size = 128
w2_size = w_size // 2
R = w2_size//2
center = (w2_size, w2_size)
scale = 1

circle = np.zeros((w_size, w_size), dtype='uint8')
for i in range(w_size):
    for j in range(w_size):
        ii = float(i - w2_size)
        jj = float(j - w2_size)
        r = sqrt(ii*ii + jj*jj)
        if r < R:
            circle[i,j] = 1

def shift(x,y,w2_size):
    ii = float(x - w2_size)
    jj = float(y - w2_size)
    return ii,jj 

def rotate(ii,jj,teta):
    i1 =  ii*cos(teta) + jj*sin(teta)
    j1 =  ii*sin(teta) + jj*cos(teta)
    return i1,j1


circle = np.zeros((w_size, w_size), dtype='int')
for i in range(w_size):
    for j in range(w_size):
        ii,jj = shift(i,j,w2_size)
        r = sqrt(ii*ii + jj*jj)
        if r < R:
            circle[i,j] = 1

fig, ax = plt.subplots(1, 1,figsize=(5, 5))
ax.set_axis_off()
ax.set_title("circle")
ax.imshow(circle.squeeze(), cmap='gray', norm=None)

Первый эксперимент

Первый эксперимент проведем умозрительно, на бумаге.
Заполним квадрат с помощью numpy.random.uniform, после повернем с помощью ndimage.rotate на случайно выбранный угол.
Или не повернем. И из таких квадратов составим наши последовательности.
И признак для классификации оставим такой - 0, если не повернут и 1 если квадрат повернут.
И в каждом квадрате вырезаем центральный круг. Т.е. артефакты, вызванные граничными точками, убираем.
Нам нужен только круг в центре.

Очевидно, что сеть их отличит очень уверенно, на графиках гистограмм можем увидеть подтверждение ЦПТ, исходные картинки с ровной (почти) гистограммой, повернутые картинки дают гистограмму в виде горба ( очень похож на Гауссиан )

Так что дальше будем проводить эксперименты только с numpy.random.normal распределением.

Для тех, кто не верит на слово, пожалуйста, код.

num_classes = 2
train_len = 5000
test_len = 1000
input_shape = (w_size, w_size, 1)

X = np.zeros((train_len+test_len, w_size, w_size, 1), dtype='float32')
Y = np.zeros(train_len+test_len, dtype='float32')

mu = 0.25
sigma = 0.05

for iii in tqdm.tqdm(range(train_len + test_len)):
    
    angle = np.random.randint(-5,5)+ 45

    n = np.random.uniform(0.25, 0.75, size=(w_size, w_size))
    t = np.zeros((w_size, w_size), dtype='float')
    t[circle>0] = n[circle>0]
    
    r = ndimage.rotate(n, angle, reshape=False, mode='nearest')
    tt = np.zeros((w_size, w_size), dtype='float')
    tt[circle>0] = r[circle>0]

    choise = np.random.randint(0, high=65535, dtype=int) % 2
    if choise == 1:
        X[iii,:,:,0] = t[:,:]
        Y[iii] = 0
    else:
        X[iii,:,:,0] = tt[:,:]
        Y[iii] =1

yy_train = np.array(keras.utils.to_categorical(Y[:train_len], num_classes))
yy_test = np.array(keras.utils.to_categorical(Y[train_len:], num_classes))

xx_train = np.array(X[:train_len])
xx_test = np.array(X[train_len:])

print(xx_train.shape, yy_train.shape)
print(xx_test.shape, yy_test.shape)


nrows=2
ncols=4
fig, ax = plt.subplots(nrows*2, ncols,figsize=(16, 20))

for ii in range(nrows):
    for jj in range(ncols):
        random_characters = int(np.random.uniform(0,train_len))
        ax[2*ii,jj].set_axis_off()
        ax[2*ii,jj].set_title(str(int(Y[random_characters])))
        ax[2*ii,jj].imshow(X[random_characters].squeeze(), cmap='gray', norm=None)
        tx = X[random_characters]
        ax[2*ii+1,jj].hist(255.*X[random_characters].flatten(), np.arange(1,256), facecolor='blue',histtype='step')

plt.show(block=True)

Второй эксперимент

Второй эксперимент проведем, заполняя исходные квадраты случайными значениями уже с numpy.random.normal распределением.

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

Оказывается сеть спокойно их различает.

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

X = np.zeros((train_len+test_len, w_size, w_size, 1), dtype='float32')
Y = np.zeros(train_len+test_len, dtype='float32')

mu = 0.45
sigma = 0.1

for iii in tqdm.tqdm(range(train_len + test_len)):
    
    angle = np.random.randint(-5,5)+ 45

    n = np.random.normal(mu, sigma, size=(w_size, w_size))
    t = np.zeros((w_size, w_size), dtype='float')
    t[circle>0] = n[circle>0]
    
    r = ndimage.rotate(n, angle, reshape=False, mode='nearest')
    tt = np.zeros((w_size, w_size), dtype='float')
    tt[circle>0] = r[circle>0]

    choise = np.random.randint(0, high=65535, dtype=int) % 2
    if choise == 1:
        X[iii,:,:,0] = t[:,:]
        Y[iii] = 0
    else:
        X[iii,:,:,0] = tt[:,:]
        Y[iii] =1

yy_train = np.array(keras.utils.to_categorical(Y[:train_len], num_classes))
yy_test = np.array(keras.utils.to_categorical(Y[train_len:], num_classes))

xx_train = np.array(X[:train_len])
xx_test = np.array(X[train_len:])

print(xx_train.shape, yy_train.shape)
print(xx_test.shape, yy_test.shape)

nrows=2
ncols=4
fig, ax = plt.subplots(nrows*2, ncols,figsize=(16, 20))

for ii in range(nrows):
    for jj in range(ncols):
        random_characters = int(np.random.uniform(0,train_len))
        ax[2*ii,jj].set_axis_off()
        ax[2*ii,jj].set_title(str(int(Y[random_characters])))
        ax[2*ii,jj].imshow(X[random_characters].squeeze(), cmap='gray', norm=None)
        ax[2*ii+1,jj].hist(255.*X[random_characters].flatten(), np.arange(1,256),\
                           facecolor='blue',histtype='step')

plt.show(block=True)

model = keras.Sequential(
    [
        keras.Input(shape=input_shape),
        layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
        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.Conv2D(64, kernel_size=(3, 3), activation="relu"),
#        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Flatten(),
        layers.Dropout(0.5),
        layers.Dense(128, activation="relu"),
        layers.Dense(num_classes, activation="softmax"),
    ]
)

batch_size = 25
epochs = 5
num_classes = 2
n_bins = 256

model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
#model.summary()

model.fit(xx_train, yy_train, batch_size=batch_size, epochs=epochs, 
          validation_data=(xx_test, yy_test), verbose = 2)

Epoch 1/5

200/200 - 6s - loss: 0.2437 - accuracy: 0.8638 - val_loss: 4.7537e-05 - val_accuracy: 1.0000

Epoch 2/5

200/200 - 4s - loss: 3.7514e-05 - accuracy: 1.0000 - val_loss: 2.2031e-05 - val_accuracy: 1.0000

Epoch 3/5

200/200 - 4s - loss: 1.8480e-05 - accuracy: 1.0000 - val_loss: 1.1520e-05 - val_accuracy: 1.0000

Epoch 4/5

200/200 - 4s - loss: 1.0300e-05 - accuracy: 1.0000 - val_loss: 6.6436e-06 - val_accuracy: 1.0000

Epoch 5/5

200/200 - 4s - loss: 5.9791e-06 - accuracy: 1.0000 - val_loss: 4.1065e-06 - val_accuracy: 1.0000

Третий эксперимент

Третий эксперимент проведем, заполняя исходные квадраты случайными значениями с numpy.random.normal распределением.

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

И часть картинок повернем.

Но теперь повернутые картинки немного исказим так, что бы гистограмма повернутой совпадала с гистограммой оригинальной картинки.

И тут чудо, сеть не может отличить повернутые картинки от оригинальных, если гистограммы мало отличаются.

Не так уж он оказался умен, этот ваш искусственный интеллект

X = np.zeros((train_len+test_len, w_size, w_size, 1), dtype='float32')
Y = np.zeros(train_len+test_len, dtype='float32')

mu = 0.45
sigma = 0.1

view_test = np.random.randint(0, train_len+test_len, (3))

for iii in tqdm.tqdm(range(train_len + test_len)):
    
    angle = np.random.randint(-5,5)+ 45

    n = np.random.normal(mu, sigma, size=(w_size, w_size))
    t = np.zeros((w_size, w_size), dtype='float')
    t[circle>0] = n[circle>0]
    tf = t.flatten()
    
    r = ndimage.rotate(n, angle, reshape=False, mode='nearest')
    tt = np.zeros((w_size, w_size), dtype='float')
    tt[circle>0] = r[circle>0]
    tts = tt.copy()
    ttf = tt.flatten()

    step = np.arange(0., 1., 1./255.)
    
    for ii in range(1):
        for i in range(1,253):
            T = np.sum(np.bitwise_and(tf>step[i], tf<step[i+1]))
            TT = np.sum(np.bitwise_and(ttf>step[i], ttf<step[i+1]))
            T_TT = abs(T-TT)
            if T_TT == 0:
                continue
            if T>TT:
                jj = 0
                while True:
                    tt_array = np.nonzero(np.bitwise_and(ttf>step[i+1],ttf<step[i+2]))[0]
                    if len(tt_array)>=T_TT or i+jj > w_size-2:
                        break
                    ttf[ttf>step[i+2]] -=step[1]
                    jj += 1
                indices = np.arange(len(tt_array))
                np.random.shuffle(indices)
                for j in range(min(len(tt_array), T_TT)):
                    ttf[tt_array[indices[j]]] -= step[1]
            else:
                tt_array = np.nonzero(np.bitwise_and(ttf>step[i], ttf<step[i+1]))[0]
                if len(tt_array) != 0:
                    indices = np.arange(len(tt_array))
                    np.random.shuffle(indices)
                    for j in range(min(len(tt_array), T_TT)):
                        ttf[tt_array[indices[j]]] +=step[1]
                        
        tt = ttf.reshape(w_size,w_size)

    choise = np.random.randint(0, high=65535, dtype=int) % 2
    if choise == 1:
        X[iii,:,:,0] = t[:,:]
        Y[iii] = 0
    else:
        tt = ttf.reshape(w_size,w_size)
        X[iii,:,:,0] = tt
        Y[iii] =1
    
    if iii in view_test:
        random_idx = int(np.random.uniform(0,train_len))
        alpha = 0.05
        fig, axs = plt.subplots(1, 3, figsize=(30, 10))
    
        stat, p = stats.normaltest(t[circle>0].flatten())
        if p > alpha:
            axs[0].set_title("Оригинал Принять "+ str(p))
        else:
            axs[0].set_title("Оригинал Отклонить ?"+ str(p))
        axs[0].set_axis_off()
        axs[0].imshow(t, cmap="gray")
    
        stat, pp = stats.normaltest(tt[circle>0].flatten())
        if pp > alpha:
            axs[1].set_title("выровненный поворот Принять "+ str(pp))
        else:
            axs[1].set_title("выровненный поворот Отклонить "+ str(pp))
        axs[1].set_axis_off()
        axs[1].imshow(tt, cmap="gray")
    
        stat, p = stats.normaltest(tts[circle>0].flatten())
        if p > alpha:
            axs[2].set_title("просто поворот Принять "+ str(p))
        else:
            axs[2].set_title("просто поворот Отклонить "+ str(p))
        axs[2].set_axis_off()
        axs[2].imshow(tts, cmap="gray")
        
    
        tt_hist,b = np.histogram(256*tt.flatten(), np.arange(1,257))
        tts_hist,b = np.histogram(256*tts.flatten(), np.arange(1,257))
        t_hist,_ = np.histogram(256*t.flatten(), np.arange(1,257))
        fig, axs = plt.subplots(1, 1, figsize=(30, 30))
        bins = np.arange(1,256)
        axs.plot(bins, tts_hist, 'y')
        axs.plot(bins, tt_hist, 'b')
        axs.plot(bins, t_hist, 'g')
        plt.show(block=True)

yy_train = np.array(keras.utils.to_categorical(Y[:train_len], num_classes))
yy_test = np.array(keras.utils.to_categorical(Y[train_len:], num_classes))

xx_train = np.array(X[:train_len])
xx_test = np.array(X[train_len:])

print(xx_train.shape, yy_train.shape)
print(xx_test.shape, yy_test.shape)

Сеть та же самая.

batch_size = 25
epochs = 5
num_classes = 2
n_bins = 256

model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
#model.summary()

model.fit(xx_train, yy_train, batch_size=batch_size, epochs=epochs, 
          validation_data=(xx_test, yy_test), verbose = 2)

Epoch 1/5
200/200 - 4s - loss: 0.6990 - accuracy: 0.4966 - val_loss: 0.6932 - val_accuracy: 0.4970
Epoch 2/5
200/200 - 4s - loss: 0.6932 - accuracy: 0.4992 - val_loss: 0.6932 - val_accuracy: 0.4970
Epoch 3/5
200/200 - 4s - loss: 0.6932 - accuracy: 0.4988 - val_loss: 0.6931 - val_accuracy: 0.5030
Epoch 4/5
200/200 - 4s - loss: 0.6932 - accuracy: 0.4930 - val_loss: 0.6931 - val_accuracy: 0.4970
Epoch 5/5
200/200 - 4s - loss: 0.6932 - accuracy: 0.4990 - val_loss: 0.6932 - val_accuracy: 0.4970

Главный эксперимент

Ну и главный эксперимент проведем на эллипсах. Очень хорошая и удобная геометрическая фигура. Картинки для испытаний создадим так - тот же квадрат, заполненный случайными данными нормального распределения и внутри квадрата эллипс, заполненный случайными значениями тоже нормального распределения, но с другими ожиданием и дисперсией. Так же после поворота выровняем гистограмму, так же как и в предыдущем эксперименте. И вот такие повороты нейронная простая сеть отлично находит.

Т.е. если картинка структурирована и неоднородна, то даже если сегменты по распределению не искажаются - все равно сеть определяет поворот исходной картинки.

w_size = 128
w2_size = w_size // 2
R = w2_size//2
center = (w2_size, w2_size)
scale = 1

RR = R //2
A = RR + 4
B = RR - 4
c = sqrt(float(A*A - B*B))

num_classes = 2
train_len = 5000
test_len = 1000
input_shape = (w_size, w_size, 1)

circle = np.zeros((w_size, w_size), dtype='uint8')
for i in range(w_size):
    for j in range(w_size):
        ii = float(i - w2_size)
        jj = float(j - w2_size)
        r = sqrt(ii*ii + jj*jj)
        if r < R:
            circle[i,j] = 1

def shift(x,y,w2_size):
    ii = float(x - w2_size)
    jj = float(y - w2_size)
    return ii,jj 

def rotate(ii,jj,teta):
    i1 =  ii*cos(teta) + jj*sin(teta)
    j1 =  ii*sin(teta) + jj*cos(teta)
    return i1,j1


circle = np.zeros((w_size, w_size), dtype='int')
for i in range(w_size):
    for j in range(w_size):
        ii,jj = shift(i,j,w2_size)
        r = sqrt(ii*ii + jj*jj)
        if r < R:
            circle[i,j] = 1

def ellipse_p(teta_grad):
    ellipse = np.zeros((w_size, w_size), dtype='float32')
    teta = radians(teta_grad)
    ci1, cj1 = rotate( c,0,teta)
    ci2, cj2 = rotate(-c,0,teta)
    for i in range(w_size):
        for j in range(w_size):
            ii,jj = shift(i,j,w2_size)
            r1 = sqrt((ii-ci1)*(ii-ci1) + (jj-cj1)*(jj-cj1))
            r2 = sqrt((ii-ci2)*(ii-ci2) + (jj-cj2)*(jj-cj2))
            
            if r1+r2 < 2*A:
                ellipse[i,j] = 255
    return (ellipse)

teta_grad = 45.0
ellipse = ellipse_p(teta_grad)

fig, ax = plt.subplots(1, 2,figsize=(10, 20))
ax[0].set_axis_off()
ax[0].set_title("circle")
ax[0].imshow(circle.squeeze(), cmap='gray', norm=None)
ax[1].set_axis_off()
ax[1].set_title("ellipse")
ax[1].imshow(ellipse.squeeze(), cmap='gray', norm=None)

X = np.zeros((train_len+test_len, w_size, w_size, 1), dtype='float32')
Y = np.zeros(train_len+test_len, dtype='float32')

mu = 0.35
sigma = 0.1
el_mu = 0.65
el_sigma = 0.1
view_test = np.random.randint(0, train_len+test_len, (3))

for iii in tqdm.tqdm(range(train_len + test_len)):
    
    angle = np.random.randint(-5,5)+ 45

    n = np.random.normal(mu, sigma, size=(w_size, w_size))
    el = np.random.normal(el_mu, el_sigma, size=(w_size, w_size))
    t = np.zeros((w_size, w_size), dtype='float')
    t[circle>0] = n[circle>0]
    ellipse = ellipse_p(angle)
    t[ellipse>0] = el[ellipse>0]
    tf = t.flatten()
    
    ellipse = ellipse_p(0)
    n[ellipse>0] = el[ellipse>0]
    r = ndimage.rotate(n, angle, reshape=False, mode='nearest')
    tts = np.zeros((w_size, w_size), dtype='float')
    tts[circle>0] = r[circle>0]
    ttf = tts.flatten()

    
    step = np.arange(0., 1., 1./255.)
    
    for ii in range(1):
        for i in range(1,253):
            T = np.sum(np.bitwise_and(tf>step[i], tf<step[i+1]))
            TT = np.sum(np.bitwise_and(ttf>step[i], ttf<step[i+1]))
            T_TT = T-TT
            if abs(T_TT) == 0:
                continue
            if T>TT:
                jj = 0
                while True:
                    tt_array = np.nonzero(np.bitwise_and(ttf>step[i+1],ttf<step[i+2]))[0]
                    if len(tt_array)>=T_TT or i+jj > w_size-2:
                        break
                    ttf[ttf>step[i+2]] -=step[1]
                    jj += 1
                indices = np.arange(len(tt_array))
                np.random.shuffle(indices)
                for j in range(min(len(tt_array), T_TT)):
                    ttf[tt_array[indices[j]]] -= step[1]
            else:
                tt_array = np.nonzero(np.bitwise_and(ttf>step[i], ttf<step[i+1]))[0]
                if len(tt_array) != 0:
                    indices = np.arange(len(tt_array))
                    np.random.shuffle(indices)
                    for j in range(min(len(tt_array), abs(T_TT))):
                        ttf[tt_array[indices[j]]] +=step[1]
                        
        tt = ttf.reshape(w_size,w_size)

    choise = np.random.randint(0, high=65535, dtype=int) % 2
    if choise == 1:
        X[iii,:,:,0] = t[:,:]
        Y[iii] = 0
    else:
        tt = ttf.reshape(w_size,w_size)
        X[iii,:,:,0] = tt
        Y[iii] =1
        
    if iii in view_test:
        random_idx = int(np.random.uniform(0,train_len))
        alpha = 0.05
        fig, axs = plt.subplots(1, 3, figsize=(30, 10))
        axs[0].set_axis_off()
        axs[1].set_axis_off()
        axs[2].set_axis_off()
        axs[0].imshow(t, cmap="gray")
        axs[1].imshow(tt, cmap="gray")
        axs[2].imshow(tts, cmap="gray")
            
        tt_hist,b = np.histogram(256*tt.flatten(), np.arange(1,257))
        tts_hist,b = np.histogram(256*tts.flatten(), np.arange(1,257))
        t_hist,_ = np.histogram(256*t.flatten(), np.arange(1,257))
        fig, axs = plt.subplots(1, 1, figsize=(30, 30))
        bins = np.arange(1,256)
        axs.plot(bins, tts_hist, 'y')
        axs.plot(bins, tt_hist, 'b')
        axs.plot(bins, t_hist, 'g')
        plt.show(block=True)

yy_train = np.array(keras.utils.to_categorical(Y[:train_len], num_classes))
yy_test = np.array(keras.utils.to_categorical(Y[train_len:], num_classes))

xx_train = np.array(X[:train_len])
xx_test = np.array(X[train_len:])

print(xx_train.shape, yy_train.shape)
print(xx_test.shape, yy_test.shape)
print(np.min(X), np.max(X))

batch_size = 25
epochs = 5
num_classes = 2
n_bins = 256

model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
#model.summary()

model.fit(xx_train, yy_train, batch_size=batch_size, epochs=epochs, 
          validation_data=(xx_test, yy_test), verbose = 2)

Epoch 1/5
200/200 - 4s - loss: 0.3143 - accuracy: 0.8330 - val_loss: 0.0030 - val_accuracy: 0.9990
Epoch 2/5
200/200 - 4s - loss: 0.0077 - accuracy: 0.9978 - val_loss: 2.2245e-04 - val_accuracy: 1.0000
Epoch 3/5
200/200 - 4s - loss: 0.0019 - accuracy: 0.9994 - val_loss: 4.2272e-04 - val_accuracy: 1.0000
Epoch 4/5
200/200 - 4s - loss: 0.0091 - accuracy: 0.9966 - val_loss: 9.0115e-04 - val_accuracy: 0.9990
Epoch 5/5
200/200 - 4s - loss: 0.0105 - accuracy: 0.9964 - val_loss: 0.0067 - val_accuracy: 0.9980

Краткое резюме.

Если в вашем датасете с картинками не выровненные классы, и вы решили добавить картинок для выравнивания с помощью аугментации, то результат будет удивительным и коварным.

Кручу-верчу, обмануть хочу