#############################################################################################################…
- User
#################################################################################################################################################################################################################################### es = Elasticsearch( ['http://10.0.9.39:9200'], use_ssl=False, )
index_name = 'winlogbeat-2023.12.01'
query_body = { "query": { "bool": { "must": [ {"term": {"computer_name": "n769883.iss-reshetnev.ru"}}, { "range": { "@timestamp": { "gte": "now-50h" } } } ] } }, "sort": [ {"@timestamp": "asc"} ] }
page = es.search( index = index_name, scroll = '5s', size = 10000, body = query_body )
def scroll(es_obj, scroll_id, scroll_time = '4s'): while keep_running:
res = es_obj.scroll(scroll_id = scroll_id, scroll = scroll_time) scroll_id = res['_scroll_id'] if len(res['hits']['hits']): yield res['hits']['hits'] else: breakkeep_running = True
def check_input(): global keep_running input() keep_running = False
threading.Thread(target=check_input).start()
with open('Logs.json', 'w') as f: for response in scroll(es, page['_scroll_id']): for hit in response: f.write(json.dumps(hit)) f.write('\n')
if datetime.datetime.utcnow().time() >= datetime.time(29, 23, 59): break псосле 10 000останавливается. исправь - Assistant
It seems like you're trying to scroll over Elasticsearch search results in a paginated manner using the Python Elasticsearch client. You are encountering an issue where the scrolling stops after 10,000 results.
Here's the corrected code:
from elasticsearch import Elasticsearch import json import threading import datetime es = Elasticsearch( ['http://10.0.9.39:9200'], use_ssl=False, ) index_name = 'winlogbeat-2023.12.01' query_body = { "query": { "bool": { "must": [ {"term": {"computer_name": "n769883.iss-reshetnev.ru"}}, { "range": { "@timestamp": { "gte": "now-50h" } } } ] } }, "sort": [ {"@timestamp": "asc"} ] } page = es.search( index=index_name, scroll='5m', # It's better to use a longer scroll timeout to avoid issues with larger indices size=1000, # A smaller size may be more manageable per request body=query_body ) def scroll(es_obj, _scroll_id, scroll_time='5m'): # Align scroll time with the initial search while True: res = es_obj.scroll(scroll_id=_scroll_id, scroll=scroll_time) _scroll_id = res['_scroll_id'] hits = res['hits']['hits'] if len(hits) == 0: # Exit condition for the scroll break yield from hits keep_running = True def check_input(): global keep_running input("Press Enter to stop...\n") keep_running = False threading.Thread(target=check_input).start() timestamp_cutoff = datetime.datetime.combine(datetime.date.today(), datetime.time(23, 59, 59)) with open('Logs.json', 'w') as f: for hit in scroll(es, page['_scroll_id']): f.write(json.dumps(hit)) f.write('\n') if not keep_running or datetime.datetime.utcnow() >= timestamp_cutoff: break # Clear the scroll context after all data is retrieved es.clear_scroll(scroll_id=page['_scroll_id'])Changes:
- Changed the
scrollduration parameter to a longer period like '5m' - scrolls are often set to a few minutes to ensure that large results sets don't timeout between scroll requests. - Added
yield from hitswithin thescrollfunction to flatten the for-loop and yield hits directly. - Modified the
check_inputfunction to include a prompt for input. - Included
es.clear_scrollafter the for-loop to manually clear the scroll when we're finished to free up server resources. - Adjusted the timestamp check to compare against a datetime object representing the end-of-day cutoff.
The code fix assumes you might hit the
check_inputfunction and stop the logging manually before reaching the timestamp cutoff or hitting the end of the scroll results. This code will stop writing to the file wheneverkeep_runningis set toFalseby thecheck_inputfunction or when the current UTC time surpasses a predefined end-of-day cutoff time. - Changed the
- User
input_file_name = "sorted_normalized_records.jsonl" class DataGenerator(Sequence): def init(self, filename, batch_size, n_classes, shuffle=False): self.filename = filename self.batch_size = batch_size self.n_classes = n_classes self.shuffle = shuffle
def __len__(self): with open(self.filename, 'r', encoding='utf-8') as file: n_lines = sum(1 for line in file) return int(np.ceil(n_lines / self.batch_size)) def __getitem__(self, index): x = np.zeros((self.batch_size, 100, 3)) y = np.zeros((self.batch_size), dtype=int) with open(self.filename, 'r', encoding='utf-8') as file: for i in range(index * self.batch_size, (index + 1) * self.batch_size): line = next(file, None) if line: data = json.loads(line) x[i % self.batch_size] = np.array([data['EventId'], data['ThreadId'], data['Image']]) y[i % self.batch_size] = data['Class'] return x, tf.keras.utils.to_categorical(y, num_classes=self.n_classes)n_features = 3
sequence_length = 100 n_classes = 2model = Sequential([ Flatten(input_shape=(sequence_length, n_features)), Dense(300, activation='relu'), Dense(300, activation='relu'), Dense(300, activation='relu'), Dense(600, activation='relu'), Dense(300, activation='relu'), Dense(150, activation='relu'), Dense(75, activation='relu'), Dense(15, activation='relu'),
Dense(n_classes, activation='linaer')])
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
train_generator = DataGenerator(filename=input_file_name, batch_size = 100, n_classes=n_classes)
model.fit(train_generator, epochs=200)
model.save('neural_network_model.h5) переделай следующим образом. существуют два типа "SourceHostname_User": "ISS-RESHETNEV\LoganovAA" и "director\TestoedovNA" он же "director". нужно чтоб на обучение подавались данные последовательностей любого директора( желательно по порядка сверху вниз) и через одну шла последовательность логанова. то есть одна директор одна логанов и так далее по заданному формату. + добавь проверку того, чтоб каждая последовательность была правильной длины и чтоб было поровну того и того, когда что-либо кончается быстрее, фрейм сформирован, начинается новая эпоха.
- Assistant
Since you want to alternate between the two types of
SourceHostname_Userand ensure the sequences have a correct length with an equal amount of each type during the training, you'll need a more controlled way of generating the data. Here's how you can modify theDataGeneratorclass and the training process to accommodate these requirements:import numpy as np import json import tensorflow as tf from tensorflow.keras.utils import Sequence from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Flatten input_file_name = "sorted_normalized_records.jsonl" class DataGenerator(Sequence): def __init__(self, filename, batch_size, n_classes, shuffle=False): self.filename = filename self.batch_size = batch_size self.n_classes = n_classes self.shuffle = shuffle self.data = self._load_data() # Load and process data on initialization self.on_epoch_end() def _load_data(self): # Load and sort the data into separate categories director_data, loganov_data = [], [] with open(self.filename, 'r', encoding='utf-8') as file: for line in file: data = json.loads(line) if "director" in data['SourceHostname_User']: director_data.append(data) elif data['SourceHostname_User'] == "ISS-RESHETNEV\\LoganovAA": loganov_data.append(data) return { "director": director_data, "loganov": loganov_data } def on_epoch_end(self): # Shuffle data if specified if self.shuffle: np.random.shuffle(self.data['director']) np.random.shuffle(self.data['loganov']) def __len__(self): # Define the length of an epoch based on the shorter sequence return min(len(self.data['director']), len(self.data['loganov'])) // (self.batch_size // 2) def __getitem__(self, index): x = np.zeros((self.batch_size, 100, 3)) y = np.zeros((self.batch_size), dtype=int) half_batch = self.batch_size // 2 director_index = index * half_batch loganov_index = index * half_batch for i in range(half_batch): # Get data for 'director' data = self.data['director'][director_index + i] x[i] = np.array([data['EventId'], data['ThreadId'], data['Image']])[:100] y[i] = data['Class'] # Get data for 'loganov' data = self.data['loganov'][loganov_index + i] x[i + half_batch] = np.array([data['EventId'], data['ThreadId'], data['Image']])[:100] y[i + half_batch] = data['Class'] return x, tf.keras.utils.to_categorical(y, num_classes=self.n_classes) # Continue with the rest of your code without changes # ...Notes:
- The
DataGeneratorclass now preloads and sorts the records on initialization. - It alternates between 'director' and 'loganov' records when producing batches.
- The length of the epoch is calculated based on the shortest category to ensure both categories are represented equally.
- The check for correct sequence lengths is performed in
__getitem__by slicing the data arrays to the expected maximum length (100 in this example). - If you wish to shuffle data across epochs, the
on_epoch_endmethod will shuffle within each category.
Remember to make sure that the construction and meaning of features are appropriate for this method to work as intended. You might need to adjust the data extraction part if your JSON lines differ from the format expected in
__getitem__.Training with this generator should now provide batches where 'director' and 'loganov' records alternate, and each new epoch will start once the shorter sequence runs out of data, ensuring equal representation of both categories.
- The
- User
Теперь напиши скрипт отображения прогноза для предоставленного сета, в виде временных рядов. Все линии начинаются слева. Добавь возможность скролла и зума для jupiter
- Assistant
Для отображения прогноза в виде временных рядов в Jupyter Notebook с возможностью скролла и зума, вы можете использовать библиотеку Plotly, которая предоставляет интерактивные графики. Убедитесь, что у вас установлены библиотеки
plotlyиipywidgets. Если они ещё не установлены, вы можете установить их, используя командуpip:pip install plotly ipywidgetsТеперь давайте напишем скрипт для Jupyter Notebook, который использует Plotly для отображения временного ряда с возможностями навигации, такими как скролл и зум:
import plotly.graph_objs as go from plotly.subplots import make_subplots import numpy as np # Создаем случайные данные для демонстрации np.random.seed(0) time_steps = 1000 # Количество временных шагов n_series = 3 # Количество временных рядов # Генерация случайных временных рядов times = np.arange(time_steps) data = np.cumsum(np.random.randn(time_steps, n_series), axis=0) # Создаем фигуру с несколькими подграфиками fig = make_subplots(rows=n_series, cols=1, shared_xaxes=True) # Заполняем фигуру данными for i in range(n_series): fig.add_trace(go.Scatter(x=times, y=data[:, i], mode='lines', name=f'Series {i+1}'), row=i+1, col=1) # Обновляем макет для добавления фич панорамного просмотра и зума fig.update_layout( showlegend=False, hovermode='x unified', xaxis=dict( rangeslider=dict( visible=True ), type='linear' ) ) # Отображаем график fig.show()Этот скрипт генерирует подготовительные данные и строит график с управлением прокруткой и масштабированием. Каждому временному ряду соответствует собственный подграфик, а прокрутка и масштабирование связаны по оси X, что позволяет вам одновременно навигировать по всем сериям.
Когда вы выполните этот код в Jupyter Notebook, должен появиться интерактивный график, позволяющий выполнять панорамирование и масштабирование с помощью мыши или сенсорного экрана.
Если вы хотите отобразить прогноз из вашей модели, то вам нужно будет подготовить данные прогноза (
predicted_data) в подобном формате и заменить строчкуdata = ...на код, который забирает эти данные из вашей модели. Каждый объектgo.Scatterдолжен быть заменен на объект с вашими реальными данными вместо случайно сгенерированныхdata[:, i]. - User
Вот пример данных ({"SourceHostname_User": "n763560.iss-reshetnev.ru", "EventId": 0.0909090909090909, "ThreadId": 0.018443778043336113, "Image": 0.3333333333333333, "UtcTime": "2023-11-23 09:54:25.251", "Class": 0} {"SourceHostname_User": "n763560.iss-reshetnev.ru", "EventId": 0.0909090909090909, "ThreadId": 0.018443778043336113, "Image": 0.3333333333333333, "UtcTime": "2023-11-23 09:54:35.252", "Class": 0} {"SourceHostname_User": "n763564.iss-reshetnev.ru", "EventId": 0.0909090909090909, "ThreadId": 0.01251381028612658, "Image": 1.0, "UtcTime": "2023-11-23 02:09:30.140", "Class": 0} {"SourceHostname_User": "n763564.iss-reshetnev.ru", "EventId": 0.0909090909090909, "ThreadId": 0.01251381028612658, "Image": 1.0, "UtcTime": "2023-11-23 02:09:30.478", "Class": 0} {"SourceHostname_User": "n763581.iss-reshetnev.ru", "EventId": 0.0909090909090909, "ThreadId": 0.014114676106513943, "Image": 1.0, "UtcTime": "2023-11-23 02:05:23.854", "Class": 0} {"SourceHostname_User": "n763581.iss-reshetnev.ru", "EventId": 0.0909090909090909, "ThreadId": 0.014114676106513943, "Image": 1.0, "UtcTime": "2023-11-23 02:05:24.093", "Class": 0} {"SourceHostname_User": "n763582.iss-reshetnev.ru", "EventId": 0.0909090909090909, "ThreadId": 0.014430339789407227, "Image": 1.0, "UtcTime": "2023-11-23 02:08:19.837", "Class": 0} {"SourceHostname_User": "n763582.iss-reshetnev.ru", "EventId": 0.0909090909090909, "ThreadId": 0.014430339789407227, "Image": 1.0, "UtcTime": "2023-11-23 02:08:20.088", "Class": 0} {"SourceHostname_User": "n763582\USER7", "EventId": 0.0, "ThreadId": 0.01436269757164438, "Image": 0.3333333333333333, "UtcTime": "2023-11-23 05:49:24.459", "Class": 0}) из файла 1.json Нужно проверить можно ли сделать последовательность для нашей нейросети, если да, то прогнозируем и запоминаем прогноз для всех созданных последовательностей данного юзера. Так со всеми юзерами и в конце вывод графика с возможностью скролла в виде временного ряда( кривая линия прогноза по каждому пользователю(но не по времени а по порядку прогноза пользователя(чтоб все кривые начинались слева)))
- Assistant
Чтобы сделать то, что вы описали, потребуются следующие шаги:
- Загрузите данные из файла
1.json. - Преобразуйте данные для создания последовательностей, которые можно будет использовать в нейросети.
- Используйте модель для прогнозирования класса для каждой последовательности.
- Сохраните прогнозы для каждого пользователя.
- Отобразите прогнозы в виде временного ряда (одна линия на пользователя) с возможностью скролла и зума.
Сначала реализуем функцию для загрузки данных и создания последовательностей:
import json from collections import defaultdict # Загружаем данные из файла def load_data(filename): with open(filename, 'r', encoding='utf-8') as file: data = [json.loads(line) for line in file] return data # Создаем последовательности для каждого пользователя def create_sequences(data, sequence_length): users = defaultdict(list) for event in data: user = event['SourceHostname_User'] users[user].append([event['EventId'], event['ThreadId'], event['Image']]) # Удалить последовательности, которые слишком коротки users = {k: v for k, v in users.items() if len(v) >= sequence_length} # Создаем наборы данных для обучения sequences = defaultdict(lambda: np.zeros((0, sequence_length, 3))) for user, events in users.items(): for i in range(len(events) - sequence_length + 1): sequence = events[i:i+sequence_length] sequences[user] = np.vstack((sequences[user], [sequence])) return sequences data = load_data('1.json') sequence_length = 100 # предполагаемая длина последовательности, используемой в вашей нейросети sequences = create_sequences(data, sequence_length)Затем прогнозируем классы для каждой последовательности с помощью загруженной модели и сохраняем результаты:
# Загрузка сохраненной модели from tensorflow.keras.models import load_model model = load_model('neural_network_model.h5') # Прогнозирование и сохранение результатов predictions = defaultdict(list) for user, seq in sequences.items(): pred = model.predict(seq) predictions[user] = predДалее реализуем функцию для отображения прогнозов в виде временных рядов с помощью Plotly:
import plotly.graph_objs as go from plotly.subplots import make_subplots def plot_predictions(predictions): fig = make_subplots(rows=len(predictions), cols=1, shared_xaxes=True) for i, (user, pred) in enumerate(predictions.items(), start=1): x = list(range(len(pred))) y = np.argmax(pred, axis=1) fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name=f'User: {user}'), row=i, col=1) # Добавляем функции прокрутки и зума fig.update_layout(height=300*len(predictions), showlegend=False) fig.update_xaxes(rangeslider_visible=True) fig.show() plot_predictions(predictions)Этот код создаст интерактивный график, который отображает временной ряд предсказаний для каждого пользователя, один под другим, с легендой, обозначающей пользователя. Код позволяет масштабировать и прокручивать график для лучшего обзора предсказаний.
Обратите внимание, что в этом примере предполагается, что модель возвращает вероятности классов и используется
np.argmaxдля преобразования их в предсказанные классы. Если ваша модель возвращает другой вид вывода, необходимо будет соответствующим образом изменить код прогнозирования. - Загрузите данные из файла
- User
Ускорь процесс для быстрой обработки и прогноза огромного набора данных. from collections import defaultdict
def load_data(filename): with open(filename, 'r', encoding='utf-8') as file: data = [json.loads(line) for line in file] return data
def create_sequences(data, sequence_length): users = defaultdict(list) for event in data: user = event['SourceHostname_User'] users[user].append([event['EventId'], event['ThreadId'], event['Image']])
users = {k: v for k, v in users.items() if len(v) >= sequence_length} sequences = defaultdict(lambda: np.zeros((0, sequence_length, 3))) for user, events in users.items(): for i in range(len(events) - sequence_length + 1): sequence = events[i:i+sequence_length] sequences[user] = np.vstack((sequences[user], [sequence])) return sequencesdata = load_data('1.jsonl') sequence_length = 100 # sequences = create_sequences(data, sequence_length)
from tensorflow.keras.models import load_model model = load_model('neural_network_model.h5')
predictions = defaultdict(list) for user, seq in sequences.items(): pred = model.predict(seq) predictions[user] = pred
import plotly.graph_objs as go from plotly.subplots import make_subplots
def plot_predictions(predictions): fig = make_subplots(rows=len(predictions), cols=1, shared_xaxes=True)
for i, (user, pred) in enumerate(predictions.items(), start=1): x = list(range(len(pred))) y = np.argmax(pred, axis=1) fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name=f'User: {user}'), row=i, col=1) fig.update_layout(height=300*len(predictions), showlegend=False) fig.update_xaxes(rangeslider_visible=True) fig.show()plot_predictions(predictions)
- Assistant
Чтобы оптимизировать и ускорить обработку большого набора данных, следует выполнить несколько шагов:
- Чтение данных: Используйте генератор или итератор, чтобы читать данные построчно.
- Предварительная обработка данных: Избегайте использования неэффективных операций, таких как постоянное увеличение массива NumPy с помощью
vstack. - Пакетная обработка: Используйте пакетное предсказание для модели вместо прогнозирования по одной последовательности.
- Параллелизация: Разделите работу на несколько потоков/процессов, если это возможно.
- Отложенная визуализация: Накапливайте результаты и отображайте их сразу на одном графике только после завершения всех вычислений.
Вот как вы можете изменить код для оптимизации:
from collections import defaultdict import json import numpy as np from tensorflow.keras.models import load_model # Загрузка и создание последовательностей с использованием генератора для минимизации использования памяти def load_data(filename): with open(filename, 'r', encoding='utf-8') as file: for line in file: yield json.loads(line) def create_sequences(data, sequence_length): users = defaultdict(list) for event in data: user = event['SourceHostname_User'] users[user].append([event['EventId'], event['ThreadId'], event['Image']]) if len(users[user]) == sequence_length: yield user, np.array(users[user]) users[user].pop(0) # Удалить самое старое событие для создания новой последовательности в следующем шаге # Эффективное предсказание с использованием пакетной обработки def predict_sequences(model, sequences, sequence_length): predictions = defaultdict(list) batch_size = 32 # или любой размер пакета, поддерживаемый вашей моделью и подходящий для вашего оборудования user_batches = defaultdict(list) batch = [] users_batch = [] for user, seq in sequences: # Наполняем пакет user_batches[user].append(seq) batch.append(seq) users_batch.append(user) # Предсказываем, если пакет полон if len(batch) == batch_size: pred = model.predict(np.array(batch), batch_size=batch_size) for u, p in zip(users_batch, pred): predictions[u].append(p) batch = [] users_batch = [] # Обработка последнего неполного пакета if len(batch) > 0: pred = model.predict(np.array(batch), batch_size=len(batch)) for u, p in zip(users_batch, pred): predictions[u].append(p) return predictions sequence_length = 100 model = load_model('neural_network_model.h5') data_generator = load_data('1.jsonl') sequence_generator = create_sequences(data_generator, sequence_length) predictions = predict_sequences(model, sequence_generator, sequence_length)В приведенном выше коде функция
create_sequencesпреобразована в генератор, который изготавливает последовательности по мере прочтения файла. Это избавляет от необходимости хранения всей выборки в памяти.Функция
predict_sequencesиспользует пакетную обработку для эффективного выполнения прогнозов. На этом этапе необходимо обработать оставшуюся часть данных, если размер пакета не был достигнут.Для визуализации вы можете использовать код отображения, который был предоставлен ранее, но помните, что для больших данных рисование может занять значительное время. Вы можете использовать
plotly.offline.iplotдля визуализации в Jupyter Notebook, чтобы избежать задержек при загрузке больших графиков. - User
predictions[u].append§ ??
- Assistant
Извините, это опечатка. Правильный код должен выглядеть так:
for u, p in zip(users_batch, pred): predictions[u].append(p)В этой строчке кода
predictions[u]ссылается на список прогнозов для конкретного пользователяu. Методappendиспользуется для добавления нового прогнозаpв этот список.Таким образом, прогнозы для каждой последовательности пользователя записываются в словарь
predictions, где ключом является имя пользователя, а значением — список всех прогнозов (в этом контексте прогнозы возвращаются моделью и являются, скорее всего, массивами вероятностей или классов).Давайте исправим этот момент в контексте полного блока для предсказания и накопления результата:
def predict_sequences(model, sequences, sequence_length): predictions = defaultdict(list) user_batches = defaultdict(list) batch = [] users_batch = [] for user, seq in sequences: # Наполняем пакет user_batches[user].append(seq) batch.append(seq) users_batch.append(user) # Предсказываем, если пакет полон if len(batch) == batch_size: pred = model.predict(np.array(batch), batch_size=batch_size) for u, p in zip(users_batch, pred): predictions[u].extend(p) # используем extend, если p - это массив batch.clear() users_batch.clear() # Обработка последнего неполного пакета if batch: pred = model.predict(np.array(batch), batch_size=len(batch)) for u, p in zip(users_batch, pred): predictions[u].extend(p) # используем extend, если p - это массив # Вернуть сглаженные результаты for user in predictions: predictions[user] = np.concatenate(predictions[user], axis=0) return predictionsОбратите внимание, что после предсказания мы используем метод
extend, еслиp— это список или массив. Мы также очищаем списокbatchиusers_batchпосле каждого пакета предсказаний. В конце конструкции мы склеиваем все результаты в массив вероятностей или классов (np.concatenate) чтобы сохранить подготовленные прогнозы в одномерном списке. Это делается для удобства дальнейшего использования прогнозов, например, при построении графика.Пожалуйста, убедитесь, что ваша модель возвращает прогнозы в форме, которая соответствует вашим ожиданиям и тому, как вы хотите их обработать далее.
- User
Ускорь процесс для быстрой обработки и прогноза огромного набора данных. from collections import defaultdict
def load_data(filename): with open(filename, ‘r’, encoding=‘utf-8’) as file: data = [json.loads(line) for line in file] return data
def create_sequences(data, sequence_length): users = defaultdict(list) for event in data: user = event[‘SourceHostname_User’] users[user].append([event[‘EventId’], event[‘ThreadId’], event[‘Image’]])
users = {k: v for k, v in users.items() if len(v) >= sequence_length}
sequences = defaultdict(lambda: np.zeros((0, sequence_length, 3))) for user, events in users.items(): for i in range(len(events) - sequence_length + 1): sequence = events[i:i+sequence_length] sequences[user] = np.vstack((sequences[user], [sequence])) return sequences
data = load_data(‘1.jsonl’) sequence_length = 100 # sequences = create_sequences(data, sequence_length)
from tensorflow.keras.models import load_model model = load_model(‘neural_network_model.h5’)
predictions = defaultdict(list) for user, seq in sequences.items(): pred = model.predict(seq) predictions[user] = pred
import plotly.graph_objs as go from plotly.subplots import make_subplots
def plot_predictions(predictions): fig = make_subplots(rows=len(predictions), cols=1, shared_xaxes=True)
for i, (user, pred) in enumerate(predictions.items(), start=1): x = list(range(len(pred))) y = np.argmax(pred, axis=1) fig.add_trace(go.Scatter(x=x, y=y, mode=‘lines’, name=f’User: {user}'), row=i, col=1)
fig.update_layout(height=300*len(predictions), showlegend=False) fig.update_xaxes(rangeslider_visible=True)
fig.show()
plot_predictions(predictions)
- Assistant
Для оптимизации и ускорения процесса обработки большого набора данных следует использовать потоковую обработку данных, оптимизировать создание последовательностей и выполнять пакетное предсказание. Вот пример того, как это можно сделать:
-
Потоковое чтение данных: Мы будем читать данные построчно, что позволит обрабатывать файлы большого размера без загрузки всего содержимого в память.
-
Оптимизация создания последовательностей: Вместо выполнения операций с
np.vstackмы будем аккумулировать данные в списках. Также проверим длину каждого набора данных для пользователя до цикла, чтобы уменьшить количество нужных итераций. -
Пакетное предсказание: Мы будем группировать последовательности в пакеты и производить предсказание пакетами, что повысит общую производительность модели за счет преимуществ векторизации операций.
from collections import defaultdict import json import numpy as np from tensorflow.keras.models import load_model # Потоковое чтение данных def load_data(filename): with open(filename, 'r', encoding='utf-8') as file: for line in file: yield json.loads(line) # Создание последовательностей def create_sequences(events, sequence_length): sequences = [] if len(events) >= sequence_length: for i in range(len(events) - sequence_length + 1): sequence = events[i:i + sequence_length] sequences.append(sequence) return sequences # Загрузка модели model = load_model('neural_network_model.h5') # Пакетное предсказание и сохранение результатов def predict_sequences(model, data_generator, sequence_length): predictions = defaultdict(list) # Создание последовательностей и предсказания по пользователям users = defaultdict(list) for event in data_generator: user = event['SourceHostname_User'] users[user].append([event['EventId'], event['ThreadId'], event['Image']]) if len(users[user]) == sequence_length: user_sequences = create_sequences(users[user], sequence_length) pred = model.predict(np.array(user_sequences)) predictions[user].extend(pred) users[user].pop(0) return predictions # Генератор данных data_generator = load_data('1.jsonl') # Предсказания sequence_length = 100 predictions = predict_sequences(model, data_generator, sequence_length)Здесь для каждого пользователя мы получаем
sequence_lengthсобытий, затем передаём их в модель для предсказания и добавляем полученные предсказания в список для этого пользователя. Как толькоsequence_lengthдостигнуто для пользователя, старый элемент удаляется.Чтобы отобразить прогнозы используя Plotly, вы можете воспользоваться уже существующей функцией
plot_predictions.Общее время обработки и предсказания будет зависеть от размера данных и производительности компьютера, на котором производится вычисление. Визуализация большого числа строк в Plotly может быть затруднена из-за ограничений производительности браузера.
Помните, что
model.predictможет потребовать много памяти, если вы передаете ей большой список последовательностей. Учитывайте это при работе с очень большими наборами данных, и, возможно, потребуется адаптировать размер пакета (batch_size) в вызовеpredict, чтобы соответствовать ограничениям вашей системы. -
- User
Теперь визуализация Топ 20 популярных юзеров - в представлении временных рядов но не по времени а по номерам прогноза юзера (все кривые начинаются слева и идут как котировка) добавь возможность зума и скролла для jupiter notebook
- Assistant
Для того, чтобы визуализировать прогнозы для Топ 20 самых популярных пользователей (на основе количества событий), мы можем сначала отранжировать пользователей по этому критерию, а затем отобразить временные ряды в виде кривых, где ось X будет соответствовать порядковому номеру прогноза для каждого пользователя, а ось Y — значению прогноза. Для интерактивной визуализации с возможностью зума и скролла в Jupyter Notebook воспользуемся библиотекой Plotly. Вот как это можно реализовать:
import json import numpy as np import plotly.graph_objs as go from collections import defaultdict, Counter from tensorflow.keras.models import load_model # Загрузка данных и подсчет событий для каждого пользователя def load_data(filename): user_counter = Counter() with open(filename, 'r', encoding='utf-8') as file: for line in file: event = json.loads(line) user = event['SourceHostname_User'] user_counter[user] += 1 return user_counter # Получение Топ 20 пользователей user_counter = load_data('1.jsonl') top_users = [user for user, count in user_counter.most_common(20)] # Предсказания могут быть выполнены аналогично предыдущему ответу... # Теперь визуализация Топ 20 пользователей def plot_top_predictions(predictions, top_users): fig = go.Figure() # Добавление кривой для каждого топ пользователя for user in top_users: preds = np.array(predictions.get(user, [])) if len(preds) == 0: continue # Пропустить пользователя, если для него нет прогнозов y = np.argmax(preds, axis=1) x = np.arange(len(y)) # Порядковые номера прогноза для пользователя fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name=user)) # Обновление макета для добавления функций зума и скролла fig.update_layout( height=800, # Выставляем высоту для удобства просмотра width=1000, title='Top 20 User Predictions', xaxis_title='Prediction Number', yaxis_title='Predicted Value', hovermode='x unified' ) fig.update_xaxes(rangeslider_visible=True) fig.update_yaxes(fixedrange=False) # Позволяет зум по оси Y fig.show() plot_top_predictions(predictions, top_users)В этом коде предполагается, что у вас уже есть
predictions, словарь, содержащий прогнозы модели для всех пользователей, как было реализовано ранее.Мы начинаем с функции
load_data, которая читает данные и подсчитывает количество событий для каждого пользователя. Затем выбираем 20 пользователей с наибольшим количеством событий и отображаем их прогнозы в виде временных рядов, где на оси Y отложены результаты прогноза, а на оси X — порядковые номера этих прогнозов.Функция
plot_top_predictionsсоздает интерактивный график с возможностью зума и скролла благодаряrangeslider_visible=Trueиfixedrange=False. Каждая кривая на графике соответствует одному пользователю из Топ 20, а кривые расположены так, что начинаются слева и идут вправо, аналогично графику котировок. - User
NameError Traceback (most recent call last) d:\Users\PopovAI\Desktop\Deep\AI_Test — копия.ipynb Ячейка 6 line 5 47 fig.update_yaxes(fixedrange=False) # Позволяет зум по оси Y 49 fig.show() ---> 51 plot_top_predictions(predictions, top_users)
NameError: name 'predictions' is not defined
- Assistant
Ошибка
NameError: name 'predictions' is not definedуказывает, что переменнаяpredictionsне определена на момент вызова функцииplot_top_predictions(predictions, top_users). Это произошло, потому что в примере кода я пропустил шаг, на которомpredictionsдолжны быть заполнены данными.Чтобы исправить это, вы должны определить
predictionsкак результат выполнения модели на вашем датасете. Предполагается, что вы выполнили предсказание для каждой последовательности данных для каждого пользователя, как это было описано в предыдущем ответе.Пример процесса заполнения
predictionsможет выглядеть так:def predict_sequences(model, data_generator, sequence_length): predictions = defaultdict(list) user_batches = defaultdict(list) batch = [] users_batch = [] for event in data_generator: user = event['SourceHostname_User'] users_batch[user].append([event['EventId'], event['ThreadId'], event['Image']]) if len(users_batch[user]) == sequence_length: user_sequences = np.array(users_batch[user]) pred = model.predict(user_sequences[np.newaxis, :, :], verbose=0) predictions[user].append(pred[0]) # Здесь мы предполагаем, что последовательность для пользователя удалена после предсказания users_batch[user].pop(0) return predictions model = load_model('neural_network_model.h5') # Загрузите свою модель data_generator = load_data('1.jsonl') # Загрузите данные sequence_length = 100 # Установите длину последовательности, которую использует модель predictions = predict_sequences(model, data_generator, sequence_length)После выполнения этого шага у вас должен появиться словарь
predictionsсо значениями, которые можно будет использовать в функцииplot_top_predictionsдля визуализации.Теперь, перед вызовом
plot_top_predictions(predictions, top_users), убедитесь, чтоpredictionsзаполненным результатами предсказания модели, и чтоtop_usersсодержит список Топ 20 пользователей. - User
import json import numpy as np import plotly.graph_objs as go from collections import defaultdict, Counter from tensorflow.keras.models import load_model
Загрузка данных и подсчет событий для каждого пользователя
def load_data(filename): user_counter = Counter() with open(filename, 'r', encoding='utf-8') as file: for line in file: event = json.loads(line) user = event['SourceHostname_User'] user_counter[user] += 1 return user_counter
Получение Топ 20 пользователей
user_counter = load_data('1.jsonl') top_users = [user for user, count in user_counter.most_common(20)]
Предсказания могут быть выполнены аналогично предыдущему ответу…
predictions = defaultdict(list) for user, seq in sequences.items(): pred = model.predict(seq) predictions[user] = pred
Теперь визуализация Топ 20 пользователей
def plot_top_predictions(predictions, top_users): fig = go.Figure()
# Добавление кривой для каждого топ пользователя for user in top_users: preds = np.array(predictions.get(user, [])) if len(preds) == 0: continue # Пропустить пользователя, если для него нет прогнозов y = np.argmax(preds, axis=1) x = np.arange(len(y)) # Порядковые номера прогноза для пользователя fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name=user)) # Обновление макета для добавления функций зума и скролла fig.update_layout( height=800, # Выставляем высоту для удобства просмотра width=1000, title='Top 20 User Predictions', xaxis_title='Prediction Number', yaxis_title='Predicted Value', hovermode='x unified' ) fig.update_xaxes(rangeslider_visible=True) fig.update_yaxes(fixedrange=False) # Позволяет зум по оси Y fig.show() name 'sequences' is not definedplot_top_predictions(predictions, top_users)
- Assistant
Ошибка
name 'sequences' is not definedозначает, что переменнаяsequences, которую вы пытаетесь использовать для предсказания значений, не была определена в текущей области видимости кода.В предыдущем ответе я предположил, что у вас есть словарь
sequences, который содержит последовательности данных для каждого пользователя. Вам нужно будет создать этот словарь перед тем, как использовать его для получения предсказаний. Давайте это исправим и полностью интегрируем весь необходимый код.Перед вычислением предсказаний
predictions, вам необходимо сначала определитьsequences. Это предполагается сделать так:# Функции для загрузки данных и создания последовательностей могут быть реализованы, как показано ранее... # Загрузка модели model = load_model('neural_network_model.h5') # Предсказания для всех пользователей predictions = defaultdict(list) for user, seq in sequences.items(): pred = model.predict(seq) predictions[user].extend(pred) # Теперь переменная predictions забита данными и мы можем передать её функции визуализацииТеперь, когда вы все это объедините, вы должны начать с определения функции
load_data, получитьuser_counter, выделитьtop_users, затем создать последовательности для этих пользователей (предполагая, что у вас есть уже преобразованные данные вsequences), произвести предсказания и визуализировать их.Если вы еще не создали
sequences, вам понадобится следующий код (или аналогичный), чтобы сгенерировать последовательности:# Это функция для создания последовательностей используя генератор данных def create_sequences(data_generator, sequence_length): sequences = defaultdict(list) for event in data_generator: user = event['SourceHostname_User'] # Добавление событий в список для пользователя sequences[user].append([event['EventId'], event['ThreadId'], event['Image']]) # Если достигнута необходимая длина последовательности, сформировать и вернуть её if len(sequences[user]) == sequence_length: yield user, np.array(sequences[user]) sequences[user].pop(0) # Удаление старого события data_generator = load_data('1.jsonl') # или любой другой источник данных sequence_length = 100 sequences = defaultdict(list) for user, seq in create_sequences(data_generator, sequence_length): sequences[user].append(seq)После выполнения этого кода, вы должны получить переменную
sequences, содержащую последовательности данных для каждого пользователя. Теперь вы можете использоватьsequencesдля созданияpredictionsи последующей визуализации. - User
Дай только весь рабочий код для прогноза и визуализации без ошибок
- Assistant
Конечно, вот полный рабочий код, который объединяет загрузку данных, создание последовательностей, выполнение прогнозов и отображение визуализации Топ 20 пользователей:
import json import numpy as np from tensorflow.keras.models import load_model from collections import Counter, defaultdict import plotly.graph_objs as go # Функция для чтения данных и подсчета встречаемости пользователей def load_data(filename): user_counter = Counter() data_by_user = defaultdict(list) with open(filename, 'r', encoding='utf-8') as file: for line in file: event = json.loads(line) user = event['SourceHostname_User'] user_counter[user] += 1 # Сохраняем данные для последующего использования data_by_user[user].append([event['EventId'], event['ThreadId'], event['Image']]) return user_counter, data_by_user # Загрузите модель model = load_model('neural_network_model.h5') # Подготовка данных и создание последовательностей filename = '1.jsonl' sequence_length = 100 # Задайте длину последовательности, соответствующую вашей модели user_counter, data_by_user = load_data(filename) # Выберите Топ-20 пользователей top_users = [user for user, _ in user_counter.most_common(20)] # Создание последовательностей и предсказаний для Топ-20 пользователей predictions = defaultdict(list) for user in top_users: # Создание последовательностей для пользователя events = data_by_user[user] for i in range(len(events) - sequence_length + 1): sequence = np.array(events[i:i + sequence_length]) sequence = sequence.reshape((1, sequence_length, -1)) # Добавление размерности пакета pred = model.predict(sequence) predictions[user].extend(pred) # Функция для визуализации предсказаний def plot_top_predictions(predictions, top_users): fig = go.Figure() # Отображение кривых прогноза для каждого пользователя for user in top_users: preds = np.array(predictions[user]) if len(preds) == 0: continue # Предположим, что модель выводит вероятности классов и нужно выбрать класс с максимальной вероятностью y = np.argmax(preds, axis=1) x = np.arange(len(y)) # Порядковые номера прогноза для пользователя fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name=user)) # Добавление возможностей зума и скролла fig.update_layout( title='Top 20 User Predictions', xaxis_title='Prediction Number', yaxis_title='Predicted Class', hovermode='x unified' ) fig.update_xaxes(rangeslider_visible=True, rangeselector=dict( buttons=list([ dict(count=1, label='1m', step='minute', stepmode='backward'), dict(count=6, label='6h', step='hour', stepmode='todate'), dict(step='all') ]) )) fig.update_yaxes(fixedrange=False) # Разрешить зум и скролл по оси Y fig.show() # Вызов функции для визуализации plot_top_predictions(predictions, top_users)Этот код сначала подготавливает данные, выбирая Топ 20 пользователей и создавая для них последовательности. Затем для каждой последовательности выполняется прогноз с помощью модели. В конце производится визуализация предсказаний всех Топ 20 пользователей с помощью библиотеки Plotly.
Убедитесь, что у вас установлены все зависимости, включая
tensorflow,numpy,plotlyи что модель уже обучена и её структура совместима с форматом входных данных.Обратите внимание, что код для генерации
predictionsзависит от формата входных данных вашей нейросети. Предполагается, что ваша нейросеть работает с последовательностями фиксированной длины, и что каждый элемент последовательности содержит три числа:EventId,ThreadId, иImage.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.