https://huggingface.co/datasets/KillzoneCCO/my-ainex-robot-dataset

#1
by KillzoneCCO - opened
Files changed (4) hide show
  1. README.md +1 -1
  2. app.py +96 -446
  3. gr.Video +0 -67
  4. requirements.txt +1 -6
README.md CHANGED
@@ -4,7 +4,7 @@ emoji: 🤖
4
  colorFrom: green
5
  colorTo: blue
6
  sdk: gradio
7
- sdk_version: 5.38.0
8
  app_file: app.py
9
  pinned: false
10
  ---
 
4
  colorFrom: green
5
  colorTo: blue
6
  sdk: gradio
7
+ sdk_version: 5.37.0
8
  app_file: app.py
9
  pinned: false
10
  ---
app.py CHANGED
@@ -1,464 +1,114 @@
1
  # app.py
2
- from datasets import load_dataset, Dataset, Image as DatasetImage, Value, Array2D, Features
3
  import gradio as gr
4
- import pandas as pd
5
- from PIL import Image as PILImage
6
- import numpy as np
7
- import matplotlib.pyplot as plt
8
- import io
9
- import time
10
- import imageio # Добавляем для создания видео
11
- import os # Для работы с файловой системой (временные файлы)
12
 
13
  # --- Настройки вашего датасета ---
14
- DATASET_REPO_ID = "KillzoneCCO/my-ainex-robot-dataset" # Убедитесь, что это ваш ID репозитория
15
- DATASET_SPLIT = "train"
16
 
17
- # Глобальная переменная для хранения загруженного и сгруппированного датасета
18
- my_episodes = None
19
- dataset_features = None
20
-
21
- # --- Функция загрузки и подготовки данных ---
22
  def load_and_prepare_dataset():
23
- """Загружает датасет с Hugging Face Hub и группирует по эпизодам."""
24
- global my_episodes, dataset_features
25
- print("Attempting to load dataset...")
26
  try:
 
27
  dataset = load_dataset(DATASET_REPO_ID, split=DATASET_SPLIT)
28
- dataset_features = dataset.features # Сохраняем фичи датасета
29
-
30
- if len(dataset) == 0:
31
- error_msg = "Датасет пуст. Нет данных для отображения."
32
- print(error_msg)
33
- my_episodes = {}
34
- # Возвращаем также пустой список для чекбоксов
35
- return error_msg, gr.update(choices=[], value=None), gr.update(choices=[], value=[])
36
-
37
- episodes_data = {}
38
- for i, row in enumerate(dataset):
39
- episode_idx_raw = row.get("episode_index")
40
- if episode_idx_raw is None:
41
- episode_idx_raw = 0
42
- row["episode_index"] = 0
43
- print(f"Warning: 'episode_index' not found for row {i}. Setting to 0.")
44
-
45
- # Используем 1-индексированный номер эпизода для ключа, чтобы совпадать с отображением
46
- episode_idx = int(episode_idx_raw) + 1
47
- if episode_idx not in episodes_data:
48
- episodes_data[episode_idx] = []
49
- episodes_data[episode_idx].append(row)
50
-
51
- # Сортируем шаги внутри каждого эпизода по временной метке, если есть
52
- for episode_idx in episodes_data:
53
- episodes_data[episode_idx].sort(key=lambda x: x.get("timestamp", 0))
54
-
55
- my_episodes = episodes_data
56
- print(f"Dataset loaded. Found {len(my_episodes)} episodes.")
57
-
58
- episode_options = sorted(list(my_episodes.keys()))
59
-
60
- # Определяем опции для чекбоксов сервоприводов
61
- servo_options = [f"Servo_{i+1}" for i in range(25)] # Предполагаем 25 сервоприводов
62
-
63
- # Возвращаем также опции для чекбоксов
64
- return f"Датасет '{DATASET_REPO_ID}' загружен. Найдено {len(my_episodes)} эпизодов.", \
65
- gr.update(choices=episode_options, value=episode_options[0] if episode_options else None), \
66
- gr.update(choices=servo_options, value=servo_options) # Все выбраны по умолчанию
67
  except Exception as e:
68
- error_msg = f"Ошибка при загрузке или подготовке датасета: {e}"
69
- print(error_msg)
70
- my_episodes = {}
71
- return error_msg, gr.update(choices=[], value=None), gr.update(choices=[], value=[])
72
 
73
- # --- Функция для отображения данных конкретного шага ---
74
- def display_step_data(selected_episode_idx, step_idx):
75
- global my_episodes
76
 
