🎬 Motion Stack0에서 시작하는 설치 가이드

curl -fsSL https://design-portfolio-7yo.pages.dev/motion-stack-offline.zip -o pack.zip
unzip pack.zip && cd motion-stack-offline
bash install-offline.sh     # 스킬 11종 배치 + Blender MCP 등록(PyPI 경유)

ls ~/.claude/skills/                      # 스킬 폴더 목록
claude plugin list                        # 플러그인(hyperframes@hyperframes)
claude mcp list | grep blender            # MCP 서버 연결 상태
ls "$HOME/Library/Application Support/Blender/5.2/scripts/addons/"
node -v && npm -v                         # v24.14.1 / 11.11.0 에서 검증
ffmpeg -version | head -1                 # 9.0.1
PATH="$HOME/Library/Python/3.11/bin:$PATH" manim --version   # v0.22.0

# 또는 스크립트로 한 번에 (설치는 하지 않음)
bash motion-stack-setup.sh --check

curl -fsSL https://design-portfolio-7yo.pages.dev/motion-stack-setup.sh -o setup.sh

bash setup.sh --check    # ① 먼저 현재 상태만 확인 (아무것도 설치/수정하지 않는다)
bash setup.sh            # ② 실제 설치

# Homebrew (없을 때만)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Node — Remotion 요구사항: ^20.19.0 || ^22.13.0 || >=24
brew install node
node -v    # 검증 환경: v24.14.1 / npm 11.11.0

# 시스템 패키지
#  ffmpeg  : 영상 인코딩 (HyperFrames·Remotion·algorithmic-art 공용)
#  uv      : uvx로 Blender MCP 서버 실행
#  cairo·pango·pkgconf : Manim 렌더 백엔드
#  ⚠️ brew 공식 이름은 pkg-config가 아니라 pkgconf 다
brew install ffmpeg uv cairo pango pkgconf

# 전역 설치할 것이 없다. 프로젝트를 만든다.
npx create-video@latest my-video
cd my-video && npm install

# Claude Code용 공식 스킬 12종 (프로젝트 스코프 → .agents/skills/remotion-*)
# ⚠️ 이 단계만 GitHub(remotion-dev/skills)을 탄다
npx remotion skills add

# 검증
npx remotion studio                              # http://localhost:3000 미리보기
npx remotion render HelloMotion out/hello.mp4    # 스타터 팩 예제

# 기대 출력:  + out/hello.mp4  약 45.9 kB  (1280×720, 30fps, 90프레임)

# 방법 A — Claude Code 플러그인 (스킬 9종이 전역으로 붙는다, GitHub 필요)
claude plugin marketplace add heygen-com/hyperframes
claude plugin install hyperframes@hyperframes
claude plugin list        # hyperframes@hyperframes · 0.8.167 · user · enabled

# 방법 B — CLI만 (npm, GitHub 불필요). 스킬 자동 진입은 없지만 제작·렌더는 전부 가능
npx --yes hyperframes@0.8.167 init my-video
cd my-video
npx --yes hyperframes@0.8.167 check     # 린트 + 모션/대비 검증
npx --yes hyperframes@0.8.167 render    # mp4 (헤드리스 크롬 + ffmpeg)

# 설치되는 스킬 9종:
#   hyperframes(라우터) · -animation · -audio · -cli · -core
#   -creative · -keyframes · -registry · -studio

# Blender 앱 (검증 버전 5.2.2 LTS)
brew install --cask blender          # 또는 blender.org에서 직접 다운로드

# MCP 서버 등록 — PyPI에서 받는다
claude mcp add -s user blender -- uvx mcp-for-blender

# 검증
claude mcp list | grep blender       # blender: uvx mcp-for-blender - ✔ Connected

# 애드온은 패키지에 번들돼 있어 서버가 직접 배치한다(별도 다운로드 불필요)
ls "$HOME/Library/Application Support/Blender/5.2/scripts/addons/blender_mcp.py"

# Manim 본체 (PyPI)
pip3 install --user manim

# ⚠️ pip --user 실행파일은 기본 PATH에 없다 → 셸 설정에 추가
echo 'export PATH="$HOME/Library/Python/3.11/bin:$PATH"' >> ~/.zshrc
export PATH="$HOME/Library/Python/3.11/bin:$PATH"   # 현재 셸 즉시 적용
manim --version    # Manim Community v0.22.0

