Здравствуй, дорогой читатель. В статье речь пойдет об обработке показаний с датчика с применением как простых алгоритмов, так и нейронной сети. Что проще – решай сам.

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

Первый способ обработки – с помощью Z-фактора, сглаживания гаусса:

import numpy as np

from scipy import stats

import lasio

from scipy import ndimage

las = lasio.read(r"Ваш лас.las")

def changeNan (mass):

       nan_indices = np.isnan(mass);

       non_nan_indices = np.arange(len(mass))[~nan_indices]

       interpolated_values = np.interp(np.arange(len(mass)), non_nan_indices, mass[~nan_indices])

       mass[nan_indices] = interpolated_values[nan_indices]

       return mass

def lasApd (m):

     

       m[m >= 1600] = np.NaN

       m[m < 1] = np.NaN

       k = 1

       m = changeNan(m)

       for i in range(1):      

              z = stats.zscore(m, ddof=0);

              m[abs(z) > k ] = np.NaN

              m = changeNan(m)

       m = ndimage.gaussian_filter(m, np.nanmean(m)/3)

       return m

 

arr = [“набор мнемоник для анализа”]

for i in arr:

       las[i] = lasApd(las[i])

       print(i)

with open(выход.las', mode='w') as f:

    las.write(f, version=2.0) 

  Когда я это написал, узнал о «панде» и что можно сделать проще. Полночи ушло (смена у меня ночная).

             В принципе, мне достаточно такой обработки данных, но я решил узнать, на что способны нейросети. Я не специалист по программированию, и последний раз писал код как человек, которому за это платят,15 лет назад. Забавный факт: когда я брался за Python, я думал, что уже писал на нём в 2006 году, но где-то на 3-ю ночь вспомнил, что тот язык назывался Perl. 

             От нейросети я честно ожидал что-то типа:

1. закинул два файла – обучил,

2. закинул необработанный – получил то, что нужно! 

 Не тут-то было.

Почему TensorFlow? – Случайность. На вторую ночь смотрел видео, где, как мне показалось, в полумистическом откровении пишут и приводят либо одни и те же примеры, либо сразу сложные типа: заполним массив случайными числами так, чтобы получилась картина Микеланджело. В общем, пришлось разбираться, как часто бывало в моей практике программирования, с основ. Общее представление о нейросетях мне дали в 2002 году в универе. Так что не совсем с нуля, а чуть ниже. :)

  Первое, что я захотел сделать, – это научиться складывать:

import tensorflow as tf

import numpy as np

from tensorflow import keras

from tensorflow.keras.layers import Dense

 N = 20

M =2

 y_train = np.random.randint(22, size=(N, M))

x = np.sum(y , axis=1)

#Начал писать статью, так и хочется добавить - тут заполняем данными!

 model = keras.Sequential() #Тип модели, хорошо идет с простыми моделями

model.add(Dense(units = 1, input_shape=(M,), activation = 'linear')) #unit количество данных на выходе, инпут - размерность строки массива (не сразу выкупил разницу, между зеленой матрицой, и массивом 

 model.compile(loss='mean_squared_error') # в данном случае ошибка выше, необходимо больше эпох, что-то написать обязательно

ИЛИ

model.compile(optimizer='rmsprop', loss='mse') #Для математических задач лучше подходит

model.fit( y_train,x, epochs=550, batch_size = 2) #batch_size, хорошая штука, типа шага в цикле

model.save('1plus1_primerno_2.keras')

rr = model.predict(y_train) #узнать Ответ, я так и не удосужился узнать, есть ли другой способ обратится к обученной модели

Ответ: 42

  Разобравшись с простой однослойной нейропаутинкой, приступил сразу к сложному, анализу временных рядов. В процессе создания я для себя понял, что каждый слой – это одно простое действие. На два действия – 2 слоя. Три действия – правильно: 3 слоя. Как обозначить, что это последовательность данных? Конечно, параметром Х. При запросе “нейросеть, убрать ошибку, данные сигнала” в первом же комментарии неизвестному парню советуют: обработай математическими методами.    