77
- # Убедимся, что selected_episode_idx не None
78
- if selected_episode_idx is None:
79
- return "", None, {}, {}, 0.0 # Добавляем timestamp
80
-
81
- if not my_episodes or selected_episode_idx not in my_episodes:
82
- return "Данные эпизода не найдены.", None, {}, {}, 0.0 # Добавляем timestamp
83
-
84
- episode_steps = my_episodes.get(selected_episode_idx)
85
- if not episode_steps:
86
- return "Данные эпизода пусты.", None, {}, {}, 0.0 # Добавляем timestamp
87
-
88
- # Убежимся, что step_idx находится в допустимых границах
89
- if not (0 <= step_idx < len(episode_steps)):
90
- return "Неверный номер шага или шаг вне диапазона.", None, {}, {}, 0.0 # Добавляем timestamp
91
-
92
- step_data = episode_steps[step_idx]
93
-
94
- # Подготовьте информацию о шаге
95
- step_info = (
96
- f"Эпизод: {step_data.get('episode_index', 'N/A')}, "
97
- f"Шаг: {step_idx}/{len(episode_steps)-1}, "
98
- f"Вознаграждение: {step_data.get('reward', 0.0):.2f}, "
99
- f"Завершено: {step_data.get('terminated', False)}, "
100
- f"Усечено: {step_data.get('truncated', False)}, "
101
- f"Timestamp: {step_data.get('timestamp', 0.0):.2f}"
102
- )
103
-
104
- # Обработка изображения
105
- image_pil = None
106
- if 'observation.camera_image_left' in step_data:
107
- img_data = step_data['observation.camera_image_left']
108
- if isinstance(img_data, PILImage.Image):
109
- image_pil = img_data
110
- elif isinstance(img_data, dict) and 'bytes' in img_data:
111
- try:
112
- image_pil = PILImage.open(io.BytesIO(img_data['bytes']))
113
- except Exception as e:
114
- print(f"Error opening image from bytes: {e}")
115
- elif img_data is not None:
116
- print(f"Unexpected image format type: {type(img_data)}")
117
-
118
- # Обработка наблюдений (исключаем image, так как он уже обработан)
119
- observation_data = {}
120
- for k, v in step_data.items():
121
- if k.startswith("observation.") and k != "observation.camera_image_left":
122
- clean_key = k[len("observation."):]
123
- if isinstance(v, np.ndarray):
124
- observation_data[clean_key] = v.squeeze().tolist()
125
- else:
126
- observation_data[clean_key] = v
127
-
128
- # Обработка действий
129
- action_data = {}
130
- for k, v in step_data.items():
131
- if k.startswith("action."):
132
- clean_key = k[len("action."):]
133
- if isinstance(v, np.ndarray):
134
- action_data[clean_key] = v.squeeze().tolist()
135
- else:
136
- action_data[clean_key] = v
137
 
138
- # Возвращаем timestamp для синхронизации видео
139
- current_timestamp = step_data.get('timestamp', 0.0)
140
-
141
- return step_info, image_pil, observation_data, action_data, current_timestamp
142
-
143
- # --- Функция для построения графика начальной позиции ---
144
- def plot_initial_pose(initial_pose_data):
145
- if not initial_pose_data:
146
- return None
147
-
148
- # Сортируем ключи, чтобы порядок сервоприводов был правильным
149
- sorted_keys = sorted(initial_pose_data.keys(), key=lambda x: int(x.split('_')[1]))
150
- servo_ids = [int(k.split('_')[1]) for k in sorted_keys]
151
- positions = [initial_pose_data[k] for k in sorted_keys]
152
-
153
- fig, ax = plt.subplots(figsize=(10, 5))
154
- ax.bar(servo_ids, positions, color='skyblue')
155
- ax.set_title('Начальная позиция сервоприводов', fontsize=14, fontweight='bold')
156
- ax.set_xlabel('ID Сервопривода', fontsize=12)
157
- ax.set_ylabel('Позиция', fontsize=12)
158
- ax.set_xticks(servo_ids) # Убедимся, что все ID сервоприводов отображаются
159
- ax.grid(axis='y', linestyle='--', alpha=0.7)
160
- plt.tight_layout()
161
- return fig
162
-
163
- # --- Функция для обновления информации об эпизоде при выборе ---
164
- def update_episode_info(selected_episode_idx):
165
- global my_episodes
166
- if not my_episodes or selected_episode_idx is None:
167
- # Добавляем пустой список для initial_servo_checkboxes
168
- return gr.update(maximum=0, value=0), "0", "Нет данных", None, {}, {}, None, gr.update(choices=[], value=[])
169
-
170
- episode_steps = my_episodes.get(selected_episode_idx)
171
- if not episode_steps:
172
- return gr.update(maximum=0, value=0), "0", "Нет данных", None, {}, {}, None, gr.update(choices=[], value=[])
173
-
174
- num_steps = len(episode_steps)
175
- if num_steps == 0:
176
- return gr.update(maximum=0, value=0), "0", "Нет данных", None, {}, {}, None, gr.update(choices=[], value=[])
177
-
178
- # Получаем данные для первого шага, чтобы инициализировать UI
179
- step_info, image_pil, observation_data, action_data, _ = display_step_data(selected_episode_idx, 0) # timestamp не нужен здесь
180
-
181
- # Извлекаем начальную позицию сервоприводов (observation.joint_positions первого шага)
182
- initial_joint_positions_dict = {}
183
- if 'joint_positions' in observation_data and observation_data['joint_positions']:
184
- # observation_data['joint_positions'] может быть списком списков, берем первый элемент
185
- flat_positions = np.array(observation_data['joint_positions']).flatten().tolist()
186
- initial_joint_positions_dict = {f"Servo_{i+1}": pos for i, pos in enumerate(flat_positions)}
187
 