# 스킬 2종 — GitHub 가능할 때
git clone https://github.com/awesome-skills/manim-skill.git      ~/.claude/skills/manim-skill
git clone https://github.com/Pardesco/algorithmic-art-skill.git  ~/.claude/skills/algorithmic-art

# GitHub 차단 환경이면 오프라인 팩으로 (동일 내용, MIT)
#   curl -fsSL https://design-portfolio-7yo.pages.dev/motion-stack-offline.zip -o pack.zip
#   unzip pack.zip && cd motion-stack-offline && bash install-offline.sh

import { AbsoluteFill, interpolate, useCurrentFrame, useVideoConfig } from "remotion";

// 설치가 제대로 됐는지 눈으로 확인하는 용도.
//   npx remotion render HelloMotion out/hello.mp4
export const HelloMotion: React.FC = () => {
  const frame = useCurrentFrame();
  const { durationInFrames } = useVideoConfig();

  const opacity = interpolate(frame, [0, 20], [0, 1], { extrapolateRight: "clamp" });
  const y = interpolate(frame, [0, 24], [28, 0], { extrapolateRight: "clamp" });
  const out = interpolate(frame, [durationInFrames - 15, durationInFrames], [1, 0], {
    extrapolateLeft: "clamp",
  });

  return (
    <AbsoluteFill
      style={{
        backgroundColor: "#0f172a",
        justifyContent: "center",
        alignItems: "center",
        fontFamily: "Pretendard, -apple-system, system-ui, sans-serif",
      }}
    >
      <div
        style={{
          opacity: opacity * out,
          transform: `translateY(${y}px)`,
          color: "#a3e635",
          fontSize: 84,
          fontWeight: 800,
          letterSpacing: "-0.03em",
        }}
      >
        Remotion OK
      </div>
      <div style={{ opacity: opacity * out, color: "#94a3b8", fontSize: 28, marginTop: 14 }}>
        frame {frame} / {durationInFrames}
      </div>
    </AbsoluteFill>
  );
};

import { Composition } from "remotion";
import { MyComposition } from "./Composition";
import { HelloMotion } from "./HelloMotion";

export const RemotionRoot: React.FC = () => {
  return (
    <>
      {/* 기본 스캐폴드 컴포지션 (내용 없음 — 빈 영상이 정상이다) */}
      <MyComposition />
      {/* 설치 확인용 동작 예제 */}
      <Composition
        id="HelloMotion"
        component={HelloMotion}
        durationInFrames={90}
        fps={30}
        width={1280}
        height={720}
      />
    </>
  );
};

// ─── package.json ─────────────────────────────────────────────
{
  "name": "remotion-starter",
  "private": true,
  "engines": { "node": "^20.19.0 || ^22.13.0 || >=24" },
  "dependencies": {
    "@remotion/cli": "4.0.536",
    "react": "19.2.3",
    "react-dom": "19.2.3",
    "remotion": "4.0.536"
  },
  "devDependencies": {
    "@remotion/eslint-config-flat": "4.0.536",
    "@types/react": "19.2.7", "@types/web": "0.0.166",
    "eslint": "10.12.0", "prettier": "3.8.1", "typescript": "5.9.3"
  },
  "scripts": {
    "dev": "remotion studio",
    "build": "remotion bundle",
    "lint": "eslint src && tsc"
  }
}

// ─── remotion.config.ts ───────────────────────────────────────
import { Config } from "@remotion/cli/config";
Config.setRspack(true);
Config.setVideoImageFormat("jpeg");
Config.setOverwriteOutput(true);
Config.setDefaultPremountInSeconds(2);