import numpy as np

import pandas as pd

from keras.models import Sequential

from keras.layers import Dense

import lasio

lasHandMade = lasio.read(r"идеальные мнемоники сделанные специалистами высшего класса!.las)

las = lasio.read(r"мнемоники до обработки.las")

print(las.curves)

data = {'depth': lasHandMade['DEPTH'],

        'valueHand': lasHandMade['F4KPM'],

        }  

df = pd.DataFrame(data)

print (df)

X = df['depth']

y = df['valueHand']

model = Sequential()

model.add(Dense(10, input_dim=1, activation='relu'))

model.add(Dense(1, activation='linear'))

model.compile(loss='mse', optimizer='adam')

model.fit(X, y, epochs=500, verbose=0)

rr = model.predict(las['мнемоника'] )

print('rr', rr)

las['мнемоника'] = np.squeeze(rr, axis=1)

with open('test_outputN.las', mode='w') as f:

      las.write(f, version=2.0)

Для меня как пользователя важно было узнать все возможные параметры, которые можно передавать в model.fit. Они под катом:

и model.compile

Код без купюр. По моей логике, первый слой должен вычислить ошибку, а второй – хотелось бы – её интерполировать. Эпох (на моём сленге – итераций) ставлю много, ибо мне все равно. Реально их тут надо штук 200. А как хотелось бы – не работает: да, ошибки сглаживает, как и всю кривую, и надо вводить функцию интерполяции. Но я уже понимал, как схитрить, и решил делать, как советуют в мануале, временные ряды. И пошел дальше. 

 import numpy as np

from tensorflow.keras import layers, models

 N = 1000 // количество примеров, лишканул… 

input_shape = (10, 1) // размерность данных для анализа нейросети, иными словами, если вы берете для анализа 1 метр, у вас в него влазит 10 значений, то размерность 10, 1 

data_poor_mnemonik = np.random.uniform(5, 30, size = (N, input_shape[0], input_shape[1]))

data_poor_mnemonik[:, 5] += np.mean(data_poor_mnemonik)*3  # Добавление аномальных точек в сигнал

 data_clear_mnemonik = np.random.uniform(5, 30, size = (N, 10, 1))

            //Модель автокодировщика (обычная) для ... ну как получится

 model = models.Sequential([

    layers.LSTM(64, input_shape=input_shape, return_sequences=True),  

    layers.LSTM(32, return_sequences=True),  

    layers.TimeDistributed(layers.Dense(1))  // взял с сайта по керасу, по сути на каждую единицу шага, в моём случае 1, используется 1 слой. Т.е. умеем что-то, что умеет кодировщик (1 строка), и декодировщик (2 строка)

])

 model.compile(optimizer='adam', loss='mse');

 anomaly_mask = np.zeros_like(data_poor_mnemonik)

anomaly_mask[:, 5] = 1

 model.fit( data_clear_mnemonik,data_poor_mnemonik, sample_weight=(1 - anomaly_mask),  epochs=100, batch_size=32)

 filtM = model.predict(data_poor_mnemonik)

corrM = data_poor_mnemonik * (1 - anomaly_mask) + filtM * anomaly_mask

 import matplotlib.pyplot as plt

N=10

plt.figure(figsize = (8, 6))

plt.plot(data_poor_mnemonik.flatten()[0:100])

plt.plot(corrM.flatten()[0:100])

plt.plot(filtM.flatten()[0:100])

plt.show()

             Данный пример ищет ошибки, исправляет вылеты. Но! Делает не так, как задумывалось (с помощью нейросети, которая всё понимает и умеет делать), а схитрил – ввел очевидную маску для аномальных точек, и через нее… (по аналогии, можно проделать этот трюк и с предыдущим примером). 

Полноценное решение поставленной задачи за грудой кода и понимания, но потихоньку, шаг за шагом…

             Итог обработки на скринах. На первом – исходные данные, на втором – работа алгоритма, на третьем – нейросеть, но с искусственным примером. Математика стабильнее и дает более ясное пространство для манипуляций, выбор критериев отбора и т.п. Математическим методом я написал программу где-то часа за 3, первый раз используя Python и первая нейросеть «2+2» – это еще полчаса. И смутное понимание, того, что делаешь. 4 дня спустя начинаешь понимать первый пример. И через 4 дня всё еще нет реализации полноценного решения чуть более сложной нейросети. Возможно, вам мой опыт пригодится. Большую часть времени ищешь, как пользоваться бестолковым и «пандой».

    Статья написана не только для того, чтобы “попиариться” и структурировать свои знания, а, возможно, для того, чтобы кто-то, кто реально понимает в теме, подсказал, как улучшить данную нейросеть. Следующим этапом хочу, чтобы она умела сравнивать с коррелирующими данными, полученными во время бурения, и прочее, и прочее.

            Вторая причина – раскрутка маленького приложения, написанного в помощь родному человеку. https://play.google.com/store/apps/details?id=children.notebook Бесплатный проект!

            Если не заминусуют, продолжу.

Upd:

5-й день, еще 2 часа. Писать отдельный пост на эту тему смысла нет, поэтому апдейтом. 

Модель сделана, и делает всё, что заявлялось, но неидеально.

import numpy as np
from tensorflow.keras import layers, models

N = 1000
input_shape = (10, 1)

data_poor_mnemonik = np.random.uniform(5, 30, size = (N, input_shape[0], input_shape[1]))
data_clear_mnemonik = np.copy(data_poor_mnemonik)

data_poor_mnemonik[:, 5] += np.mean(data_poor_mnemonik)*3  # Добавление аномальных точек в сигнал

model = models.Sequential([
    layers.LSTM(64, input_shape=input_shape, return_sequences=True),  
    layers.LSTM(32, return_sequences=True),  
    layers.TimeDistributed(layers.Dense(1))  # взял с сайта по керасу, по сути на каждую единицу шага, в моём случае 1, используется 1 слой.
])

model.compile(optimizer='adam', loss='mse');

anomaly_mask = np.zeros_like(data_poor_mnemonik)
anomaly_mask[:, 5] = 1

model.fit( data_clear_mnemonik,data_poor_mnemonik, sample_weight=(1 - anomaly_mask),  epochs=100, batch_size=32, validation_split=0.2)

data_poor_mnemonik_F_p = np.random.uniform(5, 30, size = (N, input_shape[0], input_shape[1]))
data_poor_mnemonik_F_p[:, 8] += np.mean(data_poor_mnemonik)*3 

filtM = model.predict(data_poor_mnemonik_F_p)
corrM = data_poor_mnemonik_F_p * (1 - anomaly_mask) + filtM * anomaly_mask

import lasio
las = lasio.read(r"Ваш лас файл.las")

arr = np.array(las['Название мнемоники.las'])
arr = arr[:- (arr.size%input_shape[0])]
arr= arr.reshape( int( arr.size / input_shape[0]), input_shape[0], input_shape[1])

rr = model.predict(arr )

rr = np.append(rr.flatten(), np.zeros(las['Название мнемоники'].size%input_shape[0]) )
las['Название мнемоники'] = rr

with open('Ваш лас файл_out.las', mode='w') as f:
    las.write(f, version=2.0) 

Вопросы, которые у меня возникали по ходу, и ответы на них. 

1. Как задать выходные параметры? 

Нашел два способа:
– задать параметр units = 1… в последнем слое

model.add(Dense(1, activation='linear'))

– задать параметр y_train из первого примера (какие данные для проверки даете, такие и получите).

1. Сколько слоев, какой размерности, как выбирать? 

Только опыт, эксперимент, пробы и ошибки. Я исходил из правила: 1 (float) значение, размерность скрытого слоя – 16. Про количество слоев писал выше.

Далее будем улучшать, как говорил ранее.