188
- # Создаем график начальной позиции
189
- initial_pose_plot = plot_initial_pose(initial_joint_positions_dict)
190
-
191
- # Определяем опции для чекбоксов сервоприводов для графика действий
192
- servo_options = [f"Servo_{i+1}" for i in range(25)]
193
-
194
- return (
195
- gr.update(maximum=num_steps - 1, value=0),
196
- str(num_steps),
197
- step_info,
198
- image_pil,
199
- observation_data,
200
- action_data,
201
- initial_pose_plot, # Возвращаем график начальной позиции
202
- gr.update(choices=servo_options, value=servo_options) # Все выбраны по умолчанию
203
- )
204
-
205
- # --- Функция для построения графика действий с выбором линий ---
206
- def plot_actions_for_episode(selected_episode_idx, selected_servos):
207
- global my_episodes
208
- if not my_episodes or selected_episode_idx is None:
209
- return None
210
- if not selected_servos: # Если ничего не выбрано, возвращаем пустой график
211
- fig, ax = plt.subplots(figsize=(12, 7))
212
- ax.set_title(f'Выберите сервоприводы для отображения', fontsize=14, fontweight='bold')
213
- ax.set_xlabel('Шаг (Step)', fontsize=12)
214
- ax.set_ylabel('Значение команды сервопривода', fontsize=12)
215
- plt.tight_layout()
216
- return fig
217
-
218
- episode_steps = my_episodes.get(selected_episode_idx)
219
- if not episode_steps:
220
- return None
221
-
222
- actions_data = []
223
- for step in episode_steps:
224
- servo_commands = step.get('action.servo_commands')
225
- if servo_commands is not None:
226
- actions_data.append(np.array(servo_commands).flatten().tolist())
227
-
228
- if not actions_data:
229
- return None
230
-
231
- df_data = []
232
- for step_actions in actions_data:
233
- if step_actions:
234
- row = {f'Servo_{i+1}': val for i, val in enumerate(step_actions)}
235
- df_data.append(row)
236
- else:
237
- df_data.append({})
238
-
239
- if not df_data:
240
- return None
241
-
242
- df_actions = pd.DataFrame(df_data)
243
-
244
- fig, ax = plt.subplots(figsize=(12, 7))
245
- for col in selected_servos: # Итерируем только по выбранным сервоприводам
246
- if col in df_actions.columns:
247
- ax.plot(df_actions.index, df_actions[col], label=col, linewidth=1, alpha=0.8)
248
-
249
- ax.set_title(f'Динамика команд сервоприводов для эпизода {selected_episode_idx}', fontsize=14, fontweight='bold')
250
- ax.set_xlabel('Шаг (Step)', fontsize=12)
251
- ax.set_ylabel('Значение команды сервопривода', fontsize=12)
252
- ax.legend(title='Сервопривод', bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=10)
253
- plt.grid(True, linestyle='--', alpha=0.6)
254
- plt.tight_layout(rect=[0, 0, 0.9, 1])
255
- return fig
256
-
257
- # --- Функция для создания видео из изображений эпизода ---
258
- def create_video_from_episode(selected_episode_idx, fps=10):
259
- """
260
- Создает временный MP4 файл из изображений выбранного эпизода.
261
- Возвращает путь к файлу.
262
- """
263
- global my_episodes
264
- if selected_episode_idx is None or selected_episode_idx not in my_episodes or not my_episodes[selected_episode_idx]:
265
- return None
266
-
267
- episode_steps = my_episodes.get(selected_episode_idx)
268
- if not episode_steps:
269
- return None
270
-
271
- images_for_video = []
272
- for step_data in episode_steps:
273
- image_pil = None
274
- if 'observation.camera_image_left' in step_data:
275
- img_data = step_data['observation.camera_image_left']
276
- if isinstance(img_data, PILImage.Image):
277
- image_pil = img_data
278
- elif isinstance(img_data, dict) and 'bytes' in img_data:
279
- try:
280
- image_pil = PILImage.open(io.BytesIO(img_data['bytes']))
281
- except Exception as e:
282
- print(f"Error opening image from bytes: {e}")
283
- elif img_data is not None:
284
- print(f"Unexpected image format type: {type(img_data)}")
285
-
286
- if image_pil:
287
- images_for_video.append(np.array(image_pil)) # Преобразуем PIL Image в NumPy array
288
-
289
- if not images_for_video:
290
- print(f"No images found for episode {selected_episode_idx} to create video.")
291
- return None
292
-
293
- # Создаем временный файл MP4
294
- # Hugging Face Spaces обычно имеют доступ к /tmp/
295
- temp_video_path = f"/tmp/episode_{selected_episode_idx}_{int(time.time())}.mp4"
296
-
297
  try:
298
- # imageio.mimsave требует список NumPy массивов
299
- imageio.mimsave(temp_video_path, images_for_video, fps=fps, codec='libx264', quality=8)
300
- print(f"Video created at: {temp_video_path}")
301
- return temp_video_path
302
  except Exception as e:
303
- print(f"Ошибка при создании видео: {e}")
304
- # Если произошла ошибка, попытаемся удалить недосозданный файл
305
- if os.path.exists(temp_video_path):
306
- os.remove(temp_video_path)
307
- return None
308
 
309
- # --- Функция для синхронизации видео по времени шага ---
310
- def seek_video_to_step_time(selected_episode_idx, step_idx):
311
- global my_episodes
312
- if selected_episode_idx is None or selected_episode_idx not in my_episodes or not my_episodes[selected_episode_idx]:
313
- return None # Не можем перемотать, если нет данных
314
 
315
- episode_steps = my_episodes.get(selected_episode_idx)
316
- if not episode_steps or not (0 <= step_idx < len(episode_steps)):
317
- return None
318
-
319
- # Получаем timestamp первого шага эпизода, чтобы отсчитывать смещение
320
- first_timestamp = episode_steps[0].get('timestamp', 0.0)
321
- current_timestamp = episode_steps[step_idx].get('timestamp', 0.0)
322
-
323
- # Вычисляем относительное время в секундах от начала эпизода
324
- seek_time = current_timestamp - first_timestamp
325
 