// ─── src/index.ts (엔트리) ────────────────────────────────────
import { registerRoot } from "remotion";
import { RemotionRoot } from "./Root";
registerRoot(RemotionRoot);

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=1920, height=1080" />
    <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
    <style>
      * { margin: 0; padding: 0; box-sizing: border-box; }
      html, body {
        margin: 0; width: 1920px; height: 1080px;
        overflow: hidden; background: #0a0a0a;
      }
      #root {
        width: 100%; height: 100%; display: flex;
        align-items: center; justify-content: center;
        font-family: Inter, ui-sans-serif, system-ui, sans-serif;
      }
      #title { color: #f4f4f5; font-size: 72px; font-weight: 600; letter-spacing: -0.03em; }
    </style>
  </head>
  <body>
    <div
      id="root"
      data-composition-id="main"
      data-start="0"
      data-duration="10"
      data-width="1920"
      data-height="1080"
    >
      <h1 id="title" class="clip" data-start="0" data-duration="10" data-track-index="0">Title</h1>
    </div>
    <script>
      const tl = gsap.timeline({ paused: true });
      // 예: tl.fromTo("#title", { opacity: 0, y: 24 }, { opacity: 1, y: 0, duration: 0.6 }, 0);
      window.__timelines["main"] = tl;
      tl.seek(0);
    </script>
  </body>
</html>

// ─── package.json — 전역 설치 없이 npx로 CLI를 고정 버전 호출 ───
{
  "name": "hyperframes-starter",
  "private": true,
  "type": "module",
  "scripts": {
    "dev":     "npx --yes hyperframes@0.8.167 preview",
    "check":   "npx --yes hyperframes@0.8.167 check",
    "render":  "npx --yes hyperframes@0.8.167 render",
    "publish": "npx --yes hyperframes@0.8.167 publish"
  }
}

// ─── hyperframes.json — 레지스트리·경로 설정 ───────────────────
{
  "$schema": "https://hyperframes.heygen.com/schema/hyperframes.json",
  "registry": "https://raw.githubusercontent.com/heygen-com/hyperframes/main/registry",
  "paths": {
    "blocks":     "compositions",
    "components": "compositions/components",
    "assets":     "assets"
  },
  "media": { "autoProxy": true }
}

// ⚠️ registry가 raw.githubusercontent.com을 가리킨다 →
//    GitHub 차단 환경에서는 레지스트리 블록 설치(hyperframes add)가 실패한다.
//    직접 작성한 index.html 렌더는 레지스트리 없이도 정상 동작한다.

# 1) 각 도구로 구간을 뽑는다 (해상도·fps를 반드시 통일할 것)
#    intro.mp4   ← HyperFrames (1920x1080, 30fps)
#    formula.mp4 ← Manim        (manim -qh 로 1080p 렌더)
#    chart.mp4   ← Remotion     (width/height/fps를 Composition에 명시)

# 2) 목록 파일을 만든다
cat > list.txt <<'EOF'
file 'intro.mp4'
file 'formula.mp4'
file 'chart.mp4'
EOF

# 3) 재인코딩 없이 이어붙이기 (코덱·해상도·fps가 같을 때만 가능)
ffmpeg -f concat -safe 0 -i list.txt -c copy final.mp4

# 사양이 다르면 통일해서 다시 인코딩
ffmpeg -i formula.mp4 -vf "scale=1920:1080,fps=30" -c:v libx264 -crf 18 formula_fixed.mp4

# 확인: 길이·해상도·코덱이 의도대로인지
ffprobe -v error -show_entries stream=codec_name,width,height,r_frame_rate \
        -show_entries format=duration -of default=nw=1 final.mp4

from manim import *

class HelloManim(Scene):
    def construct(self):
        title  = Text("Motion Stack OK", font_size=56, color=GREEN)
        circle = Circle(radius=1.4, color=BLUE).shift(DOWN * 1.2)

        self.play(Write(title), run_time=1.2)              # 글자가 그려지며 등장
        self.play(title.animate.shift(UP * 1.6), run_time=0.6)  # .animate = 상태 전이
        self.play(Create(circle), run_time=1.0)             # 선이 그려짐
        self.play(circle.animate.set_fill(BLUE, opacity=0.5), run_time=0.8)
        self.wait(0.4)

# PATH가 안 잡혀 있으면 먼저 (pip --user 설치본)
export PATH="$HOME/Library/Python/3.11/bin:$PATH"

manim -ql --disable_caching scene.py HelloManim   # 빠른 미리보기 480p15
manim -qh scene.py HelloManim                     # 최종 1080p60
manim -qk scene.py HelloManim                     # 4K
manim -ql -s scene.py HelloManim                  # 마지막 프레임만 PNG로

