Upload 11 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+media/emotions_detect.png filter=lfs diff=lfs merge=lfs -text
+media/result_video.mp4 filter=lfs diff=lfs merge=lfs -text

Image_Detection.py

@@ -0,0 +1,109 @@
+import io
+import cv2
+import numpy as np
+from PIL import Image
+import streamlit as st
+
+
+# ===================== Настройки страницы ======================
+
+st.set_page_config(
+    layout='wide',
+    initial_sidebar_state='auto',
+    page_title='Face Emotion Recognition',
+    page_icon='👻',
+    )
+
+st.write("#### Детекция лиц, эмоций, пола, расы и возраста на изображении")
+
+# отображение картинки с примерами детекции
+@st.cache_data
+def load_main_image(image_path: str) -> Image.Image:
+    main_pil_image = Image.open(image_path)
+    return main_pil_image
+
+MAIN_IMAGE_PATH = './media/emotions_detect.png'
+main_pil_image = load_main_image(MAIN_IMAGE_PATH)
+st.image(main_pil_image, width=800)
+
+# ===================== Боковое меню настроек ======================
+
+st.sidebar.header('Настройки')
+st.sidebar.write('---')
+
+face_conf_threshold = st.sidebar.slider(
+    label='Порог уверенности для детекции лиц',
+    min_value=0.0,
+    max_value=1.0,
+    value=0.7,
+    step=0.01,
+    )
+st.sidebar.write('---')
+
+# какие действия нужно детектить (пока не реализовано переключение)
+actions = ['age', 'gender', 'race', 'emotion']
+# применять ли дополнительное выравнивание
+st.sidebar.write('Применять ли дополнительное выравнивание')
+align = st.sidebar.checkbox(label='Align', value=False)
+
+
+# загрузка и инициализация моделей
+with st.spinner('Инициализация/загрузка моделей...'):
+    from detector import detector_model
+
+# ==================== Загрузка изображения и распознавание ============
+
+st_image = st.file_uploader(label='Выберите изображение')
+st.session_state['detect_image_ready'] = False
+
+if st_image:
+    pil_image = Image.open(st_image)
+    np_image_rgb = np.array(pil_image)
+    
+    np_image_bgr = cv2.cvtColor(np_image_rgb, cv2.COLOR_RGB2BGR)
+    st.image(np_image_bgr, width=400, channels='BGR')
+    
+    # ================ Кнопка распознать ==================    
+
+    if st.button('Распознать'):
+        if detector_model.is_first_run:
+            spinner_text = 'Первоначальная инициализация моделей и распознавание фото...'
+        else:
+            spinner_text = 'Распознавание фото ...'
+
+        with st.spinner(spinner_text):
+            detections = detector_model.detect_image(
+                np_image_bgr, 
+                actions=actions,
+                align=align,
+                )
+            detector_model.is_first_run = False
+
+        with st.spinner('Отрисовка результата'):
+            result_np_image = detector_model.draw_detections(
+                np_image_rgb=np_image_rgb,
+                detections=detections,
+                face_conf_threshold=face_conf_threshold,
+                )
+            st.session_state['detect_image_ready'] = True
+
+# отображение результата детекции
+if st.session_state['detect_image_ready']:
+    st.image(result_np_image)
+
+    # сохранение картинки с результатом чтобы ее скачать
+    image_name = f"{st_image.name.split('.')[0]}_detect.png"
+    file_buffer = io.BytesIO()
+    result_pil_image = Image.fromarray(result_np_image)
+    result_pil_image.save(file_buffer, format='PNG')
+    image_bytes = file_buffer.getvalue()
+    
+    # ================ Кнопка скачать ================== 
+
+    st.download_button(
+        label='Скачать изображение', 
+        data=image_bytes, 
+        file_name=image_name,
+        mime='image/png',
+        )
+    st.session_state['detect_image_ready'] = False

detector.py

