"LOL"

.gitignore

@@ -0,0 +1,13 @@
+.venv/
+__pycache__/
+*.mp4
+*.wav
+.data
+.env
+*.txt
+.streamlit
+.vercel
+.DS_Store
+*.png
+*.srt
+*.pdf

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,14 +1,43 @@
----
-title: Know Flow
-emoji: 👁
-colorFrom: blue
-colorTo: green
-sdk: streamlit
-sdk_version: 1.42.2
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: Generate lecture videos from documents with customizable voi
----
+# KnowFlow - Chuyển Bài Giảng Thành Video
+
+KnowFlow là một ứng dụng giúp chuyển đổi file bài giảng (PDF, DOCX) thành video có giọng đọc và hình ảnh minh họa. Dự án sử dụng các công nghệ AI hiện đại để phân tích nội dung, sinh lời giảng, tạo ảnh và dựng video tự động.
+
+## 🚀 Tính năng chính
+- **Semantic Chunking & Text Analysis**: Sử dụng `gemini-pro` của Google để chia nhỏ văn bản và tạo lời giảng tự động.
+- **Text-to-Speech (TTS)**: Sử dụng `mms-tts-vie` của Facebook để tạo giọng đọc tiếng Việt tự nhiên.
+- **Image Generation**: Sử dụng `stable-diffusion-3.5-large` của Stability AI để tạo hình ảnh minh họa.
+- **Video Generation**: Sử dụng `moviepy` để tạo video từ giọng đọc và hình ảnh.
+- **Triển khai dễ dàng**: Chạy trên `Streamlit` với giao diện đơn giản, hỗ trợ tải file và xem video đầu ra.
+
+## 🛠️ Công nghệ sử dụng
+- **Google Gemini-Pro** - Semantic chunking & text generation
+- **Facebook MMS-TTS-VIE** - Chuyển văn bản thành giọng nói
+- **Stability AI Stable Diffusion 3.5 Large** - Tạo hình ảnh minh họa
+- **MoviePy** - Dựng video từ giọng đọc và hình ảnh
+- **Streamlit** - Giao diện web để tải file và xem kết quả
+
+## 📥 Cài đặt
+Yêu cầu Python 3.8+ và pip.
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+```bash
+# Clone repo
+git clone https://github.com/hieunguyen-cyber/knowflow.git
+cd knowflow
+
+# Cài đặt các thư viện cần thiết
+pip install -r requirements.txt
+```
+## ▶️ Chạy ứng dụng
+```bash
+streamlit run app.py
+```
+Sau khi chạy lệnh trên, mở trình duyệt và truy cập `http://localhost:8501` để sử dụng.
+
+## 📸 Hình ảnh minh họa
+![Demo KnowFlow](data/pipeline.png)
+
+## 📜 Giấy phép
+Dự án được phát hành dưới giấy phép Apache.
+
+---
+_Tác giả: Nguyễn Trung Hiếu_

app.py