326
- # Возвращаем объект gr.Video.update с новой позицией перемотки
327
- # Gradio автоматически обработает это для перемотки видео
328
- return gr.Video(value=None, seek=seek_time) # value=None, чтобы не менять источник видео, только перемотать
329
-
330
- # --- Gradio интерфейс ---
331
- with gr.Blocks() as demo:
332
- gr.Markdown("# Интерактивный просмотр датасета робота Ainex")
333
- gr.Markdown("Загрузите ваш датасет с Hugging Face Hub и исследуйте собранные данные. Нажмите 'Обновить датасет', чтобы загрузить последние данные.")
334
-
335
- with gr.Row():
336
- with gr.Column(scale=1): # Левая колонка
337
- refresh_button = gr.Button("Обновить датасет")
338
- refresh_status = gr.Textbox(label="Статус загрузки датасета", value="Нажмите 'Обновить датасет' для начала.")
339
-
340
- episode_selector = gr.Dropdown(label="Выберите эпизод (1-индексированный)", choices=[], interactive=True)
341
- num_steps_in_episode_output = gr.Textbox(label="Всего шагов в эпизоде", interactive=False)
342
-
343
- with gr.Row():
344
- step_slider = gr.Slider(minimum=0, maximum=0, value=0, label="Выберите шаг (0-индексированный)", step=1, interactive=True, scale=4)
345
- play_video_button = gr.Button("▶️ Воспроизвести видео", scale=1)
346
- video_fps_slider = gr.Slider(minimum=1, maximum=30, value=10, label="FPS видео", step=1, interactive=True)
347
-
348
- # График начальной позиции робота
349
- initial_pose_plot_output = gr.Plot(label="Начальная позиция сервоприводов")
350
-
351
- # Чекбоксы для выбора сервоприводов на графике действий
352
- servo_checkboxes = gr.CheckboxGroup(
353
- label="Выбрать сервоприводы для графика действий",
354
- choices=[f"Servo_{i+1}" for i in range(25)],
355
- value=[f"Servo_{i+1}" for i in range(25)],
356
- interactive=True,
357
- elem_id="servo_checkboxes"
358
- )
359
- # Кнопка для отображения графика действий (остается в левой колонке)
360
- plot_actions_button = gr.Button("Показать график действий")
361
-
362
-
363
- with gr.Column(scale=2): # Правая колонка
364
- step_info_output = gr.Textbox(label="Информация о шаге", interactive=False)
365
- video_output = gr.Video(label="Воспроизведение эпизода", height=480, autoplay=False)
366
- single_image_output = gr.Image(label="Текущий кадр (для слайдера)", type="pil", height=480)
367
-
368
- # Перемещенный график команд сервоприводов (теперь выше)
369
- action_plot_output = gr.Plot(label="График команд сервоприводов")
370
-
371
- # Перемещенные детальные данные (теперь ниже)
372
- with gr.Accordion("Детальные данные", open=True):
373
- observation_output = gr.Json(label="Наблюдения (observation)")
374
- action_output = gr.Json(label="Действия (action)")
375
-
376
- # Удалена нижняя строка с анализом данных
377
- # with gr.Row():
378
- # with gr.Column():
379
- # analysis_text_output = gr.Textbox(label="Результаты анализа", interactive=False)
380
- # analysis_plot_output = gr.Plot(label="Гистограмма положений суставов")
381
- # with gr.Column():
382
- # action_plot_output = gr.Plot(label="График команд сервоприводов") # Это было здесь
383
-
384
- # --- Логика взаимодействия ---
385
- demo.load(
386
- load_and_prepare_dataset,
387
- inputs=None,
388
- outputs=[refresh_status, episode_selector, servo_checkboxes]
389
- ).then(
390
- update_episode_info,
391
- inputs=episode_selector,
392
- outputs=[step_slider, num_steps_in_episode_output, step_info_output, single_image_output, observation_output, action_output, initial_pose_plot_output, servo_checkboxes]
393
- ).then(
394
- # Перерисовываем график действий при смене эпизода
395
- plot_actions_for_episode,
396
- inputs=[episode_selector, servo_checkboxes],
397
- outputs=action_plot_output
398
- )
399
-
400
- episode_selector.change(
401
- update_episode_info,
402
- inputs=episode_selector,
403
- outputs=[step_slider, num_steps_in_episode_output, step_info_output, single_image_output, observation_output, action_output, initial_pose_plot_output, servo_checkboxes]
404
- ).then(
405
- # Перерисовываем график действий при смене эпизода
406
- plot_actions_for_episode,
407
- inputs=[episode_selector, servo_checkboxes],
408
- outputs=action_plot_output
409
- )
410
-
411
- step_slider.change(
412
- display_step_data,
413
- inputs=[episode_selector, step_slider],
414
- outputs=[step_info_output, single_image_output, observation_output, action_output, gr.State()]
415
- ).then(
416
- # Синхронизация видео с ползунком шагов
417
- seek_video_to_step_time,
418
- inputs=[episode_selector, step_slider],
419
- outputs=video_output
420
- )
421
-
422
- refresh_button.click(
423
- load_and_prepare_dataset,
424
- inputs=None,
425
- outputs=[refresh_status, episode_selector, servo_checkboxes]
426
- ).then(
427
- update_episode_info,
428
- inputs=episode_selector,
429
- outputs=[step_slider, num_steps_in_episode_output, step_info_output, single_image_output, observation_output, action_output, initial_pose_plot_output, servo_checkboxes]
430
- ).then(
431
- # Перерисовываем график действий при обновлении датасета
432
- plot_actions_for_episode,
433
- inputs=[episode_selector, servo_checkboxes],
434
- outputs=action_plot_output
435
- )
436
-
437
- # analyze_button.click удален
438
- # analyze_button.click(
439
- # analyze_data,
440
- # inputs=None,
441
- # outputs=[analysis_text_output, analysis_plot_output]
442
- # )
443
-
444
- play_video_button.click(
445
- create_video_from_episode,
446
- inputs=[episode_selector, video_fps_slider],
447
- outputs=[video_output],
448
- queue=False
449
- )
450
-
451
- plot_actions_button.click(
452
- plot_actions_for_episode,
453
- inputs=[episode_selector, servo_checkboxes],
454
- outputs=action_plot_output
455
- )
456
-
457
- # Логика для чекбоксов сервоприводов
458
- servo_checkboxes.change(
459
- plot_actions_for_episode,
460
- inputs=[episode_selector, servo_checkboxes],
461
- outputs=action_plot_output
462
- )
463
-
464
- demo.launch(debug=True)
 