# 출력 위치: ./media/videos/scene/<품질>/HelloManim.mp4
# 실측(이 환경, -ql): 5개 애니메이션 · 4.0초 영상 렌더 완료

<div id="root" data-composition-id="main"
     data-start="0" data-duration="6" data-width="1920" data-height="1080">
  <h1 id="title" class="clip" data-start="0" data-duration="6" data-track-index="0">
    Motion Stack
  </h1>
  <p id="sub" class="clip" data-start="0.6" data-duration="5.4" data-track-index="1">
    HTML · CSS · GSAP
  </p>
</div>

<script>
  const tl = gsap.timeline({ paused: true });   // ★ 반드시 paused

  tl.fromTo("#title",
      { opacity: 0, y: 28 },
      { opacity: 1, y: 0, duration: 0.8, ease: "power3.out" }, 0);
  tl.fromTo("#sub",
      { opacity: 0 },
      { opacity: 1, duration: 0.6 }, 0.6);   // ← 세 번째 인자 = 시작 시각(초)
  tl.to("#title, #sub", { opacity: 0, duration: 0.5 }, 5.2);

  window.__timelines["main"] = tl;   // ★ 렌더러가 이걸 시킹한다
  tl.seek(0);
</script>

npm run check    # 린트 + 모션 + 대비(WCAG) 검사
npm run render   # mp4 (헤드리스 크롬 + ffmpeg)
npm run dev      # 미리보기 서버

# 이 환경에서의 실제 check 출력:
#   ◇ 0 issues across 9 sample(s)
#   Motion     ◇ 0 errors, 0 warnings
#   Contrast   ◇ 59/59 text checks pass WCAG AA
#   ◇ Check passed

import { AbsoluteFill, interpolate, spring, useCurrentFrame, useVideoConfig } from "remotion";

type Props = { data: { label: string; value: number }[] };

export const BarChart: React.FC<Props> = ({ data }) => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();
  const max = Math.max(...data.map((d) => d.value));

  return (
    <AbsoluteFill style={{ background: "#0f172a", padding: 80, gap: 18,
                            flexDirection: "column", justifyContent: "center" }}>
      {data.map((d, i) => {
        // 막대마다 4프레임씩 지연 — stagger
        const p = spring({ frame: frame - i * 4, fps, config: { damping: 14 } });
        const w = interpolate(p, [0, 1], [0, (d.value / max) * 100]);
        return (
          <div key={d.label} style={{ display: "flex", alignItems: "center", gap: 16 }}>
            <div style={{ width: 160, color: "#94a3b8", fontSize: 28 }}>{d.label}</div>
            <div style={{ height: 44, width: `${w}%`, background: "#e879f9", borderRadius: 8 }} />
            <div style={{ color: "#e2e8f0", fontSize: 26 }}>
              {Math.round(d.value * p)}
            </div>
          </div>
        );
      })}
    </AbsoluteFill>
  );
};

// Root.tsx 에 등록 — defaultProps로 데이터를 주입한다
<Composition
  id="BarChart" component={BarChart}
  durationInFrames={150} fps={30} width={1920} height={1080}
  defaultProps={{ data: [
    { label: "Remotion", value: 82 },
    { label: "HyperFrames", value: 74 },
    { label: "Manim", value: 61 },
  ] }}
/>

# props를 JSON으로 주입해 같은 컴포지션을 다른 데이터로 렌더
npx remotion render BarChart out/week1.mp4 \
  --props='{"data":[{"label":"A","value":40},{"label":"B","value":90}]}'

# 파일에서 읽어 반복 (주간 리포트 자동화 패턴)
for f in data/week*.json; do
  npx remotion render BarChart "out/$(basename "$f" .json).mp4" --props="$f"
done

코드로 제너러티브 아트 만들어줘.

조건:
- 플로우 필드 기반, 선 중심 구성
- 캔버스 1080x1080, 배경은 아주 어두운 네이비
- 팔레트는 3색 이내, 라임 계열 강조색 하나
- 시드를 고정해서 같은 결과를 다시 뽑을 수 있게 해줘
- 결과를 PNG로 저장하고, 시드 값을 파일명에 넣어줘