@@ -0,0 +1,113 @@
+import asyncio
+
+try:
+    asyncio.get_running_loop()
+except RuntimeError:
+    asyncio.run(asyncio.sleep(0))  # Ensures an event loop is created before Streamlit starts
+
+import streamlit as st
+from main import main
+import os
+import subprocess
+from huggingface_hub import InferenceClient
+import google.generativeai as genai
+
+HF_TOKEN = st.secrets["secrets"]["HF_TOKEN"]
+GOOGLE_API_KEY = st.secrets["secrets"]["GOOGLE_API_KEY"]
+genai.configure(api_key=GOOGLE_API_KEY)
+client = InferenceClient(provider="hf-inference", api_key=HF_TOKEN)
+
+# Định nghĩa đường dẫn video đầu ra
+OUTPUT_VIDEO_PATH = "./data/output/final_output.mp4"
+OUTPUT_VIDEO_FIXED_PATH = "./data/output/final_output_fixed.mp4"
+
+# Tiêu đề ứng dụng
+st.set_page_config(page_title="KnowFlow", page_icon="📖")
+st.markdown("<h1 style='text-align: center;'>📖 KnowFlow 🌊</h1>", unsafe_allow_html=True)
+st.markdown("<h4 style='text-align: center;'>Convert documents into videos with AI-powered storytelling</h4>", unsafe_allow_html=True)
+
+# Thông tin tác giả
+st.markdown("---")
+st.markdown("👨‍💻 **Author:** Nguyễn Trung Hiếu")
+st.markdown("🔗 [GitHub Repository](https://github.com/hieunguyen-cyber/KnowFlow.git)")
+st.markdown("---")
+
+# Upload file PDF
+uploaded_file = st.file_uploader("📂 Upload your document (PDF)", type=["pdf","docx"])
+
+# Nếu có file, lưu vào thư mục tạm và lấy đường dẫn
+file_path = None
+if uploaded_file:
+    file_path = f"./data/input/{uploaded_file.name}"
+    with open(file_path, "wb") as f:
+        f.write(uploaded_file.getbuffer())  # Lưu file thực tế
+number_of_images = st.slider("🖼️ Nhập số ảnh",1,10,3)
+# Cấu hình đầu vào
+gender = st.radio("🗣️ Select Voice Gender", options=["female", "male"])
+
+# Nếu chọn giọng nam, vô hiệu hóa tốc độ (chỉ cho phép "normal")
+if gender == "male":
+    speed = st.radio("⚡ Speech Speed (Male voice supports only normal)", options=["normal"], disabled=True)
+else:
+    speed = st.radio("⚡ Speech Speed", options=["fast", "normal", "slow"])
+analysis_level = st.radio("Analysis Level", options=["basic", "detailed"])
+writting_style = st.radio("Writting Style", options  = ["academic","popular","creative","humorous"])
+
+# Tạo thanh trượt với giá trị từ 50 đến 250, bước nhảy 50
+word_lower_limit, word_upper_limit = st.slider(
+    "Chọn khoảng độ dài văn bản:",
+    min_value=50,
+    max_value=250,
+    value=(50, 250),  # Giá trị mặc định
+    step=50
+)
+
+st.write(f"Giới hạn độ dài văn bản từ **{word_lower_limit}** đến **{word_upper_limit}** ký tự.")
+detail_level = st.radio("📖 Detail Level of Image Description", options=["short", "detailed"])
+perspective = st.radio("🔎 Perspective", options=["subjective", "neutral"])
+emotion = st.text_input("🎭 Emotion", placeholder="Example: mysterious, romantic,...")
+time_setting = st.text_input("⏳ Time Setting", placeholder="Example: modern, medieval,...")
+art_style = st.text_input("🖌️ Image Description Style", placeholder="Example: realistic, abstract,...")
+style = st.text_input("🎨 Image Style", placeholder="Example: realistic, anime,...")
+color_palette = st.text_input("🌈 Color Palette", placeholder="Example: vibrant, monochrome,...")
+
+def convert_audio_format(video_input, video_output):
+    """Chuyển đổi định dạng âm thanh của video sang AAC."""
+    if not os.path.exists(video_input):
+        raise FileNotFoundError(f"File '{video_input}' không tồn tại!")
+
+    command = [
+        "ffmpeg", "-i", video_input,  
+        "-c:v", "copy", "-c:a", "aac", "-b:a", "192k",
+        "-y",  # Ghi đè nếu file output đã tồn tại
+        video_output
+    ]
+    
+    try:
+        subprocess.run(command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print(f"✅ Chuyển đổi thành công: {video_output}")
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Lỗi khi chuyển đổi video: {e.stderr.decode()}")
+
+# Nút chạy pipeline
+if st.button("🚀 Generate Video"):
+    if file_path and os.path.exists(file_path):
+        st.success("⏳ Processing started...")
+        main(file_path, analysis_level, writting_style, word_lower_limit, word_upper_limit, gender, speed, number_of_images, detail_level, perspective, emotion, time_setting, art_style, style, color_palette)
+
+        # Kiểm tra xem video đã được tạo chưa
+        if os.path.exists(OUTPUT_VIDEO_PATH):
+            st.success("🎉 Video generated successfully!")
+            
+            # Chuyển đổi định dạng âm thanh
+            convert_audio_format(OUTPUT_VIDEO_PATH, OUTPUT_VIDEO_FIXED_PATH)
+
+            st.video(OUTPUT_VIDEO_FIXED_PATH)  # Trình chiếu video
+
+            # Tạo link tải về
+            with open(OUTPUT_VIDEO_FIXED_PATH, "rb") as video_file:
+                st.download_button(label="📥 Download Video", data=video_file, file_name="final_output_fixed.mp4", mime="video/mp4")
+        else:
+            st.error("⚠️ Video generation failed. Please check the logs.")
+    else:
+        st.error("⚠️ Please upload a valid PDF file.")

main.py

@@ -0,0 +1,24 @@
+from src.text_processing import text_processing
+from src.text_to_speech import text_to_speech
+from src.image_gen import image_gen
+from src.text_to_video import text_to_video
+import os
+def remove_cache(folder_path):
+    if not os.path.exists(folder_path):
+        os.makedirs(folder_path)  # Tạo thư mục nếu chưa tồn tại
+    for file_name in os.listdir(folder_path):
+        file_path = os.path.join(folder_path, file_name)
+        if os.path.isfile(file_path):  # Kiểm tra nếu là file
+            os.remove(file_path)
+def main(file_path = "./data/input/sample.pdf", analysis_level='basic', writting_style='academic', word_lower_limit=100, word_upper_limit = 150, gender = "female", speed = "fast", number_of_images = 3, detail_level="short", perspective="neutral", emotion="sad", time_setting="classic", art_style="realistic", style="anime", color_palette="monochrome"):
+    remove_cache("./data/audio")
+    remove_cache("./data/image")
+    remove_cache("./data/text")
+    remove_cache("./data/output")
+    text_processing(file_path = file_path, analysis_level=analysis_level, writting_style=writting_style, word_lower_limit = word_lower_limit, word_upper_limit=word_upper_limit )
+    text_to_speech(gender = gender, speed = speed)
+    image_gen(number_of_images = number_of_images, detail_level=detail_level, perspective=perspective, emotion=emotion, time_setting=time_setting, art_style=art_style, style=style, color_palette=color_palette)
+    text_to_video()
+
+if __name__ == "__main__":
+    main(file_path="./data/input/sample_2.pdf")

notebook/image_gen.ipynb

@@ -0,0 +1,190 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import InferenceClient\n",
+    "import os\n",
+    "import glob\n",
+    "from collections import defaultdict\n",
+    "import google.generativeai as genai\n",
+    "from tqdm import tqdm\n",
+    "from huggingface_hub.utils import HfHubHTTPError\n",
+    "import random\n",
+    "from dotenv import load_dotenv\n",
+    "import time\n",
+    "\n",
+    "\n",
+    "load_dotenv()\n",
+    "HF_API_KEY = os.getenv(\"HUGGINGFACE_API_KEY\")\n",
+    "GOOGLE_API_KEY = os.getenv(\"GOOGLE_API_KEY\")\n",
+    "genai.configure(api_key=GOOGLE_API_KEY)\n",
+    "client = InferenceClient(provider=\"hf-inference\", api_key=HF_API_KEY)\n",
+    "import time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def split_text_by_semantics(number_of_images):\n",
+    "    with open(\"../data/text/text.txt\", \"r\", encoding=\"utf-8\") as file:\n",
+    "        text = file.read()\n",
+    "    prompt = f\"\"\"\n",
+    "    Bạn là một chuyên gia xử lý văn bản. Hãy chia văn bản sau thành {number_of_images} đoạn có ý nghĩa sao cho mỗi đoạn vừa đủ để giải thích trong khoảng 3 đến 5 câu.\n",
+    "\n",
+    "    Văn bản:\n",
+    "    {text}\n",
+    "\n",
+    "    Định dạng đầu ra:\n",
+    "    - Phần 1: [Nội dung]\n",
+    "    - Phần 2: [Nội dung]\n",
+    "    - Phần 3: [Nội dung]\n",
+    "    \"\"\"\n",
+    "\n",
+    "    try:\n",
+    "        model = genai.GenerativeModel(\"gemini-pro\")\n",
+    "        response = model.generate_content(prompt)\n",
+    "        result_text = response.text.strip()\n",
+    "\n",
+    "        chunks = result_text.split(\"- Phần \")\n",
+    "        chunks = [chunk.strip() for chunk in chunks if chunk]\n",
+    "        return chunks\n",
+    "    except Exception as e:\n",
+    "        print(f\"Lỗi khi gọi API Gemini: {e}\")\n",
+    "        return []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def describe_image(description, detail_level=\"short\", perspective=\"neutral\", emotion=None, time_setting=None, art_style=None):\n",
+    "    \"\"\"\n",
+    "    Nhận một đoạn văn mô tả chi tiết và trả về một câu mô tả hình ảnh theo các tùy chỉnh.\n",
+    "\n",
+    "    Args:\n",
+    "        description (str): Đoạn văn mô tả chi tiết.\n",
+    "        detail_level (str): Mức độ chi tiết (\"short\" hoặc \"detailed\").\n",
+    "        perspective (str): Góc nhìn (\"subjective\" hoặc \"neutral\").\n",
+    "        emotion (str, optional): Cảm xúc chủ đạo (nếu có, ví dụ: \"mysterious\", \"romantic\").\n",
+    "        time_setting (str, optional): Bối cảnh thời gian (ví dụ: \"modern\", \"medieval\", \"futuristic\").\n",
+    "        art_style (str, optional): Phong cách nghệ thuật (ví dụ: \"realistic\", \"abstract\", \"sketch\").\n",
+    "\n",
+    "    Returns:\n",
+    "        str: Một câu mô tả hình ảnh theo yêu cầu.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    prompt = f\"\"\"\n",
+    "    Bạn là chuyên gia mô tả hình ảnh. Hãy đọc đoạn mô tả dưới đây và tạo một mô tả hình ảnh theo các tiêu chí sau:\n",
+    "    - Mức độ chi tiết: {\"Ngắn gọn\" if detail_level == \"short\" else \"Chi tiết\"}.\n",
+    "    - Góc nhìn: {\"Chủ quan\" if perspective == \"subjective\" else \"Trung lập\"}.\n",
+    "    {f\"- Cảm xúc chủ đạo: {emotion}.\" if emotion else \"\"}\n",
+    "    {f\"- Bối cảnh thời gian: {time_setting}.\" if time_setting else \"\"}\n",
+    "    {f\"- Phong cách nghệ thuật: {art_style}.\" if art_style else \"\"}\n",
+    "\n",
+    "    Đoạn mô tả:\n",
+    "    {description}\n",
+    "\n",
+    "    Hãy tạo một mô tả hình ảnh phù hợp với yêu cầu trên bằng Tiếng Anh.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    try:\n",
+    "        model = genai.GenerativeModel(\"gemini-pro\")\n",
+    "        response = model.generate_content(prompt)\n",
+    "        return response.text.strip()\n",
+    "    except Exception as e:\n",
+    "        print(f\"Lỗi khi gọi API Gemini: {e}\")\n",
+    "        return \"\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate_image(prompt, output_path, model=\"stabilityai/stable-diffusion-3.5-large\", resolution=(512, 512), style=None, color_palette=None):\n",
+    "    \"\"\"\n",
+    "    Tạo hình ảnh từ mô tả văn bản với các tùy chỉnh linh hoạt.\n",
+    "    \n",
+    "    :param prompt: Mô tả hình ảnh đầu vào.\n",
+    "    :param output_path: Đường dẫn lưu ảnh đầu ra.\n",
+    "    :param model: Mô hình AI sử dụng để tạo ảnh.\n",
+    "    :param style: Phong cách hình ảnh (nếu có, ví dụ: 'realistic', 'anime', 'cyberpunk').\n",
+    "    :param color_palette: Bảng màu ưu tiên (nếu có, ví dụ: 'vibrant', 'monochrome').\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    custom_prompt = prompt\n",
+    "    \n",
+    "    if style:\n",
+    "        custom_prompt += f\" in {style} style\"\n",
+    "    if color_palette:\n",
+    "        custom_prompt += f\" with {color_palette} color scheme\"\n",
+    "    \n",
+    "    image = client.text_to_image(custom_prompt, model=model, resolution=resolution)\n",
+    "    image.save(output_path)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texts = split_text_by_semantics(number_of_images=3)\n",
+    "index = 0\n",
+    "for merged_text in tqdm(texts, desc=\"Processing\", unit=\"image\"):\n",
+    "    output_path = f\"../data/image/{index}.png\"\n",
+    "    prompt = describe_image(merged_text)\n",
+    "    print(prompt)\n",
+    "\n",
+    "    # Cơ chế retry với backoff\n",
+    "    max_retries = 5\n",
+    "    retry_count = 0\n",
+    "\n",
+    "    while retry_count < max_retries:\n",
+    "        try:\n",
+    "            generate_image(prompt, output_path)\n",
+    "            time.sleep(60)  # Chờ sau khi tạo ảnh thành công\n",
+    "            break  # Nếu thành công thì thoát khỏi vòng lặp retry\n",
+    "        except HfHubHTTPError as e:\n",
+    "            print(f\"Lỗi khi gọi API: {e}\")\n",
+    "            retry_count += 1\n",
+    "            wait_time = 2 ** retry_count + random.uniform(0, 1)  # Exponential backoff\n",
+    "            print(f\"Thử lại sau {wait_time:.2f} giây...\")\n",
+    "            time.sleep(wait_time)\n",
+    "\n",
+    "    index += 1"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebook/text_preprocessing.ipynb

@@ -0,0 +1,247 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cài đặt thư viện\n",
+    "API Free của Gemini nên không cần private"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import fitz  # PyMuPDF\n",
+    "from docx import Document\n",
+    "import google.generativeai as genai\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "# Load biến môi trường từ .env\n",
+    "load_dotenv()\n",
+    "GOOGLE_API_KEY = os.getenv(\"GOOGLE_API_KEY\")\n",
+    "genai.configure(api_key=GOOGLE_API_KEY)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Thiết lập hàm đọc file\n",
+    "Chấp nhận hai định dạng là .doc và .pdf. Đảm bảo file bài giảng nhiều chữ."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def extract_text_from_pdf(pdf_path):\n",
+    "    # Mở file PDF\n",
+    "    doc = fitz.open(pdf_path)\n",
+    "    text = \"\"\n",
+    "    for page_num in range(doc.page_count):\n",
+    "        page = doc.load_page(page_num)\n",
+    "        text += page.get_text()\n",
+    "    return text\n",
+    "\n",
+    "def extract_text_from_docx(docx_path):\n",
+    "    # Mở file DOCX\n",
+    "    doc = Document(docx_path)\n",
+    "    text = \"\"\n",
+    "    for para in doc.paragraphs:\n",
+    "        text += para.text + \"\\n\"\n",
+    "    return text\n",
+    "\n",
+    "def extract_text_from_file(file_path):\n",
+    "    # Kiểm tra loại file và gọi hàm tương ứng\n",
+    "    file_extension = os.path.splitext(file_path)[1].lower()\n",
+    "\n",
+    "    if file_extension == '.pdf':\n",
+    "        return extract_text_from_pdf(file_path)\n",
+    "    elif file_extension == '.docx':\n",
+    "        return extract_text_from_docx(file_path)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unsupported file format. Only PDF and DOCX are supported.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text = extract_text_from_file(\"../data/input/sample.pdf\")\n",
+    "with open(\"../data/text/text.txt\", \"w\", encoding=\"utf-8\") as f:\n",
+    "    f.write(text)  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Gọi API tiến hành chia đoạn và phân tích tóm tắt\n",
+    "Đưa ra phân tích và lưu lại file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def split_text_by_semantics(text, number_of_chunks):\n",
+    "    prompt = f\"\"\"\n",
+    "    Bạn là một chuyên gia xử lý văn bản. Hãy chia văn bản sau thành {number_of_chunks} đoạn có ý nghĩa sao cho mỗi đoạn vừa đủ để giải thích trong khoảng 3 đến 5 câu.\n",
+    "\n",
+    "    Văn bản:\n",
+    "    {text}\n",
+    "\n",
+    "    Định dạng đầu ra:\n",
+    "    - Phần 1: [Nội dung]\n",
+    "    - Phần 2: [Nội dung]\n",
+    "    - Phần 3: [Nội dung]\n",
+    "    \"\"\"\n",
+    "\n",
+    "    try:\n",
+    "        model = genai.GenerativeModel(\"gemini-pro\")\n",
+    "        response = model.generate_content(prompt)\n",
+    "        result_text = response.text.strip()\n",
+    "\n",
+    "        chunks = result_text.split(\"- Phần \")\n",
+    "        chunks = [chunk.strip() for chunk in chunks if chunk]\n",
+    "        return chunks\n",
+    "    except Exception as e:\n",
+    "        print(f\"Lỗi khi gọi API Gemini: {e}\")\n",
+    "        return []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate_explaination_for_chunks(chunks, analysis_level='basic', style='academic', word_limit=100):\n",
+    "    \"\"\"\n",
+    "    Phân tích nội dung của văn bản theo mức độ và phong cách mong muốn.\n",
+    "    \n",
+    "    :param chunks: Danh sách các đoạn văn bản cần phân tích.\n",
+    "    :param text: Toàn bộ văn bản gốc.\n",
+    "    :param analysis_level: Mức độ phân tích ('basic' hoặc 'detailed').\n",
+    "    :param style: Phong cách phân tích ('academic', 'popular', 'creative', 'humorous').\n",
+    "    :param word_limit: Số từ ước lượng cho mỗi phần tóm tắt.\n",
+    "    :return: Danh sách các phân tích tương ứng với từng đoạn.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    level_prompts = {\n",
+    "        'basic': \"Hãy đưa ra một bản tóm tắt ngắn gọn, tập trung vào nội dung chính.\",\n",
+    "        'detailed': \"Hãy phân tích chuyên sâu từng phần, làm rõ ý nghĩa, ngữ cảnh và các yếu tố quan trọng.\"\n",
+    "    }\n",
+    "    \n",
+    "    style_prompts = {\n",
+    "        'academic': \"Phân tích theo phong cách học thuật, sử dụng ngôn ngữ chuyên sâu và lập luận chặt chẽ.\",\n",
+    "        'popular': \"Trình bày theo phong cách phổ thông, dễ hiểu và phù hợp với nhiều đối tượng.\",\n",
+    "        'creative': \"Giải thích một cách sáng tạo, sử dụng hình ảnh ẩn dụ và cách diễn đạt thú vị.\",\n",
+    "        'humorous': \"Phân tích theo phong cách hài hước, thêm vào yếu tố vui nhộn và bất ngờ.\"\n",
+    "    }\n",
+    "    \n",
+    "    overview_prompt = f\"\"\"\n",
+    "    Đây là một văn bản có nội dung quan trọng. Bạn sẽ phân tích từng phần theo mức độ '{analysis_level}' và phong cách '{style}'.\n",
+    "    Văn bản gồm các phần sau: {', '.join([f'Phần {i+1}' for i in range(len(chunks))])}.\n",
+    "    {level_prompts[analysis_level]}\n",
+    "    {style_prompts[style]}\n",
+    "    Mỗi phần không vượt quá {word_limit} từ.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    try:\n",
+    "        model = genai.GenerativeModel(\"gemini-pro\")\n",
+    "        response = model.generate_content(overview_prompt)\n",
+    "        overview_text = response.text.strip()\n",
+    "        \n",
+    "        explanations = []\n",
+    "        for idx, chunk in enumerate(chunks, start=1):\n",
+    "            part_prompt = f\"\"\"\n",
+    "            Phân tích phần {idx} của văn bản.\n",
+    "            {level_prompts[analysis_level]}\n",
+    "            {style_prompts[style]}\n",
+    "            Nội dung phần này:\n",
+    "            {chunk}\n",
+    "            Hãy đảm bảo phần tóm tắt không vượt quá {word_limit} từ.\n",
+    "            \"\"\"\n",
+    "            \n",
+    "            part_response = model.generate_content(part_prompt)\n",
+    "            explanations.append(part_response.text.strip())\n",
+    "        \n",
+    "        return explanations\n",
+    "    \n",
+    "    except Exception as e:\n",
+    "        print(f\"Lỗi khi gọi API Gemini: {e}\")\n",
+    "        return []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Tách văn bản theo ngữ nghĩa sử dụng API Gemini\n",
+    "semantic_chunks = split_text_by_semantics(text, number_of_chunks=3)\n",
+    "\n",
+    "# Tạo thuyết minh cho từng phần semantic chunk\n",
+    "explainations = generate_explaination_for_chunks(semantic_chunks)\n",
+    "\n",
+    "# In kết quả\n",
+    "for idx, explaination in enumerate(explainations, start=1):\n",
+    "    print(f\"Giải thích cho Phần {idx}:\\n{explaination}\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Lưu từng câu vào tệp riêng biệt\n",
+    "for idx, explaination in enumerate(explainations, start=1):\n",
+    "    # Tách đoạn văn bản thành các câu dựa trên dấu chấm\n",
+    "    sentences = explaination.split('.')\n",
+    "    \n",
+    "    # Lưu từng câu vào tệp riêng biệt\n",
+    "    for sentence_idx, sentence in enumerate(sentences, start=1):\n",
+    "        sentence = sentence.strip()  # Loại bỏ khoảng trắng thừa\n",
+    "        if sentence:  # Kiểm tra nếu câu không rỗng\n",
+    "            output_file = f\"../data/text/{idx}_{sentence_idx}.txt\"  # Tên tệp theo định dạng x_y.txt\n",
+    "            with open(output_file, \"w\", encoding=\"utf-8\") as f:\n",
+    "                f.write(f\"'{sentence}'\")  # Ghi câu trong dấu nháy đơn\n",
+    "            print(f\"Đã lưu: {output_file}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebook/text_to_speech.ipynb

@@ -0,0 +1,224 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from transformers import VitsModel, AutoTokenizer\n",
+    "import torchaudio\n",
+    "import numpy as np\n",
+    "import os\n",
+    "from gtts import gTTS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Đọc và load danh sách từ các file .txt trong thư mục ../data/text\n",
+    "text_folder = \"../data/text\"\n",
+    "text_files = sorted([f for f in os.listdir(text_folder) if f.endswith('.txt')])  # Lọc các file .txt trong thư mục"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Audio saved as hello.mp3 (gTTS - Female)\n"
+     ]
+    }
+   ],
+   "source": [
+    "def text_to_speech(text, filename=\"output.mp3\", gender=\"female\", speed=\"normal\"):\n",
+    "    \"\"\"\n",
+    "    Convert text to speech and save it as an audio file.\n",
+    "    \n",
+    "    Parameters:\n",
+    "        text (str): The text to convert.\n",
+    "        filename (str): The output file name.\n",
+    "        gender (str): \"male\" (use MMS-TTS) or \"female\" (use gTTS).\n",
+    "        speed (str): \"slow\", \"normal\", or \"fast\" (only for gTTS).\n",
+    "    \"\"\"\n",
+    "    lang = \"vi\"\n",
+    "    \n",
+    "    if gender.lower() == \"female\":\n",
+    "        # gTTS chỉ có giọng nữ\n",
+    "        speed_mapping = {\"slow\": True, \"normal\": False, \"fast\": False}\n",
+    "        slow = speed_mapping.get(speed.lower(), False)\n",
+    "        \n",
+    "        tts = gTTS(text=text, lang=lang, slow=slow)\n",
+    "        tts.save(filename)\n",
+    "        print(f\"✅ Audio saved as {filename}\")\n",
+    "    \n",
+    "    elif gender.lower() == \"male\":\n",
+    "        # MMS-TTS cho giọng nam\n",
+    "        model = VitsModel.from_pretrained(\"facebook/mms-tts-vie\")\n",
+    "        tokenizer = AutoTokenizer.from_pretrained(\"facebook/mms-tts-vie\")\n",
+    "        \n",
+    "        inputs = tokenizer(text, return_tensors=\"pt\")\n",
+    "        with torch.no_grad():\n",
+    "            output = model(**inputs).waveform\n",
+    "        \n",
+    "        # Lưu file âm thanh\n",
+    "        torchaudio.save(filename, output, 24000)\n",
+    "        print(f\"✅ Audio saved as {filename}\")\n",
+    "    \n",
+    "    else:\n",
+    "        print(\"⚠️ Giọng không hợp lệ! Chỉ hỗ trợ 'male' hoặc 'female'.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Audio saved as 1_1.wav (gTTS - Female)\n",
+      "Đã lưu 1_1.wav\n",
+      "✅ Audio saved as 1_10.wav (gTTS - Female)\n",
+      "Đã lưu 1_10.wav\n",
+      "✅ Audio saved as 1_11.wav (gTTS - Female)\n",
+      "Đã lưu 1_11.wav\n",
+      "✅ Audio saved as 1_12.wav (gTTS - Female)\n",
+      "Đã lưu 1_12.wav\n",
+      "✅ Audio saved as 1_13.wav (gTTS - Female)\n",
+      "Đã lưu 1_13.wav\n",
+      "✅ Audio saved as 1_14.wav (gTTS - Female)\n",
+      "Đã lưu 1_14.wav\n",
+      "✅ Audio saved as 1_15.wav (gTTS - Female)\n",
+      "Đã lưu 1_15.wav\n",
+      "✅ Audio saved as 1_16.wav (gTTS - Female)\n",
+      "Đã lưu 1_16.wav\n",
+      "✅ Audio saved as 1_17.wav (gTTS - Female)\n",
+      "Đã lưu 1_17.wav\n",
+      "✅ Audio saved as 1_2.wav (gTTS - Female)\n",
+      "Đã lưu 1_2.wav\n",
+      "✅ Audio saved as 1_3.wav (gTTS - Female)\n",
+      "Đã lưu 1_3.wav\n",
+      "✅ Audio saved as 1_4.wav (gTTS - Female)\n",
+      "Đã lưu 1_4.wav\n",
+      "✅ Audio saved as 1_5.wav (gTTS - Female)\n",
+      "Đã lưu 1_5.wav\n",
+      "✅ Audio saved as 1_6.wav (gTTS - Female)\n",
+      "Đã lưu 1_6.wav\n",
+      "✅ Audio saved as 1_7.wav (gTTS - Female)\n",
+      "Đã lưu 1_7.wav\n",
+      "✅ Audio saved as 1_8.wav (gTTS - Female)\n",
+      "Đã lưu 1_8.wav\n",
+      "✅ Audio saved as 1_9.wav (gTTS - Female)\n",
+      "Đã lưu 1_9.wav\n",
+      "✅ Audio saved as 2_1.wav (gTTS - Female)\n",
+      "Đã lưu 2_1.wav\n",
+      "✅ Audio saved as 2_10.wav (gTTS - Female)\n",
+      "Đã lưu 2_10.wav\n",
+      "✅ Audio saved as 2_11.wav (gTTS - Female)\n",
+      "Đã lưu 2_11.wav\n",
+      "✅ Audio saved as 2_12.wav (gTTS - Female)\n",
+      "Đã lưu 2_12.wav\n",
+      "✅ Audio saved as 2_13.wav (gTTS - Female)\n",
+      "Đã lưu 2_13.wav\n",
+      "✅ Audio saved as 2_14.wav (gTTS - Female)\n",
+      "Đã lưu 2_14.wav\n",
+      "✅ Audio saved as 2_15.wav (gTTS - Female)\n",
+      "Đã lưu 2_15.wav\n",
+      "✅ Audio saved as 2_16.wav (gTTS - Female)\n",
+      "Đã lưu 2_16.wav\n",
+      "✅ Audio saved as 2_17.wav (gTTS - Female)\n",
+      "Đã lưu 2_17.wav\n",
+      "✅ Audio saved as 2_18.wav (gTTS - Female)\n",
+      "Đã lưu 2_18.wav\n",
+      "✅ Audio saved as 2_2.wav (gTTS - Female)\n",
+      "Đã lưu 2_2.wav\n",
+      "✅ Audio saved as 2_3.wav (gTTS - Female)\n",
+      "Đã lưu 2_3.wav\n",
+      "✅ Audio saved as 2_4.wav (gTTS - Female)\n",
+      "Đã lưu 2_4.wav\n",
+      "✅ Audio saved as 2_5.wav (gTTS - Female)\n",
+      "Đã lưu 2_5.wav\n",
+      "✅ Audio saved as 2_6.wav (gTTS - Female)\n",
+      "Đã lưu 2_6.wav\n",
+      "✅ Audio saved as 2_7.wav (gTTS - Female)\n",
+      "Đã lưu 2_7.wav\n",
+      "✅ Audio saved as 2_8.wav (gTTS - Female)\n",
+      "Đã lưu 2_8.wav\n",
+      "✅ Audio saved as 2_9.wav (gTTS - Female)\n",
+      "Đã lưu 2_9.wav\n",
+      "✅ Audio saved as 3_1.wav (gTTS - Female)\n",
+      "Đã lưu 3_1.wav\n",
+      "✅ Audio saved as 3_10.wav (gTTS - Female)\n",
+      "Đã lưu 3_10.wav\n",
+      "✅ Audio saved as 3_11.wav (gTTS - Female)\n",
+      "Đã lưu 3_11.wav\n",
+      "✅ Audio saved as 3_12.wav (gTTS - Female)\n",
+      "Đã lưu 3_12.wav\n",
+      "✅ Audio saved as 3_14.wav (gTTS - Female)\n",
+      "Đã lưu 3_14.wav\n",
+      "✅ Audio saved as 3_17.wav (gTTS - Female)\n",
+      "Đã lưu 3_17.wav\n",
+      "✅ Audio saved as 3_18.wav (gTTS - Female)\n",
+      "Đã lưu 3_18.wav\n",
+      "✅ Audio saved as 3_19.wav (gTTS - Female)\n",
+      "Đã lưu 3_19.wav\n",
+      "✅ Audio saved as 3_2.wav (gTTS - Female)\n",
+      "Đã lưu 3_2.wav\n",
+      "✅ Audio saved as 3_3.wav (gTTS - Female)\n",
+      "Đã lưu 3_3.wav\n",
+      "✅ Audio saved as 3_4.wav (gTTS - Female)\n",
+      "Đã lưu 3_4.wav\n",
+      "✅ Audio saved as 3_5.wav (gTTS - Female)\n",
+      "Đã lưu 3_5.wav\n",
+      "✅ Audio saved as 3_6.wav (gTTS - Female)\n",
+      "Đã lưu 3_6.wav\n",
+      "✅ Audio saved as 3_7.wav (gTTS - Female)\n",
+      "Đã lưu 3_7.wav\n",
+      "✅ Audio saved as 3_8.wav (gTTS - Female)\n",
+      "Đã lưu 3_8.wav\n",
+      "✅ Audio saved as 3_9.wav (gTTS - Female)\n",
+      "Đã lưu 3_9.wav\n"
+     ]
+    }
+   ],
+   "source": [
+    "for text_file in text_files:\n",
+    "    with open(f\"../data/text/{text_file}\", \"r\", encoding=\"utf-8\") as file:\n",
+    "        content = file.read()\n",
+    "    audio_file = text_file.replace(\"txt\",\"wav\")\n",
+    "    text_to_speech(content, audio_file)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

src/image_gen.py

@@ -0,0 +1,126 @@
+from huggingface_hub import InferenceClient
+import os
+import glob
+from collections import defaultdict
+import google.generativeai as genai
+from tqdm import tqdm
+from huggingface_hub.utils import HfHubHTTPError
+import random
+import time
+from dotenv import load_dotenv
+
+load_dotenv()
+HF_TOKEN = os.getenv("HF_TOKEN")
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+genai.configure(api_key=GOOGLE_API_KEY)
+client = InferenceClient(provider="hf-inference", api_key=HF_TOKEN)
+
+def split_text_for_images(number_of_images):
+    with open("./data/text/text.txt", "r", encoding="utf-8") as file:
+        text = file.read().strip()
+
+    total_length = len(text)
+    chunk_size = total_length // number_of_images  # Độ dài trung bình của mỗi đoạn
+
+    chunks = []
+    start = 0
+
+    for i in range(number_of_images):
+        # Xác định điểm kết thúc gần nhất tại dấu câu (nếu có)
+        end = start + chunk_size
+        if i < number_of_images - 1:
+            while end < total_length and text[end] not in ".!?":  
+                end += 1  # Mở rộng đến dấu câu gần nhất để tránh cắt ngang câu
+            if end < total_length - 1:
+                end += 1  # Bao gồm cả dấu câu vào đoạn
+
+        chunk = text[start:end].strip()
+        chunks.append(chunk)
+        start = end  # Bắt đầu đoạn tiếp theo từ đây
+
+    return chunks
+def describe_image(description, detail_level="short", perspective="neutral", emotion=None, time_setting=None, art_style=None):
+    """
+    Nhận một đoạn văn mô tả chi tiết và trả về một câu mô tả hình ảnh theo các tùy chỉnh.
+
+    Args:
+        description (str): Đoạn văn mô tả chi tiết.
+        detail_level (str): Mức độ chi tiết ("short" hoặc "detailed").
+        perspective (str): Góc nhìn ("subjective" hoặc "neutral").
+        emotion (str, optional): Cảm xúc chủ đạo (nếu có, ví dụ: "mysterious", "romantic").
+        time_setting (str, optional): Bối cảnh thời gian (ví dụ: "modern", "medieval", "futuristic").
+        art_style (str, optional): Phong cách nghệ thuật (ví dụ: "realistic", "abstract", "sketch").
+
+    Returns:
+        str: Một câu mô tả hình ảnh theo yêu cầu.
+    """
+    
+    prompt = f"""
+    Bạn là chuyên gia mô tả hình ảnh. Hãy đọc đoạn mô tả dưới đây và tạo một mô tả hình ảnh theo các tiêu chí sau:
+    - Mức độ chi tiết: {"Ngắn gọn" if detail_level == "short" else "Chi tiết"}.
+    - Góc nhìn: {"Chủ quan" if perspective == "subjective" else "Trung lập"}.
+    {f"- Cảm xúc chủ đạo: {emotion}." if emotion else ""}
+    {f"- Bối cảnh thời gian: {time_setting}." if time_setting else ""}
+    {f"- Phong cách nghệ thuật: {art_style}." if art_style else ""}
+
+    Đoạn mô tả:
+    {description}
+
+    Hãy tạo một mô tả hình ảnh phù hợp với yêu cầu trên bằng Tiếng Anh.
+    """
+
+    try:
+        model = genai.GenerativeModel("gemini-pro")
+        response = model.generate_content(prompt)
+        return response.text.strip()
+    except Exception as e:
+        print(f"Lỗi khi gọi API Gemini: {e}")
+        return ""
+def generate_image(prompt, output_path, style=None, color_palette=None):
+    model="stabilityai/stable-diffusion-3.5-large"
+    """
+    Tạo hình ảnh từ mô tả văn bản với các tùy chỉnh linh hoạt.
+    
+    :param prompt: Mô tả hình ảnh đầu vào.
+    :param output_path: Đường dẫn lưu ảnh đầu ra.
+    :param model: Mô hình AI sử dụng để tạo ảnh.
+    :param style: Phong cách hình ảnh (nếu có, ví dụ: 'realistic', 'anime', 'cyberpunk').
+    :param color_palette: Bảng màu ưu tiên (nếu có, ví dụ: 'vibrant', 'monochrome').
+    """
+    custom_prompt = prompt
+    
+    if style:
+        custom_prompt += f" in {style} style"
+    if color_palette:
+        custom_prompt += f" with {color_palette} color scheme"
+    
+    image = client.text_to_image(custom_prompt, model=model)
+    image.save(output_path)
+    print(f"✅Image saved at {output_path}")
+def image_gen(number_of_images = 3,detail_level = "short", perspective="neutral", emotion=None, time_setting=None, art_style=None, style=None, color_palette=None):
+    texts = split_text_for_images(number_of_images)
+    index = 0
+    for text in tqdm(texts, desc="Processing", unit="image"):
+        output_path = f"./data/image/{index}.png"
+        prompt = describe_image(text, detail_level, perspective, emotion, time_setting, art_style)
+        print(prompt)
+
+        # Cơ chế retry với backoff
+        max_retries = 5
+        retry_count = 0
+
+        while retry_count < max_retries:
+            try:
+                generate_image(prompt, output_path, style, color_palette)
+                time.sleep(60)  # Chờ sau khi tạo ảnh thành công
+                break  # Nếu thành công thì thoát khỏi vòng lặp retry
+            except HfHubHTTPError as e:
+                print(f"Lỗi khi gọi API: {e}")
+                retry_count += 1
+                wait_time = 2 ** retry_count + random.uniform(0, 1)  # Exponential backoff
+                print(f"Thử lại sau {wait_time:.2f} giây...")
+                time.sleep(wait_time)
+        index += 1
+    os.remove("./data/text/text.txt")
+if __name__ == "__main__":
+    image_gen(number_of_images = 3, detail_level="short", perspective="neutral", emotion="sad", time_setting="classic", art_style="realistic", style="anime", color_palette="monochrome")

src/text_processing.py

@@ -0,0 +1,151 @@
+import os
+import fitz  
+from docx import Document
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+load_dotenv()
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+genai.configure(api_key=GOOGLE_API_KEY)
+
+####################### - TEXT EXTRACTION - #######################
+def extract_text_from_pdf(pdf_path):
+    # Mở file PDF
+    doc = fitz.open(pdf_path)
+    text = ""
+    for page_num in range(doc.page_count):
+        page = doc.load_page(page_num)
+        text += page.get_text()
+    return text
+
+def extract_text_from_docx(docx_path):
+    # Mở file DOCX
+    doc = Document(docx_path)
+    text = ""
+    for para in doc.paragraphs:
+        text += para.text + "\n"
+    return text
+
+def extract_text_from_file(file_path):
+    # Kiểm tra loại file và gọi hàm tương ứng
+    file_extension = os.path.splitext(file_path)[1].lower()
+
+    if file_extension == '.pdf':
+        return extract_text_from_pdf(file_path)
+    elif file_extension == '.docx':
+        return extract_text_from_docx(file_path)
+    else:
+        raise ValueError("Unsupported file format. Only PDF and DOCX are supported.")
+####################### - SEMANTIC CHUNKING - #######################
+def split_text_by_semantics(text):
+    prompt = f"""
+    Bạn là một chuyên gia xử lý văn bản. Hãy chia văn bản sau thành một số đoạn có ý nghĩa sao cho mỗi đoạn vừa đủ để giải thích trong khoảng 3 đến 5 câu.
+
+    Văn bản:
+    {text}
+
+    Định dạng đầu ra:
+    - Phần 1: [Nội dung]
+    - Phần 2: [Nội dung]
+    - Phần 3: [Nội dung]
+    """
+
+    try:
+        model = genai.GenerativeModel("gemini-pro")
+        response = model.generate_content(prompt)
+        result_text = response.text.strip()
+
+        chunks = result_text.split("- Phần ")
+        chunks = [chunk.strip() for chunk in chunks if chunk]
+        return chunks
+    except Exception as e:
+        print(f"Lỗi khi gọi API Gemini: {e}")
+        return []
+
+####################### - CONTENT GENERATION - #######################
+def generate_explaination_for_chunks(chunks, analysis_level='basic', writting_style='academic', word_lower_limit=100, word_upper_limit=150):
+    """
+    Phân tích nội dung của văn bản theo mức độ và phong cách mong muốn.
+    
+    :param chunks: Danh sách các đoạn văn bản cần phân tích.
+    :param text: Toàn bộ văn bản gốc.
+    :param analysis_level: Mức độ phân tích ('basic' hoặc 'detailed').
+    :param writting_style: Phong cách phân tích ('academic', 'popular', 'creative', 'humorous').
+    :param word_limit: Số từ ước lượng cho mỗi phần tóm tắt.
+    :return: Danh sách các phân tích tương ứng với từng đoạn.
+    """
+    
+    level_prompts = {
+        'basic': "Hãy đưa ra một bản tóm tắt ngắn gọn, tập trung vào nội dung chính.",
+        'detailed': "Hãy phân tích chuyên sâu từng phần, làm rõ ý nghĩa, ngữ cảnh và các yếu tố quan trọng."
+    }
+    
+    writting_style_prompts = {
+        'academic': "Phân tích theo phong cách học thuật, sử dụng ngôn ngữ chuyên sâu và lập luận chặt chẽ.",
+        'popular': "Trình bày theo phong cách phổ thông, dễ hiểu và phù hợp với nhiều đối tượng.",
+        'creative': "Giải thích một cách sáng tạo, sử dụng hình ảnh ẩn dụ và cách diễn đạt thú vị.",
+        'humorous': "Phân tích theo phong cách hài hước, thêm vào yếu tố vui nhộn và bất ngờ."
+    }
+    
+    overview_prompt = f"""
+    Đây là một văn bản có nội dung quan trọng. Bạn sẽ phân tích từng phần theo mức độ '{analysis_level}' và phong cách '{writting_style}'.
+    Văn bản gồm các phần sau: {', '.join([f'Phần {i+1}' for i in range(len(chunks))])}.
+    {level_prompts[analysis_level]}
+    {writting_style_prompts[writting_style]}
+    Mỗi phần không vượt quá {word_upper_limit} từ và không ít hơn {word_lower_limit} từ.
+    """
+    
+    try:
+        model = genai.GenerativeModel("gemini-pro")
+        response = model.generate_content(overview_prompt)
+        overview_text = response.text.strip()
+        
+        explanations = []
+        for idx, chunk in enumerate(chunks, start=1):
+            part_prompt = f"""
+            Phân tích phần {idx} của văn bản.
+            {level_prompts[analysis_level]}
+            {writting_style_prompts[writting_style]}
+            Nội dung phần này:
+            {chunk}
+            Hãy đảm bảo phần tóm tắt không vượt quá {word_upper_limit} từ và không ít hơn {word_lower_limit}.
+            """
+            
+            part_response = model.generate_content(part_prompt)
+            explanations.append(part_response.text.strip())
+        
+        return explanations
+    
+    except Exception as e:
+        print(f"Lỗi khi gọi API Gemini: {e}")
+        return [] 
+def text_processing(file_path, analysis_level='basic', writting_style='academic', word_lower_limit = 100, word_upper_limit = 150):
+    # Trích xuất văn bản từ file PDF
+    text = extract_text_from_file(file_path=file_path)
+    with open("./data/text/text.txt", "w", encoding="utf-8") as f:
+        f.write(text)  
+    # Tách văn bản theo ngữ nghĩa
+    semantic_chunks = split_text_by_semantics(text)
+
+    # Tạo thuyết minh cho từng phần semantic chunk
+    explanations = generate_explaination_for_chunks(semantic_chunks, analysis_level=analysis_level, writting_style = writting_style, word_lower_limit = word_lower_limit, word_upper_limit=word_upper_limit)
+
+    # Tạo thư mục nếu chưa tồn tại
+    output_dir = "./data/text/"
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Lưu từng câu vào file riêng biệt
+    for chunk_idx, explanation in enumerate(explanations, start=1):
+        # Tách đoạn phân tích thành các câu
+        sentences = explanation.split('.')
+
+        for sentence_idx, sentence in enumerate(sentences, start=1):
+            sentence = sentence.strip()  # Loại bỏ khoảng trắng thừa
+            if sentence:  # Kiểm tra nếu câu không rỗng
+                output_file = os.path.join(output_dir, f"{chunk_idx}_{sentence_idx}.txt")  # Tên file dạng "chunkID_sentenceID.txt"
+                with open(output_file, "w", encoding="utf-8") as f:
+                    f.write(sentence.replace("*","") + ".")  # Giữ dấu chấm cuối câu
+                print(f"Đã lưu: {output_file}")
+####################### - MAIN CODE - #######################
+if __name__ == "__main__":
+    text_processing(file_path = "./data/input/sample_3.pdf")

src/text_to_speech.py

@@ -0,0 +1,52 @@
+import torch
+from transformers import VitsModel, AutoTokenizer
+import torchaudio
+import os
+from gtts import gTTS
+
+def generate_audio(text, filename="output.mp3", gender="female", speed="normal"):
+    """
+    Convert text to speech and save it as an audio file.
+    
+    Parameters:
+        text (str): The text to convert.
+        filename (str): The output file name.
+        gender (str): "male" (use MMS-TTS) or "female" (use gTTS).
+        speed (str): "slow", "normal", or "fast" (only for gTTS).
+    """
+    lang = "vi"
+    
+    if gender.lower() == "female":
+        # gTTS chỉ có giọng nữ
+        speed_mapping = {"slow": True, "normal": False, "fast": False}
+        slow = speed_mapping.get(speed.lower(), False)
+        
+        tts = gTTS(text=text, lang=lang, slow=slow)
+        tts.save(filename)
+        print(f"✅ Audio saved as {filename}")
+    
+    elif gender.lower() == "male":
+        # MMS-TTS cho giọng nam
+        model = VitsModel.from_pretrained("facebook/mms-tts-vie")
+        tokenizer = AutoTokenizer.from_pretrained("facebook/mms-tts-vie")
+        
+        inputs = tokenizer(text, return_tensors="pt")
+        with torch.no_grad():
+            output = model(**inputs).waveform
+        
+        # Lưu file âm thanh
+        torchaudio.save(filename, output, 24000, backend="sox_io")
+        print(f"✅ Audio saved as {filename}")
+    
+    else:
+        print("⚠️ Giọng không hợp lệ! Chỉ hỗ trợ 'male' hoặc 'female'.")
+def text_to_speech(gender, speed):
+    text_folder = "./data/text"
+    text_files = sorted([f for f in os.listdir(text_folder) if f.endswith('.txt') and f != "text.txt"])
+    for text_file in text_files:
+        with open(f"./data/text/{text_file}", "r", encoding="utf-8") as file:
+            content = file.read()
+        audio_file = text_file.replace("txt","wav")
+        generate_audio(content, f"./data/audio/{audio_file}", gender=gender, speed=speed) 
+if __name__ == "__main__":
+    text_to_speech(gender = "female", speed = "fast")

src/text_to_video.py

@@ -0,0 +1,153 @@
+from moviepy.video.io.VideoFileClip import VideoFileClip, AudioFileClip
+from moviepy.video.VideoClip import TextClip, ImageClip
+from moviepy.video.compositing.CompositeVideoClip import concatenate_videoclips, CompositeVideoClip
+from moviepy.audio.AudioClip import concatenate_audioclips
+from moviepy.video.tools.subtitles import SubtitlesClip
+from moviepy.video.VideoClip import ColorClip
+import os
+from itertools import accumulate
+import pysrt
+
+
+def format_time(seconds):
+    """Chuyển đổi thời gian (giây) thành định dạng SRT hh:mm:ss,ms"""
+    mins, sec = divmod(seconds, 60)
+    hours, mins = divmod(mins, 60)
+    return f"{int(hours):02}:{int(mins):02}:{int(sec):02},{int((sec % 1) * 1000):03}"
+def get_audio_duration(audio_path):
+    # Lọc các file có đuôi .wav
+    audio_paths = os.listdir(audio_path)
+    audio_list = [file for file in audio_paths if file.endswith(".wav")]
+    
+    # Khởi tạo danh sách audio duration
+    duration_list = []
+    
+    for audio_path in audio_list:
+        # Mở file âm thanh và lấy thời gian
+        with AudioFileClip(f"./data/audio/{audio_path}") as audio:
+            duration_list.append(audio.duration)
+    # Tính tổng tích lũy thời gian
+    duration_list = [format_time(time) for time in list(accumulate(duration_list))]
+    return [format_time(0.0)] + duration_list
+def create_srt_from_time_and_text(duration_time, text_folder, output_srt):
+    subtitle = ""
+    subtitle_index = 1
+    text_list = sorted([file for file in os.listdir(text_folder) if file.endswith('txt')])
+    # Duyệt qua các mốc thời gian và file text
+    for i in range(len(duration_time) - 1):
+        start_time = duration_time[i]
+        end_time = duration_time[i + 1]
+        
+        # Lấy tên file text tương ứng
+        text_file = text_list[i]  
+        
+        text_path = os.path.join(text_folder, text_file)
+        
+        if os.path.exists(text_path):
+            with open(text_path, 'r', encoding='utf-8') as f:
+                text = f.read().strip()
+                # Thêm phần subtitle vào chuỗi kết quả
+                subtitle += f"{subtitle_index}\n{start_time} --> {end_time}\n{text}\n\n"
+                subtitle_index += 1
+        else:
+            print(f"File {text_file} không tồn tại!")
+    
+    # Lưu vào file SRT
+    with open(output_srt, 'w', encoding='utf-8') as f:
+        f.write(subtitle)
+def concatenate_audio_files(audio_folder, output_audio_path):
+    # Lọc tất cả các file âm thanh .wav trong thư mục
+    audio_clips = []
+    
+    for file in sorted(os.listdir(audio_folder)):
+        if file.endswith('.wav'):
+            audio_path = os.path.join(audio_folder, file)
+            audio_clip = AudioFileClip(audio_path)
+            audio_clips.append(audio_clip)
+    
+    # Ghép tất cả các audio clip lại với nhau
+    final_audio = concatenate_audioclips(audio_clips)
+    
+    # Lưu kết quả vào file output
+    final_audio.write_audiofile(output_audio_path, codec = 'pcm_s16le')
+
+    print(f"File audio đã được lưu tại: {output_audio_path}")
+def create_video_from_images(image_folder, audio_path, output_video_path):
+    # Đọc file âm thanh để lấy thời lượng
+    audio = AudioFileClip(audio_path)
+    total_duration = audio.duration  # Tổng thời lượng video bằng thời lượng audio
+
+    # Đọc tất cả các file ảnh trong thư mục và sắp xếp theo tên
+    image_files = [file for file in sorted(os.listdir(image_folder)) if file.endswith("png")]
+    
+    if not image_files:
+        raise ValueError("Không tìm thấy ảnh nào trong thư mục!")
+
+    # Tính thời lượng hiển thị cho mỗi ảnh
+    duration_per_image = total_duration / len(image_files)
+
+    # Tạo danh sách các clip ảnh
+    clips = [ImageClip(f"./data/image/{img}").with_duration(duration_per_image).resized(width=1280) for img in image_files]
+
+    # Ghép các clip ảnh lại với nhau
+    final_video = concatenate_videoclips(clips, method="chain")
+    
+    # Gán âm thanh vào video
+    final_video .audio = audio
+
+    # Xuất video
+    final_video.write_videofile(output_video_path, codec="libx264", audio_codec="pcm_s16le", fps=24)
+
+    print(f"Video đã được lưu tại: {output_video_path}")
+def wrap_text(text, max_width):
+    """
+    Tự động xuống dòng để vừa với chiều rộng max_width.
+    """
+    import textwrap
+    return "\n".join(textwrap.wrap(text, width=max_width))
+def add_subtitles_to_video(video_path, subtitle_path, output_video_path):
+    """
+    Thêm phụ đề từ file .srt trực tiếp vào video.
+    
+    :param video_path: Đường dẫn video gốc
+    :param subtitle_path: Đường dẫn file .srt
+    :param output_video_path: Đường dẫn lưu video đầu ra
+    """
+    
+    # Đọc file video
+    video = VideoFileClip(video_path)
+
+    # Đọc file .srt
+    subs = pysrt.open(subtitle_path)
+
+    subtitle_clips = []  # Danh sách các đoạn phụ đề
+
+    # Xử lý từng dòng phụ đề
+    for sub in subs:
+        # Chuyển thời gian thành giây
+        start_time = sub.start.ordinal / 1000  # Chuyển từ milliseconds sang giây
+        end_time = sub.end.ordinal / 1000
+        font = "./data/BeVietnamPro-Light.ttf"
+        # Tạo clip phụ đề
+        txt_clip = TextClip(font=font, text=wrap_text(sub.text, max_width=85), font_size=30, stroke_color="black", stroke_width=3, color="#fff")
+         
+        # Đặt vị trí hiển thị (giữa phía dưới video)
+        txt_clip = txt_clip.with_position(('center', 'bottom')).with_duration(end_time - start_time).with_start(start_time)
+        
+        subtitle_clips.append(txt_clip)
+
+    # Ghép phụ đề vào video
+    final_video = CompositeVideoClip([video] + subtitle_clips)
+
+    # Xuất video với phụ đề
+    final_video.write_videofile(output_video_path, fps=video.fps, codec='libx264', threads=4)
+
+    print(f"Video với phụ đề đã được lưu tại: {output_video_path}")
+def text_to_video():
+    duration_time = get_audio_duration("./data/audio")
+    create_srt_from_time_and_text(duration_time, './data/text', './data/output/subtitle.srt')
+    concatenate_audio_files("./data/audio","./data/output/final_audio.wav")
+    create_video_from_images("./data/image","./data/output/final_audio.wav","./data/output/output.mp4")
+    add_subtitles_to_video("./data/output/output.mp4", "./data/output/subtitle.srt", "./data/output/final_output.mp4")
+if __name__ == "__main__":
+    text_to_video()

test/test.ipynb

@@ -0,0 +1,391 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from moviepy.video.io.VideoFileClip import VideoFileClip, AudioFileClip\n",
+    "from moviepy.video.VideoClip import TextClip, ImageClip\n",
+    "from moviepy.video.compositing.CompositeVideoClip import concatenate_videoclips, CompositeVideoClip\n",
+    "from moviepy.audio.AudioClip import concatenate_audioclips\n",
+    "from moviepy.video.tools.subtitles import SubtitlesClip\n",
+    "from moviepy.video.VideoClip import ColorClip\n",
+    "import os\n",
+    "from tqdm import tqdm\n",
+    "from itertools import accumulate\n",
+    "import pysrt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def format_time(seconds):\n",
+    "    \"\"\"Chuyển đổi thời gian (giây) thành định dạng SRT hh:mm:ss,ms\"\"\"\n",
+    "    mins, sec = divmod(seconds, 60)\n",
+    "    hours, mins = divmod(mins, 60)\n",
+    "    return f\"{int(hours):02}:{int(mins):02}:{int(sec):02},{int((sec % 1) * 1000):03}\"\n",
+    "def get_audio_duration(audio_path):\n",
+    "    # Lọc các file có đuôi .wav\n",
+    "    audio_paths = os.listdir(audio_path)\n",
+    "    audio_list = [file for file in audio_paths if file.endswith(\".wav\")]\n",
+    "    \n",
+    "    # Khởi tạo danh sách audio duration\n",
+    "    duration_list = []\n",
+    "    \n",
+    "    for audio_path in audio_list:\n",
+    "        # Mở file âm thanh và lấy thời gian\n",
+    "        with AudioFileClip(f\"../data/audio/{audio_path}\") as audio:\n",
+    "            duration_list.append(audio.duration)\n",
+    "    # Tính tổng tích lũy thời gian\n",
+    "    duration_list = [format_time(time) for time in list(accumulate(duration_list))]\n",
+    "    return [format_time(0.0)] + duration_list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "duration_time = get_audio_duration(\"../data/audio\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_srt_from_time_and_text(duration_time, text_folder, output_srt):\n",
+    "    subtitle = \"\"\n",
+    "    subtitle_index = 1\n",
+    "    text_list = sorted([file for file in os.listdir(text_folder) if file.endswith('txt')])\n",
+    "    # Duyệt qua các mốc thời gian và file text\n",
+    "    for i in range(len(duration_time) - 1):\n",
+    "        start_time = duration_time[i]\n",
+    "        end_time = duration_time[i + 1]\n",
+    "        \n",
+    "        # Lấy tên file text tương ứng\n",
+    "        text_file = text_list[i]  # Giả sử các file có tên như '1.txt', '2.txt', ...\n",
+    "        \n",
+    "        text_path = os.path.join(text_folder, text_file)\n",
+    "        \n",
+    "        if os.path.exists(text_path):\n",
+    "            with open(text_path, 'r', encoding='utf-8') as f:\n",
+    "                text = f.read().strip()\n",
+    "                # Thêm phần subtitle vào chuỗi kết quả\n",
+    "                subtitle += f\"{subtitle_index}\\n{start_time} --> {end_time}\\n{text}\\n\\n\"\n",
+    "                subtitle_index += 1\n",
+    "        else:\n",
+    "            print(f\"File {text_file} không tồn tại!\")\n",
+    "    \n",
+    "    # Lưu vào file SRT\n",
+    "    with open(output_srt, 'w', encoding='utf-8') as f:\n",
+    "        f.write(subtitle)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "create_srt_from_time_and_text(duration_time, '../data/text', 'subtitle.srt')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def concatenate_audio_files(audio_folder, output_audio_path):\n",
+    "    # Lọc tất cả các file âm thanh .wav trong thư mục\n",
+    "    audio_clips = []\n",
+    "    \n",
+    "    for file in sorted(os.listdir(audio_folder)):\n",
+    "        if file.endswith('.wav'):\n",
+    "            audio_path = os.path.join(audio_folder, file)\n",
+    "            audio_clip = AudioFileClip(audio_path)\n",
+    "            audio_clips.append(audio_clip)\n",
+    "    \n",
+    "    # Ghép tất cả các audio clip lại với nhau\n",
+    "    final_audio = concatenate_audioclips(audio_clips)\n",
+    "    \n",
+    "    # Lưu kết quả vào file output\n",
+    "    final_audio.write_audiofile(output_audio_path, codec = 'pcm_s16le')\n",
+    "\n",
+    "    print(f\"File audio đã được lưu tại: {output_audio_path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "chunk:   1%|          | 107/11954 [00:14<27:40,  7.14it/s, now=None]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MoviePy - Writing audio in final_audio.wav\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "chunk:   1%|          | 107/11954 [00:25<46:35,  4.24it/s, now=None]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MoviePy - Done.\n",
+      "File audio đã được lưu tại: final_audio.wav\n"
+     ]
+    }
+   ],
+   "source": [
+    "concatenate_audio_files(\"../data/audio\",\"final_audio.wav\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 111,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_video_from_images(image_folder, audio_path, output_video_path):\n",
+    "    # Đọc file âm thanh để lấy thời lượng\n",
+    "    audio = AudioFileClip(audio_path)\n",
+    "    total_duration = audio.duration  # Tổng thời lượng video bằng thời lượng audio\n",
+    "\n",
+    "    # Đọc tất cả các file ảnh trong thư mục và sắp xếp theo tên\n",
+    "    image_files = [file for file in sorted(os.listdir(image_folder))]\n",
+    "    \n",
+    "    if not image_files:\n",
+    "        raise ValueError(\"Không tìm thấy ảnh nào trong thư mục!\")\n",
+    "\n",
+    "    # Tính thời lượng hiển thị cho mỗi ảnh\n",
+    "    duration_per_image = total_duration / len(image_files)\n",
+    "\n",
+    "    # Tạo danh sách các clip ảnh\n",
+    "    clips = [ImageClip(f\"../data/image/{img}\").with_duration(duration_per_image).resized(width=1280) for img in image_files]\n",
+    "\n",
+    "    # Ghép các clip ảnh lại với nhau\n",
+    "    final_video = concatenate_videoclips(clips, method=\"chain\")\n",
+    "    \n",
+    "    # Gán âm thanh vào video\n",
+    "    final_video .audio = audio\n",
+    "\n",
+    "    # Xuất video\n",
+    "    final_video.write_videofile(output_video_path, codec=\"libx264\", audio_codec=\"pcm_s16le\", fps=24)\n",
+    "\n",
+    "    print(f\"Video đã được lưu tại: {output_video_path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 112,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MoviePy - Building video output.mp4.\n",
+      "MoviePy - Writing audio in outputTEMP_MPY_wvf_snd.wav\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                         \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MoviePy - Done.\n",
+      "MoviePy - Writing video output.mp4\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                             \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MoviePy - Done !\n",
+      "MoviePy - video ready output.mp4\n",
+      "Video đã được lưu tại: output.mp4\n"
+     ]
+    }
+   ],
+   "source": [
+    "create_video_from_images(\"../data/image\",\"final_audio.wav\",\"output.mp4\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def wrap_text(text, max_width):\n",
+    "    \"\"\"\n",
+    "    Tự động xuống dòng để vừa với chiều rộng max_width.\n",
+    "    \"\"\"\n",
+    "    import textwrap\n",
+    "    return \"\\n\".join(textwrap.wrap(text, width=max_width))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def add_subtitles_to_video(video_path, subtitle_path, output_video_path):\n",
+    "    \"\"\"\n",
+    "    Thêm phụ đề từ file .srt trực tiếp vào video.\n",
+    "    \n",
+    "    :param video_path: Đường dẫn video gốc\n",
+    "    :param subtitle_path: Đường dẫn file .srt\n",
+    "    :param output_video_path: Đường dẫn lưu video đầu ra\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # Đọc file video\n",
+    "    video = VideoFileClip(video_path)\n",
+    "\n",
+    "    # Đọc file .srt\n",
+    "    subs = pysrt.open(subtitle_path)\n",
+    "\n",
+    "    subtitle_clips = []  # Danh sách các đoạn phụ đề\n",
+    "\n",
+    "    # Xử lý từng dòng phụ đề\n",
+    "    for sub in subs:\n",
+    "        # Chuyển thời gian thành giây\n",
+    "        start_time = sub.start.ordinal / 1000  # Chuyển từ milliseconds sang giây\n",
+    "        end_time = sub.end.ordinal / 1000\n",
+    "        font = \"../BeVietnamPro-Light.ttf\"\n",
+    "        # Tạo clip phụ đề\n",
+    "        txt_clip = TextClip(font=font, text=wrap_text(sub.text, max_width=75), font_size=10, stroke_color=\"black\", stroke_width=3, color=\"#fff\")\n",
+    "         \n",
+    "        # Đặt vị trí hiển thị (giữa phía dưới video)\n",
+    "        txt_clip = txt_clip.with_position(('center', 'bottom')).with_duration(end_time - start_time).with_start(start_time)\n",
+    "        \n",
+    "        subtitle_clips.append(txt_clip)\n",
+    "\n",
+    "    # Ghép phụ đề vào video\n",
+    "    final_video = CompositeVideoClip([video] + subtitle_clips)\n",
+    "\n",
+    "    # Xuất video với phụ đề\n",
+    "    final_video.write_videofile(output_video_path, fps=video.fps, codec='libx264', threads=4)\n",
+    "\n",
+    "    print(f\"Video với phụ đề đã được lưu tại: {output_video_path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf61.7.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [400, 258], 'bitrate': 24, 'fps': 24.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]', 'encoder': 'Lavc61.19.100 libx264'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 44100, 'bitrate': 127, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 542.12, 'bitrate': 159, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [400, 258], 'video_bitrate': 24, 'video_fps': 24.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 44100, 'audio_bitrate': 127, 'video_duration': 542.12, 'video_n_frames': 13010}\n",
+      "/opt/anaconda3/lib/python3.12/site-packages/imageio_ffmpeg/binaries/ffmpeg-macos-aarch64-v7.1 -i output.mp4 -loglevel error -f image2pipe -vf scale=400:258 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n",
+      "MoviePy - Building video final_output.mp4.\n",
+      "MoviePy - Writing audio in final_outputTEMP_MPY_wvf_snd.mp3\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                        \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MoviePy - Done.\n",
+      "MoviePy - Writing video final_output.mp4\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                             "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MoviePy - Done !\n",
+      "MoviePy - video ready final_output.mp4\n",
+      "Video với phụ đề đã được lưu tại: final_output.mp4\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r"
+     ]
+    }
+   ],
+   "source": [
+    "add_subtitles_to_video(\"output.mp4\", \"subtitle.srt\", \"final_output.mp4\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}