1
  # app.py
2
+ from datasets import load_dataset, Dataset
3
  import gradio as gr
4
+ import pandas as pd # Для удобства работы с данными
 
 
 
 
 
 
 
5
 
6
  # --- Настройки вашего датасета ---
7
+ DATASET_REPO_ID = "KillzoneCCO/my-ainex-robot-dataset"
8
+ DATASET_SPLIT = "train" # Обычно датасеты имеют сплит 'train', 'validation', 'test'
9
 
10
+ # --- Функция загрузки данных ---
 
 
 
 
11
  def load_and_prepare_dataset():
12
+ """Загружает датасет с Hugging Face Hub."""
 
 
13
  try:
14
+ # Загружаем ваш датасет
15
  dataset = load_dataset(DATASET_REPO_ID, split=DATASET_SPLIT)
16
+ return dataset
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
17
  except Exception as e:
18
+ return f"Ошибка при загрузке датасета: {e}"
 
 
 
19
 
20
+ # Глобальная переменная для хранения датасета
21
+ # Это загрузит датасет один раз при запуске Space
22
+ my_dataset = load_and_prepare_dataset()
23
 
24
+ # --- Функции для Gradio интерфейса ---
25
+ def get_dataset_info():
26
+ """Возвращает общую информацию о датасете."""
27
+ if isinstance(my_dataset, str): # Если была ошибка загрузки
28
+ return my_dataset
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
29
 
30
+ info = f"Датасет загружен: {DATASET_REPO_ID}\n"
31
+ info += f"Количество записей: {len(my_dataset)}\n"
32
+ info += f"Особенности (столбцы): {list(my_dataset.features.keys())}\n\n"
33
+ info += "Пример первых 5 записей (столбцы observation.camera_image_left, action.arm_command):\n"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
34
 
35
+ # Попытка извлечь нужные столбцы
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
36
  try:
37
+ sample_df = pd.DataFrame(my_dataset[:5])
38
+ # Фильтруем столбцы для отображения, чтобы не перегружать интерфейс
39
+ display_cols = [col for col in sample_df.columns if "observation." in col or "action." in col]
40
+ return info + sample_df[display_cols].to_string()
41
  except Exception as e:
42
+ return info + f"Не удалось отобразить пример данных: {e}\nВозможно, у вас другие названия столбцов или типы данных. Проверьте ваш датасет на HF Hub."
 
 
 
 
43
 
 
 
 
 
 
44
 
45
+ def view_record_by_index(index: int):
46
+ """Отображает одну запись по индексу."""
47
+ if isinstance(my_dataset, str):
48
+ return my_dataset
 
 
 
 
 
 
49
 