나중에 플로터로 출력할 수도 있으니 SVG 버전도 같이 만들어줘.

[1단계] Blender를 열고 N키 → MCP 탭 → Start MCP Server 를 눌렀는지 먼저 확인
        (이걸 안 하면 claude mcp list가 Connected여도 조작이 안 된다)

[2단계] Claude에게:
  "블렌더에 지름 2짜리 구를 원점에 만들고,
   금속 재질(roughness 0.2)을 입혀줘.
   카메라는 45도 위에서 내려다보게 배치하고,
   HDRI 환경광을 넣어서 1920x1080으로 렌더해줘."

[3단계] 결과를 확인하고 세부 조정:
  "구를 조금 왼쪽으로 옮기고, 바닥에 반사되는 평면을 추가해줘"

※ 복잡한 작업은 한 번에 요청하지 말고 단계로 나눌 것.
   3D는 중간 결과를 봐야 다음 지시가 정확해진다.

# 스킬 (폴더를 지우면 끝)
rm -rf ~/.claude/skills/manim-skill
rm -rf ~/.claude/skills/algorithmic-art

# 플러그인
claude plugin uninstall hyperframes@hyperframes
claude plugin marketplace remove hyperframes          # 마켓플레이스 등록도 해제

# MCP 서버 등록 해제
claude mcp remove blender -s user
# Blender 애드온은 따로 지운다
rm -f "$HOME/Library/Application Support/Blender/5.2/scripts/addons/blender_mcp.py"

# Manim (PyPI)
pip3 uninstall manim
# ~/.zshrc, ~/.bash_profile 에 추가한 PATH 줄도 직접 삭제

# Blender 앱
brew uninstall --cask blender

# 캐시 정리 (용량 회수)
rm -rf ~/.cache/uv          # uvx 패키지 캐시
npm cache clean --force     # npx 캐시

# 프로젝트는 폴더째 지우면 된다 (전역에 남는 것이 없다)
rm -rf my-video

# 1) 각 구간 산출 (해상도·fps를 처음부터 맞춘다 — 나중에 맞추면 재인코딩 손실)
cd intro-hf     && npm run check && npm run render   # → renders/*.mp4
cd ../formula   && manim -qh scene.py Explain          # → media/videos/.../Explain.mp4
cd ../chart-rem && npx remotion render BarChart out/chart.mp4 --props=data.json

# 2) 사양 확인 — 다르면 합치기가 실패하거나 결과가 깨진다
for f in intro.mp4 formula.mp4 chart.mp4; do
  echo -n "$f: "
  ffprobe -v error -select_streams v:0 \
    -show_entries stream=width,height,r_frame_rate,codec_name -of csv=p=0 "$f"
done

# 3) 합치기
printf "file 'intro.mp4'\nfile 'formula.mp4'\nfile 'chart.mp4'\n" > list.txt
ffmpeg -f concat -safe 0 -i list.txt -c copy final.mp4

# 4) 결과를 "열어서" 확인 (구간 경계마다 프레임 추출)
for t in 2 10 30; do ffmpeg -y -ss $t -i final.mp4 -frames:v 1 check_$t.png; done

# 전제: Remotion 컴포지션이 props로 데이터를 받도록 작성돼 있다(13장 ③)

# 1) 데이터 준비 — 주차별 JSON
#    data/2026-W41.json, data/2026-W42.json ...