@@ -0,0 +1,263 @@
+import os
+from pathlib import Path
+from dataclasses import dataclass
+from typing import Generator
+
+import cv2
+import numpy as np
+import pandas as pd
+
+from PIL import Image, ImageDraw, ImageFont
+from ffmpeg import FFmpeg
+
+# установка пути куда будут скачиваться модели DeepFace
+MODELS_DIR = Path('models')
+os.environ['DEEPFACE_HOME'] = str(MODELS_DIR)
+
+
+# настройка Tensorflow чтобы не вылетало если мало памяти
+import tensorflow as tf
+
+os.environ['TF_GPU_ALLOCATOR'] = 'cuda_malloc_async'
+gpus = tf.config.experimental.list_physical_devices('GPU')
+if gpus:
+    try:
+        for gpu in gpus:
+            tf.config.experimental.set_memory_growth(gpu, True)
+    except RuntimeError as ex:
+        print(ex)
+
+
+from deepface import DeepFace
+
+
+# словарь для детекции одного лица который возвращает библиотека DeepFace
+DEEPFACE_DICT = dict[str, str | int | float | dict[str, str | int | float | None]]
+
+# датакласс для хранения результатов детекции
+# если лиц не обнаружено (face_conf = 0) то устанавливает все значения на None
+@dataclass
+class DetectResult:
+    face_conf: float | None = None
+    gender: str | None = None
+    gender_conf: float | None = None
+    age: int | None = None
+    race: str | None = None
+    race_conf: float | None = None
+    emotion: str | None = None
+    emotion_conf: float | None = None
+    x: int | None = None
+    y: int | None = None
+    w: int | None = None
+    h: int | None = None
+
+
+    # если лиц не обнаружено (face_conf = 0) то устанавливает все значения на None
+    def __post_init__(self):
+        if self.face_conf == 0:
+            self.__dict__.update(DetectResult().__dict__)
+
+
+    # формирование экземпляра из словаря, который возвращает библиотека DeepFace
+    @classmethod
+    def from_dict(cls, detect_dict: DEEPFACE_DICT):
+        return cls(
+            face_conf=detect_dict['face_confidence'],
+            gender=detect_dict['dominant_gender'],
+            gender_conf=detect_dict['gender'][detect_dict['dominant_gender']],
+            age=detect_dict['age'],
+            race=detect_dict['dominant_race'],
+            race_conf=detect_dict['race'][detect_dict['dominant_race']],
+            emotion=detect_dict['dominant_emotion'],
+            emotion_conf=detect_dict['emotion'][detect_dict['dominant_emotion']],
+            x=detect_dict['region']['x'],
+            y=detect_dict['region']['y'],
+            w=detect_dict['region']['w'],
+            h=detect_dict['region']['h'],
+        )
+
+
+    # вернуть текущий экземпляр в качестве словаря
+    def as_dict(self):
+        return self.__dict__
+
+
+    # получить названия атрибутов экземпляра
+    def keys(self):
+        return self.__dict__.keys()
+
+
+    # видоизменить текстовое представление экземпляра
+    def __repr__(self):
+        if self.face_conf is None:
+            repr_text = f'DetectResult(face_conf=None'
+        else:
+            repr_text = 'DetectResult(\n  ' + \
+                '\n  '.join([f'{k}={v}' for k, v in self.as_dict().items()])
+        return repr_text + '\n)\n'
+
+
+class Detector:
+    def __init__(self):
+        self.box_color = 'red'
+        self.text_color = 'yellow'
+        self.fill_color = 'black'
+        self.font_path = 'fonts/LiberationMono-Regular.ttf'
+        self.font_scale = 40  # чем меньше тем больше шрифт
+        self.detections_all_frames = []
+        self.save_video_path = 'result_video.mp4'
+        self.result_csv_path = 'video_annotations.csv'
+        # opencv, yunet, centerface, dlib, ssd, fastmtcnn
+        self.detector_backend = 'ssd'
+        weights_dir = MODELS_DIR / '.deepface' / 'weights'
+        self.is_first_run = True
+
+        if Path(self.result_csv_path).is_file():
+            Path(self.result_csv_path).unlink(missing_ok=True)
+
+        if len(list(weights_dir.iterdir())) == 0:
+            self.first_detect_and_load_weights()
+
+
+    # детекция случайной картинки из шума чтобы при первом запуске загрузились веса
+    def first_detect_and_load_weights(self):
+        DeepFace.analyze(
+            img_path=np.random.randint(0, 256, size=(28, 28, 3), dtype=np.uint8),
+            actions=['age', 'gender', 'race', 'emotion'],
+            detector_backend=self.detector_backend,
+            align=False,
+            enforce_detection=False,
+            silent=True,
+            )
+
+
+    # детекция одного изображения, возаращает список со словарями результатов детекций
+    def detect_image(self, image: str | np.ndarray, actions: list[str], align: bool) -> list[DetectResult]:
+        detection_dicts = DeepFace.analyze(
+            img_path=image,
+            actions=actions,
+            detector_backend=self.detector_backend,
+            align=align,
+            enforce_detection=False,
+            silent=True,
+            )
+        detections = [DetectResult.from_dict(detection) for detection in detection_dicts]
+        return detections
+
+
+    # отрисовка результатов для детекций
+    def draw_detections(
+            self,
+            np_image_rgb: np.ndarray,
+            detections: list[DetectResult],
+            face_conf_threshold: float,
+            ) -> np.ndarray:
+        pil_image = Image.fromarray(np_image_rgb)
+        draw = ImageDraw.Draw(pil_image)
+        font_size = pil_image.size[1] // self.font_scale
+        # font = ImageFont.load_default(size=font_size)
+        font = ImageFont.truetype(self.font_path, size=font_size)
+        for detection in detections:
+            if detection.face_conf is not None:
+                if detection.face_conf > face_conf_threshold:
+                    x, y, w, h = detection.x, detection.y, detection.w, detection.h
+                    text = f'{detection.gender},{detection.age},{detection.race},{detection.emotion}'
+                    draw.rectangle((x, y, x + w, y + h), outline=self.box_color, width=6)
+                    _, _, text_width, text_height = font.getbbox(text)
+                    if (x + text_width) > pil_image.size[0]:
+                        x -= text_width / 2
+                    draw.rectangle(xy=(x, y - text_height, x + text_width, y), fill=self.fill_color)
+                    draw.text(xy=(x, y), text=text, font=font, fill=self.text_color, anchor='lb')
+        return np.array(pil_image)
+
+
+    # функция - генератор для детекция видео, который детектит кадры видео в цикле
+    # возвращает номер текущего кадра и общее кол-во кадров, чтобы сделать внешний прогресс бар
+    def detect_video(
+            self,
+            video_file: str | Path,
+            actions: list[str],
+            align: bool,
+            face_conf_threshold: float,
+            ) -> Generator[tuple[int, int], None, None]:
+
+        cap_read = cv2.VideoCapture(str(video_file))
+        frames_width = int(cap_read.get(cv2.CAP_PROP_FRAME_WIDTH))
+        frames_height = int(cap_read.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        frames_fps = int(cap_read.get(cv2.CAP_PROP_FPS))
+        total_frames = int(cap_read.get(cv2.CAP_PROP_FRAME_COUNT))
+
+        cap_write = cv2.VideoWriter(
+            filename=self.save_video_path,
+            fourcc=cv2.VideoWriter_fourcc(*'mp4v'),
+            fps=frames_fps,
+            frameSize=(frames_width, frames_height),
+            )
+
+        self.detections_all_frames = []
+        frames_count = 0
+
+        while cap_read.isOpened():
+            ret, np_image_bgr = cap_read.read()
+            if not ret:
+                break
+            detections = self.detect_image(
+                image=np_image_bgr,
+                actions=actions,
+                align=align,
+                )
+            self.detections_all_frames.append(detections)
+
+            if detections[0].face_conf is not None:
+                np_image_rgb = cv2.cvtColor(np_image_bgr, cv2.COLOR_BGR2RGB)
+                result_np_image = self.draw_detections(
+                    np_image_rgb=np_image_rgb,
+                    detections=detections,
+                    face_conf_threshold=face_conf_threshold,
+                )
+                np_image_bgr = cv2.cvtColor(result_np_image, cv2.COLOR_RGB2BGR)
+
+            cap_write.write(np_image_bgr)
+            frames_count += 1
+            yield (frames_count, total_frames)
+
+        cap_write.release()
+        cap_read.release()
+
+
+    # создание датафрейма из словарей с результатами детекции
+    # каждая строка датафрейма - порядковый номер кадра из видео
+    # если на кадре ничего нет то все значения кроме номера кадра и времени видео будут None
+    # если на кадре несколько лиц - номера кадров и время видео будут дублироваться
+    def detections_to_df(self) -> pd.DataFrame:
+        if not Path(self.save_video_path).exists():
+            print('Нет видео с результатами детекции')
+            return None
+
+        if len(self.detections_all_frames) == 0:
+            print('Не найдено ни одного объекта')
+            return None
+
+        cap_read = cv2.VideoCapture(str(self.save_video_path))
+        frames_fps = int(cap_read.get(cv2.CAP_PROP_FPS))
+        cap_read.release()
+
+        df_list = []
+        for frame_num, detections in enumerate(self.detections_all_frames, start=1):
+            for detection in detections:
+                df_list.append({'frame_num': frame_num, **detection.as_dict()})
+
+        df = pd.DataFrame(df_list)
+        df.insert(loc=1, column='frame_sec', value=df.frame_num / frames_fps)
+        df['face_detected'] = df['gender'].notna().astype(int)
+        df.to_csv(self.result_csv_path, index=False)
+        return self.result_csv_path
+
+
+    # конвертация в mp4
+    @staticmethod
+    def convert_mp4(input_video_path: str | Path, output_video_path: str | Path) -> None:
+        ffmpeg = FFmpeg().option('y').input(input_video_path).output(output_video_path)
+        ffmpeg.execute()
+
+detector_model = Detector()

draw_utils.py

@@ -0,0 +1,238 @@
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+import streamlit as st
+
+
+plt.style.use('dark_background')
+plt.rcParams.update({'figure.figsize': (7, 1.5)})
+plt.rcParams.update({'font.size': 5})
+
+
+def draw_plots(df: pd.DataFrame) -> None:
+    df_clean = df.dropna(subset=['face_conf'])
+    
+    st.write('---')
+    st.write('Количество детекций по возрасту и по уверенности модели')
+
+    fig, axes = plt.subplots(1, 2)
+    sns.histplot(df_clean['age'], kde=True, ax=axes[0])
+    axes[0].set_title('Распределение возраста')
+    axes[0].set_xlabel('Возраст')
+    axes[0].set_ylabel('Количество обнаружений')
+    sns.histplot(df_clean['face_conf'], kde=True, ax=axes[1])
+    axes[1].set_title('Распределение уверенности детекций')
+    axes[1].set_xlabel('Уверенность')
+    axes[1].set_ylabel('Количество обнаружений')
+
+
+    st.pyplot(fig, use_container_width=False)
+    st.write('---')
+    st.write('Распределение уверенности модели по классам пола и эмоций')
+
+
+    fig, axes = plt.subplots(1, 2)
+    sns.boxplot(
+        data=df_clean,
+        x='gender',
+        y='face_conf',
+        hue='gender',
+        palette='hls',
+        ax=axes[0],
+        )
+    axes[0].set_title('Распределение уверенности детекций по полу')
+    axes[0].set_xlabel('Пол')
+    axes[0].set_ylabel('Уверенность')
+    # axes[0].tick_params(axis='x', labelrotation=45)
+    sns.boxplot(
+        data=df_clean,
+        x='emotion',
+        y='face_conf',
+        hue='emotion',
+        palette='hls',
+        ax=axes[1],
+        )
+    axes[1].set_title('Распределение уверенности детекций по эмоциям')
+    axes[1].set_xlabel('Эмоция')
+    axes[1].set_ylabel('Уверенность')
+
+
+    st.pyplot(fig, use_container_width=False)
+    st.write('---')
+    st.write('Количество детекций по классам эмоций и пола')
+
+
+    fig, axes = plt.subplots(1, 2)
+    sns.countplot(
+        data=df_clean,
+        x='emotion',
+        hue='emotion',
+        order=df_clean['emotion'].value_counts().index, 
+        palette='viridis',
+        legend=False,
+        ax=axes[0],
+        )
+    axes[0].set_title('Количество обнаружений эмоций')
+    axes[0].set_xlabel('Эмоция')
+    axes[0].set_ylabel('Количество')
+    sns.countplot(
+        data=df_clean,
+        x='gender',
+        hue='gender',
+        order=df_clean['gender'].value_counts().index, 
+        palette='Set2',
+        legend=False,
+        ax=axes[1],
+        )
+    axes[1].set_title('Количество обнаружений пола')
+    axes[1].set_xlabel('Пол')
+    axes[1].set_ylabel('Количество')
+
+
+    st.pyplot(fig, use_container_width=False)
+    st.write('---')
+    st.write('Количество детекций по классу эмоций в зависимости от пола и расы')
+
+
+    fig, axes = plt.subplots(1, 2)
+    sns.countplot(
+        data=df_clean,
+        x='emotion',
+        hue='gender',
+        palette='viridis',
+        order=df_clean['emotion'].value_counts().index,
+        ax=axes[0],
+        )
+    axes[0].set_title('Распределение пола по эмоциям')
+    axes[0].set_xlabel('Эмоция')
+    axes[0].set_ylabel('Количество')
+    axes[0].legend(title='Пол')
+    sns.countplot(
+        data=df_clean,
+        x='emotion',
+        hue='race',
+        palette='viridis',
+        order=df_clean['emotion'].value_counts().index,
+        ax=axes[1],
+        )
+    axes[1].set_title('Распределение рас по эмоциям')
+    axes[1].set_xlabel('Эмоция')
+    axes[1].set_ylabel('Количество')
+    axes[1].legend(title='Раса')
+
+
+    st.pyplot(fig, use_container_width=False)
+    st.write('---')
+    st.write('Кадры и секунды с наибольшим количеством детекций')
+
+
+    fig, axes = plt.subplots(1, 2)
+    face_count_per_frame = df.groupby('frame_num')['face_detected'].sum()
+    axes[0].plot(face_count_per_frame.index, face_count_per_frame.values, marker='o', linestyle='-')
+    axes[0].set_title('Частота обнаружения лиц по кадрам')
+    axes[0].set_xlabel('Номер кадра')
+    axes[0].set_ylabel('Количество обнаруженных лиц')
+    face_count_per_frame = df.groupby('frame_sec')['face_detected'].sum()
+    axes[1].plot(face_count_per_frame.index, face_count_per_frame.values, marker='o', linestyle='-')
+    axes[1].set_title('Частота обнар��жения лиц по секундам')
+    axes[1].set_xlabel('Время (сек)')
+    axes[1].set_ylabel('Количество обнаруженных лиц')
+
+
+    st.pyplot(fig, use_container_width=False)
+    st.write('---')
+    st.write('Какие классы в какое время были обнаружены (по эмоциям)')
+
+
+    fig, ax = plt.subplots(1, 1)
+    sns.scatterplot(
+        data=df_clean, 
+        x='frame_sec', 
+        y='emotion', 
+        hue='emotion', 
+        palette='deep', 
+        s=50, 
+        alpha=0.6, 
+        legend=True,
+        ax=ax,
+        )
+    ax.set_title('Временная шкала обнаружения лиц по эмоциям')
+    ax.set_xlabel('Время видео (секунды)')
+    ax.set_ylabel('Эмоция')
+    ax.grid(True, linestyle='--', alpha=0.7)
+    ax.legend(title='Классы эмоций', bbox_to_anchor=(1.05, 1), loc='upper left')
+
+
+    st.pyplot(fig, use_container_width=False)
+    st.write('---')
+    st.write('Какие классы в какое время были обнаружены (по полу)')
+
+
+    fig, ax = plt.subplots()
+    sns.scatterplot(
+        data=df_clean, 
+        x='frame_sec', 
+        y='gender', 
+        hue='gender', 
+        palette='deep', 
+        s=50, 
+        alpha=0.6, 
+        legend=True,
+        ax=ax,
+        )
+    ax.set_title('Временная шкала обнаружения лиц по полу')
+    ax.set_xlabel('Время видео (секунды)')
+    ax.set_ylabel('Пол')
+    ax.grid(True, linestyle='--', alpha=0.7)
+    ax.legend(title='Классы пола', bbox_to_anchor=(1.05, 1), loc='upper left')
+
+
+    st.pyplot(fig, use_container_width=False)
+    st.write('---')
+    st.write('Какие классы в какое время были обнаружены (по расе)')
+
+
+    fig, ax = plt.subplots()
+    sns.scatterplot(
+        data=df_clean, 
+        x='frame_sec', 
+        y='race', 
+        hue='race', 
+        palette='deep', 
+        s=50, 
+        alpha=0.6, 
+        legend=True,
+        ax=ax,
+        )
+    ax.set_title('Временная шкала обнаружения лиц по расе')
+    ax.set_xlabel('Время видео (секунды)')
+    ax.set_ylabel('Раса')
+    ax.grid(True, linestyle='--', alpha=0.7)
+    ax.legend(title='Классы расы', bbox_to_anchor=(1.05, 1), loc='upper left')
+
+
+    st.pyplot(fig, use_container_width=False)
+    st.write('---')
+    st.write('Распределение смены эмоций по времени и кол-ву детекций')
+
+
+    fig, ax = plt.subplots()
+    emotion_timeline = df.pivot_table(
+        index='frame_sec', 
+        columns='emotion', 
+        aggfunc='size', 
+        fill_value=0,
+        )
+    emotion_timeline.plot(kind='area', stacked=True, ax=ax)
+    ax.set_title('Изменение эмоций во времени')
+    ax.set_xlabel('Время видео (секунды)')
+    ax.set_ylabel('Количество детекций')
+    ax.grid(True, linestyle='--', alpha=0.7)
+    ax.legend(title='Эмоции', bbox_to_anchor=(1.05, 1), loc='upper left')
+
+
+    st.pyplot(fig, use_container_width=False)
+    st.write('---')
+
+

media/result_video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df2012d876a8b65ce2f5b8a9d31c9bf89a2e254f82763657331ef12aacf809ce
+size 3309385

pages/1_Video_Detection.py

@@ -0,0 +1,110 @@
+import tempfile
+
+import streamlit as st
+
+
+# ===================== Настройки страницы ======================
+
+st.set_page_config(
+    layout='wide',
+    initial_sidebar_state='auto',
+    page_title='Face Emotion Recognition',
+    page_icon='👻',
+    )
+
+st.write("#### Детекция лиц, эмоций, пола, расы и возраста на видео")
+
+# загрузка и отображение видео с примером детекции
+@st.cache_data 
+def load_main_video(video_path: str) -> bytes:
+    with open(video_path, 'rb') as file:
+        video_bytes = file.read()
+    return video_bytes
+
+MAIN_VIDEO_PATH = 'media/result_video.mp4'
+example_video_bytes = load_main_video(MAIN_VIDEO_PATH)
+
+video_width = 60
+video_side = 100
+
+_, container, _ = st.columns([video_side, video_width, video_side])
+container.video(data=example_video_bytes)
+
+# ===================== Боковое меню настроек ======================
+
+st.sidebar.header('Настройки')
+st.sidebar.write('---')
+
+face_conf_threshold = st.sidebar.slider(
+    label='Порог уверенности для детекции лиц',
+    min_value=0.0,
+    max_value=1.0,
+    value=0.7,
+    step=0.01,
+    )
+st.sidebar.write('---')
+
+# какие действия нужно детектить (пока не реализовано переключение)
+actions = ['age', 'gender', 'race', 'emotion']
+# применять ли дополнительное выравнивание
+st.sidebar.write('Применять ли дополнительное выравнивание')
+align = st.sidebar.checkbox(label='Align', value=False)
+
+
+# загрузка и инициализация моделей
+with st.spinner('Инициализация/загрузка моделей...'):
+    from detector import detector_model
+
+# ==================== Загрузка видео и детекция =================
+
+st_video = st.file_uploader(label='Выберите видео')
+st.session_state['video_ready_to_convert'] = False
+st.session_state['annotations_ready'] = False
+
+if st_video:
+    if st.button('Детекция видео'):
+        progress_text = 'Детекция видео...'
+        progress_bar = st.progress(0, text=progress_text)
+
+        temp_file = tempfile.NamedTemporaryFile(delete=False)
+        temp_file.write(st_video.read())
+        video_file = temp_file.name
+
+        generator = detector_model.detect_video(
+            video_file=video_file,
+            actions=actions,
+            align=align,
+            face_conf_threshold=face_conf_threshold,
+            )
+        frame_count, total_frames = next(generator)
+        for (frame_count, _) in generator:
+            progress_text = f'Детекция видео, кадр {frame_count}/{total_frames}'
+            progress_bar.progress(frame_count / total_frames, text=progress_text)
+        
+        progress_bar.empty()
+        st.session_state['video_ready_to_convert'] = True
+        detector_model.detections_to_df()
+
+# ======= Конвертация видео для отображения в браузере =================
+
+if st.session_state['video_ready_to_convert']:
+    convert_video_path = 'result_video_convert.mp4'
+    with st.spinner('Идет конвертация видео ...'):
+        detector_model.convert_mp4(detector_model.save_video_path, convert_video_path)
+    # st.video(convert_video_path, format='video/mp4')
+
+    with open(str(convert_video_path), 'rb') as file:
+        video_bytes = file.read()
+
+    _, container, _ = st.columns([video_side, video_width, video_side])
+    container.video(data=video_bytes)
+    
+    # ======================= Кнопка скачать видео ===================
+
+    st.download_button(
+        label='Скачать видео', 
+        data=video_bytes, 
+        file_name=detector_model.save_video_path,
+        )
+    st.session_state['video_ready_to_convert'] = False
+

pages/2_Video_Detection_Results.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+
+import pandas as pd
+import streamlit as st
+
+from draw_utils import draw_plots
+
+
+st.set_page_config(
+    layout='wide',
+    initial_sidebar_state='auto',
+    page_title='Face Emotion Recognition',
+    page_icon='👻',
+    )
+
+
+st.write("#### Отображение результатов детекции видео")
+
+csv_path = 'video_annotations.csv'
+
+@st.cache_data
+def load_df():
+    df = pd.read_csv(csv_path)
+    return df
+
+if Path('video_annotations.csv').exists():
+    df = load_df()
+    st.download_button(
+        label='Скачать csv аннотации', 
+        data=df.to_csv().encode('utf-8'), 
+        file_name=csv_path,
+        mime='text/csv',
+        )
+    draw_plots(df)
+else:
+    st.write(
+        '#### Для отображения результатов детекции выберите видео' \
+        'на вкладке Video Detection и нажмите "Детекция видео"'
+    )

pages/3_Web_Camera_Photo.py

@@ -0,0 +1,75 @@
+import cv2
+import numpy as np
+from PIL import Image
+import streamlit as st
+
+from detector import detector_model
+
+
+# ===================== Настройки страницы ======================
+
+st.set_page_config(
+    layout='wide',
+    initial_sidebar_state='auto',
+    page_title='Face Emotion Recognition',
+    page_icon='👻',
+    )
+
+
+st.write("#### Детекция лиц, эмоций, пола и возраста с веб-камеры")
+
+# ===================== Боковое меню настроек ======================
+
+st.sidebar.header('Настройки')
+st.sidebar.write('---')
+
+face_conf_threshold = st.sidebar.slider(
+    label='Порог уверенности для детекции лиц',
+    min_value=0.0,
+    max_value=1.0,
+    value=0.7,
+    step=0.01,
+    )
+st.sidebar.write('---')
+
+# какие действия нужно детектить (пока не реализовано переключение)
+actions = ['age', 'gender', 'race', 'emotion']
+# применять ли дополнительное выравнивание
+st.sidebar.write('Применять ли дополнительное выравнивание')
+align = st.sidebar.checkbox(label='Align', value=False)
+
+# ================= Чтение видеопотока с камеры ===============
+
+st_image = st.camera_input("Сделать фото")
+st.session_state['detect_image_ready'] = False
+
+# ====================== Детекция ===========================
+
+if st_image:
+    pil_image = Image.open(st_image)
+    np_image_rgb = np.array(pil_image)
+    
+    np_image_bgr = cv2.cvtColor(np_image_rgb, cv2.COLOR_RGB2BGR)
+    with st.spinner('Распознавание фото'):
+        detections = detector_model.detect_image(
+            np_image_bgr, 
+            actions=actions,
+            align=align,
+            )
+
+    with st.spinner('Отрисовка результата'):
+        result_np_image = detector_model.draw_detections(
+            np_image_rgb=np_image_rgb,
+            detections=detections,
+            face_conf_threshold=face_conf_threshold,
+            )
+        st.session_state['detect_image_ready'] = True
+
+# ============= Отрисовка результата ======================
+
+if st_image and st.session_state['detect_image_ready']:
+    col1, col2 = st.columns(2)
+    with col1:
+        st.image(np_image_rgb, caption='Исходное фото', use_column_width=True)
+    with col2:
+        st.image(result_np_image, caption='Результат детекции', use_column_width=True)

requirements.txt

@@ -0,0 +1,6 @@
+tensorflow==2.15
+tf-keras==2.15
+deepface==0.0.93
+streamlit==1.39.0
+python-ffmpeg==2.0.12
+seaborn==0.13.2