50
+ if 0 <= index < len(my_dataset):
51
+ record = my_dataset[index]
52
+ output = f"--- Запись #{index} ---\n\n"
53
+
54
+ # Отобразим основные поля
55
+ output += f"Вознаграждение (reward): {record.get('reward', 'N/A')}\n"
56
+ output += f"Завершено (terminated): {record.get('terminated', 'N/A')}\n"
57
+ output += f"Сокращено (truncated): {record.get('truncated', 'N/A')}\n"
58
+ output += f"Индекс эпизода (episode_index): {record.get('episode_index', 'N/A')}\n"
59
+ output += f"Временная метка (timestamp): {record.get('timestamp', 'N/A')}\n\n"
60
+
61
+ output += "--- Наблюдение (Observation) ---\n"
62
+ for key, value in record.items():
63
+ if key.startswith("observation."):
64
+ output += f"{key.replace('observation.', '')}: {value}\n"
65
+
66
+ output += "\n--- Действие (Action) ---\n"
67
+ for key, value in record.items():
68
+ if key.startswith("action."):
69
+ output += f"{key.replace('action.', '')}: {value}\n"
70
+
71
+ # Если есть поле с изображением, попробуем его показать
72
+ # Предполагаем, что изображение хранится как Pillow Image или путь к файлу
73
+ # Если у вас изображения представлены как массивы numpy, потребуется дополнительная обработка
74
+ if "observation.image" in record: # Или другое название вашего поля с изображением
75
+ # Здесь вам, возможно, потребуется преобразовать данные изображения,
76
+ # если они не являются напрямую отображаемым форматом (например, numpy array)
77
+ # В этом примере просто выведем информацию о нем
78
+ output += f"\nИзображение (observation.image): (наличие, тип: {type(record['observation.image'])})\n"
79
+ elif "observation.camera_image_left" in record:
80
+ output += f"\nИзображение (observation.camera_image_left): (наличие, тип: {type(record['observation.camera_image_left'])})\n"
81
+
82
+ return output
83
+ else:
84
+ return "Неверный индекс записи. Пожалуйста, введите число в диапазоне от 0 до " + str(len(my_dataset) - 1)
85
+
86
+ # --- Создаем Gradio интерфейс ---
87
+ if isinstance(my_dataset, Dataset): # Только если датасет успешно загружен
88
+ with gr.Blocks() as demo:
89
+ gr.Markdown(f"# Визуализация датасета `{DATASET_REPO_ID}`")
90
+ gr.Markdown("Здесь вы можете просмотреть информацию о вашем собранном датасете робота.")
91
+
92
+ with gr.Tab("Общая информация"):
93
+ info_output = gr.Textbox(label="Информация о датасете", lines=15)
94
+ get_info_btn = gr.Button("Загрузить информацию")
95
+ get_info_btn.click(get_dataset_info, outputs=info_output)
96
+
97
+ with gr.Tab("Просмотр записей по индексу"):
98
+ record_index_input = gr.Number(label="Индекс записи", value=0, precision=0)
99
+ record_output = gr.Textbox(label="Содержимое записи", lines=20)
100
+ view_record_btn = gr.Button("Показать запись")
101
+ view_record_btn.click(view_record_by_index, inputs=record_index_input, outputs=record_output)
102
+
103
+ gr.Markdown("---")
104
+ gr.Markdown("Названия столбцов 'observation.*' и 'action.*' берутся из вашего `collect_data.py`.")
105
+ gr.Markdown("Если у вас есть изображения, они могут отображаться здесь. Возможно, потребуется дополнительная доработка для корректного отображения изображений.")
106
+
107
+ else: # Если произошла ошибка при загрузке датасета
108
+ with gr.Blocks() as demo:
109
+ gr.Markdown(f"# Ошибка загрузки датасета")
110
+ gr.Textbox(value=my_dataset, label="Сообщение об ошибке")
111
+
112
+
113
+ # Запуск приложения Gradio
114
+ demo.launch()
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
gr.Video DELETED
@@ -1,67 +0,0 @@
1
- http://googleusercontent.com/immersive_entry_chip/0
2
-
3
-
4
- **Что изменено в Подходе 1:**
5
-
6
- 1. **`import imageio` и `import os`**: Добавлены в начале файла.
7
- 2. **Удалена `playback_active` и `play_steps` / `stop_playback`**: Эти функции были для имитации видео. Теперь мы создаем настоящий видеофайл.
8
- 3. **Новая функция `create_video_from_episode(selected_episode_idx, fps)`**:
9
- * Эта функция собирает все изображения из выбранного эпизода.
10
- * Преобразует их в массивы NumPy (требование `imageio`).
11
- * Использует `imageio.mimsave()` для сохранения последовательности изображений в файл MP4 во временной директории `/tmp/`.
12
- * Возвращает путь к созданному MP4-файлу.
13
- * Добавлен параметр `fps` (кадры в секунду) для контроля скорости видео.
14
- 4. **Изменения в Gradio интерфейсе (`gr.Blocks`):**
15
- * `image_output` заменен на `video_output = gr.Video(...)`. Этот компонент Gradio предназначен для отображения видеофайлов.
16
- * Добавлена новая кнопка `play_video_button = gr.Button("▶️ Воспроизвести видео")`.
17
- * Добавлен слайдер `video_fps_slider` для настройки FPS видео.
18
- * Добавлен `single_image_output = gr.Image(...)` для отображения отдельного кадра при движении слайдера, так как `gr.Video` не будет показывать отдельные кадры при ручной навигации.
19
- 5. **Изменения в логике взаимодействия (`demo.load`, `episode_selector.change`, `step_slider.change`):**
20
- * Выходы этих функций теперь обновляют `single_image_output` вместо `image_output`, чтобы слайдер по-прежнему работал с отдельными кадрами.
21
- 6. **Логика для `play_video_button.click`**:
22
- * При нажатии на эту кнопку вызывается `create_video_from_episode`, которая генерирует MP4-файл.
23
- * Выход `create_video_from_episode` (путь к файлу) передается в `video_output`. Gradio автоматически загрузит и воспроизведет этот файл.
24
- * `queue=False` по-прежнему важен, чтобы UI не зависал во время создания видео.
25
-
26
- ---
27
-
28
- ### Подход 2: Имитация видео путем быстрого обновления изображения
29
-
30
- Этот подход использует генератор Gradio для последовательного обновления компонента `gr.Image` с задержкой, создавая иллюзию видео. Это может быть менее плавно, чем настоящий видеофайл, но не требует создания временных файлов.
31
-
32
- ```python
33
-
34
- http://googleusercontent.com/immersive_entry_chip/1
35
-
36
-
37
- **Что изменено в Подходе 2:**
38
-
39
- 1. **`playback_active`**: Глобальная переменная для контроля состояния воспроизведения.
40
- 2. **`play_steps_generator(selected_episode_idx, initial_step, playback_speed_sec)`**:
41
- * Это функция-генератор, которая `yield`'ит обновления для нескольких компонентов Gradio.
42
- * `initial_step` используется для того, чтобы воспроизведение начиналось с текущей позиции слайдера.
43
- * `playback_speed_sec` контролирует задержку между обновлениями кадров.
44
- * Внутри цикла `for` она вызывает `display_step_data` для получения информации о текущем шаге, изображении, наблюдениях и действиях.
45
- * `yield` используется для отправки этих данных в соответствующие выходные компоненты Gradio.
46
- * `time.sleep(playback_speed_sec)` создает паузу, имитируя скорость воспроизведения.
47
- * После завершения цикла, она `yield`'ит последний кадр, чтобы слайдер остался на последнем шаге.
48
- 3. **`stop_playback(current_step)`**:
49
- * Эта функция устанавливает `playback_active = False`, что прерывает цикл в `play_steps_generator`.
50
- * Возвращает сообщение о статусе и текущий шаг слайдера.
51
- 4. **`playback_speed_slider`**: Новый компонент `gr.Slider` для управления скоростью воспроизведения (задержкой между кадрами).
52
- 5. **Изменения в `play_button.click`**:
53
- * `inputs`: Теперь включает `episode_selector`, `step_slider` (для получения текущего шага) и `playback_speed_slider`.
54
- * `outputs`: Теперь включает все компоненты, которые обновляет `play_steps_generator`: `step_slider`, `step_info_output`, `image_output`, `observation_output`, `action_output`.
55
- * `queue=False`: Это **критически важно** для плавного воспроизведения, так как позволяет Gradio не блокировать UI, пока генератор работает.
56
- 6. **Изменения в `stop_button.click`**:
57
- * `inputs`: Теперь включает `step_slider` (для сохранения его текущего значения).
58
- * `outputs`: Обновляет `refresh_status` сообщением об остановке и `step_slider` его текущим значением.
59
-
60
- ---
61
-
62
- **Рекомендации:**
63
-
64
- * **Для "настоящего" видео:** Если для вас важно, чтобы это было именно видео (с возможностью перемотки, паузы, воспроизведения как единого файла), то **Подход 1** с `gr.Video` является лучшим выбором. Он будет более производительным для длинных эпизодов, так как видео генерируется один раз.
65
- * **Для интерактивного просмотра кадров:** Если вам важнее возможность пошагово просматривать кадры, а "видео" - это просто удобный способ быстрого перелистывания, то **Подход 2** может быть достаточным. Однако он может быть менее плавным и более ресурсоемким для очень быстрых или длинных последовательностей.
66
-
67
- Выберите тот подход, который лучше соответствует вашим потребностям и ограничениям Hugging Face Spaces. Убедитесь, что вы добавили `imageio` в ваш `requirements.txt` файл на Hugging Face Spaces, если вы используете Подход 1.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
requirements.txt CHANGED
@@ -1,9 +1,4 @@
1
- gradio
2
  datasets
 
3
  pandas
4
- numpy
5
- matplotlib
6
- Pillow
7
- imageio
8
- imageio-ffmpeg
9
  huggingface_hub
 
 
1
  datasets
2
+ gradio
3
  pandas
 
 
 
 
 
4
  huggingface_hub