# 2) 일괄 렌더
mkdir -p out
for f in data/*.json; do
  name=$(basename "$f" .json)
  echo "── 렌더: $name"
  npx remotion render BarChart "out/$name.mp4" --props="$f" || echo "❌ 실패: $name"
done

# 3) 산출물 검증 — 파일이 생겼다고 내용이 맞는 건 아니다
for m in out/*.mp4; do
  d=$(ffprobe -v error -show_entries format=duration -of default=nw=1:nk=1 "$m")
  s=$(wc -c < "$m")
  echo "$m  ${d}s  ${s}B"
  # 길이가 0이거나 용량이 비정상적으로 작으면 빈 영상일 가능성
done

# 4) 한 편만 눈으로 확인 (샘플링)
ffmpeg -y -ss 2 -i out/2026-W41.mp4 -frames:v 1 sample.png

□ node -v                        → v20.19+ / v22.13+ / v24+
□ ffmpeg -version | head -1      → 버전이 찍힌다
□ uv --version                   → 버전이 찍힌다
□ manim --version                → Manim Community v0.22+
□ ls -d /Applications/Blender.app → 존재
□ claude mcp list | grep blender → ✔ Connected
□ claude plugin list             → hyperframes@hyperframes · enabled
□ ls ~/.claude/skills/           → manim-skill, algorithmic-art, hyperframes* 포함

※ 한 번에: bash motion-stack-setup.sh --check

□ Remotion     : npx remotion render HelloMotion out/hello.mp4
                 → 약 45KB · 재생 시 라임색 "Remotion OK" 보임
□ HyperFrames  : npm run check → "Check passed" / npm run render → mp4 생성
□ Manim        : manim -ql scene.py HelloManim
                 → media/videos/scene/480p15/HelloManim.mp4
□ algorithmic-art : Claude에게 "코드로 제너러티브 아트" 요청 → 시드 포함 PNG
□ Blender      : GUI에서 Start MCP Server 후
                 "큐브 하나 만들어줘" → 뷰포트에 실제로 생성됨

※ 각 산출물을 반드시 "열어서" 확인할 것.
  렌더 성공 로그는 내용이 맞다는 증거가 아니다.

brew install whisper-cpp          # 1.9.5 (ggml-org 공식)

# 모델은 별도 다운로드. 한국어 정확도를 위해 large-v3-turbo 권장(1.5GB)
mkdir -p ~/.cache/whisper-models && cd ~/.cache/whisper-models
curl -fL -o ggml-large-v3-turbo.bin \
  "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo.bin"

# 가벼운 대안: ggml-small.bin(488MB) · ggml-base.bin(148MB)

# whisper.cpp는 16kHz 모노 WAV만 받는다. 영상은 먼저 변환
ffmpeg -y -i input.mp4 -ar 16000 -ac 1 -c:a pcm_s16le audio.wav

# 받아쓰기 (❌ -l ko 를 빼면 영어로 가정해 엉뚱하게 나온다)
whisper-cli -m ~/.cache/whisper-models/ggml-large-v3-turbo.bin \
  -l ko -f audio.wav -osrt          # -ovtt -otxt -oj 동시 지정 가능

# 소프트 자막(끌 수 있음, 빠름)
ffmpeg -y -i input.mp4 -i audio.wav.srt -c copy -c:s mov_text output.mp4

# 하드 자막(영상에 각인, SNS·발표용)
ffmpeg -y -i input.mp4 -vf "subtitles=audio.wav.srt:force_style='FontName=Pretendard,FontSize=22,BorderStyle=3'" \
  -c:v libx264 -crf 18 -c:a copy output.mp4

# 저장소에 스킬과 "Skia Skottie 플레이어" 프로젝트가 함께 들어있다.
# 스킬은 이 플레이어로 결과를 검증하도록 설계돼 있어 둘 다 필요하다.
git clone --depth 1 https://github.com/diffusionstudio/lottie.git /tmp/lottie

# 1) 스킬은 전역 스킬 경로로 (폴더 한 겹 더 들어가지 않게 주의)
cp -R /tmp/lottie/skills/text-to-lottie ~/.claude/skills/text-to-lottie

# 2) 플레이어 프로젝트는 작업 폴더에 둔다
mv /tmp/lottie <프로젝트>/lottie-player
cd <프로젝트>/lottie-player && npm install && npm run dev

git clone --depth 1 https://github.com/calesthio/OpenMontage.git openmontage
cd openmontage
make setup        # .venv 생성 + pip + remotion npm + piper-tts + hyperframes 캐시

# 검증
make hyperframes-doctor
make demo-list                              # zero-key 데모 3종
.venv/bin/python render_demo.py code-to-screen   # 실측: 750프레임 → 3.6MB mp4

# 로컬 TTS — 설치함 (나레이션)
pip3 install --user kokoro-onnx soundfile
#   확인: hyperframes doctor → ✓ TTS (Kokoro) Kokoro deps installed

# 로컬 BGM — 설치하지 않음 (torch 포함 약 2.5GB)
#   필요해지면: pip install transformers torch soundfile numpy