🐍 Python

Coding Style

📏 Python Sytle Guide

• Google Python Style Guide
• Documenting Python Code: A Complete Guide

📏 Documentation

# Module

"""A one-line summary

Detailed descriptions for the module or program.
You may include 'how to run this' or 'usage of functions/classes'

"""

# Function
def function_name(args):
    """Function Description shortly

    More details for this class...
    More details for this class...

    Args:
        arg_name: description

    Returns:
        what to return
    
    Raises:
        error_type: why we get this error
    """

# Class
class ClassName:
    """A one-line summary

    More details for this class...
    More details for this class...

    Attributes:
        attrib_name: description
    """

📏 Indentations and Spaces

# Examples: Parentheses --------------------------------
foo = long_function_name(var_one, var_two,
                         var_three, var_four)

meal = (spam,
        beans)

foo = long_function_name(
    var_one, var_two, var_three,
    var_four)

foo = long_function_name(
    var_one, var_two, var_three,
    var_four
)

# String ------------------------------------------------
# One Tab (= 4 spaces)
long_string = """This is fine if your use case can accept
    extraneous leading spaces."""

# Use parentheses
long_string = ("And this is fine if you cannot accept\n" +
               "extraneous leading spaces.")
long_string = ("And this too is fine if you cannot accept\n"
               "extraneous leading spaces.")

# textwarp
import textwrap
long_string = textwrap.dedent("""\
    This is also fine, because textwrap.dedent()
    will collapse common leading spaces in each line.""")

📏 Function signature

def my_method(
    self,
    first_var: int,
    second_var: Foo,
    third_var: Bar | None,
) -> int:

# spaces around `=` if the argument have type annotation & default value
def func(a: int = 0) -> int:

📏 Type Annotation

• var: type = value format
• typing module can be used

# Variables
path: str = '/home/winterbloooom/foo.txt'
paths: list = [path1, path2, path3]

# Functions
def show_paths(paths: list, max_num: int = 3) -> str:
    return 'done'

# With `typing` module
from typing import List, Dict
food: List[str] = ['banana', 'apple']
students: Dict[str, int] = {'eungi': 100, 'winterbloooom': 99}

• References
  • 파이썬 타입 어노테이션/힌트 (Blog)
  • typing 모듈로 타입 표시하기 (Blog)

📏 Naming Convention

• Package / module - package_name , module_name
  • DO NOT use dashes(-)
• Function - function_name
• Variable
  • Global Constant - GLOBAL_CONSTANT_NAME
  • others - var_name
• Class - ClassName
• Exception - ExceptionName

Here's a guideline from Gudio

Type	Public	Internal
Packages	lower_with_under
Modules	lower_with_under	_lower_with_under
Classes	CapWords	_CapWords
Exceptions	CapWords
Functions	lower_with_under()	_lower_with_under()
Global/Class Constants	CAPS_WITH_UNDER	_CAPS_WITH_UNDER
Global/Class Variables	lower_with_under	_lower_with_under
Instance Variables	lower_with_under	_lower_with_under (protected)
Method Names	lower_with_under()	_lower_with_under() (protected)
Function/Method Parameters	lower_with_under
Local Variables	lower_with_under

📏 Black & isort formatting

[ Formatting with Black and isort ]

• Black for Python code formatting
• isort for Python import sorting

[ Method 1. VSCode extensions ]

• Black Formatter (by Microsoft)
• isort (by Microsoft)

1. command + shift + p
2. Preferences: Open User Settings (JSON)
3. Insert code blow

"[python]": {
    "diffEditor.ignoreTrimWhitespace": false,
    "editor.defaultFormatter": "ms-python.black-formatter",
    "editor.formatOnSave": true,
},
"isort.args":["--profile", "black"],

[ Method 2. Commandline ]

• Installation**

  pip install black
  pip install isort

• Usage 1: command

  black <file or path>
  isort <file or path>

• Usage 2: with pyproject.toml configuration file
  • Make this file in the directory where the .gitignore exists.

    [tool.black]
    line-length = 100
    target-version = ['py39']
    exclude = '''
      \.git
      \DIR_OR_FILE_NAME
    '''
    
    [tool.isort]
    profile = "black"
    multi_line_output = 3
    use_parentheses = true
    line_length = 100
    skip = [".gitignore"]
    

  • then run commands below.

    black --config pyproject.toml <PATH>
    isort --settings-path pyproject.toml <PATH>

[ Use with Pre-commit ]

• Installation

  pip install pre-commit

• pre-commit configuration file
  • Make a file named .pre-commit-config.yaml in the directory where the .gitignore exist.

    repos:
      - repo: https://github.com/PyCQA/isort
        rev: 5.10.1
        hooks:
          - id: isort
    
      - repo: https://github.com/ambv/black
        rev: 22.6.0
        hooks:
          - id: black

• Make pre-commit hook

  pre-commit install

• Commit

  git commit -am "pre-commit test"

📏 String Formatting

# 천 단위 콤마 표시
print(f"{value:,}")
# 천 단위 콤마 표시 + 소숫점 (소숫점 앞 5자리, 뒤 2자리)
print(f"{value:5,.2f}")

# Scientific Notation (지수 표현)
print("{value:.2e}") # 1234567.89 -> 1.23e+06
print("{value:.2e}") # 0.0000001234 -> 1.23e-07

For your smart codes

📌 Check the type or value of the function arguments

if not isinstance(argument, (type1, type2, ...)):
    # Preprocess the argument

assert isinstance(argument, type1), f"Error message"
		# If fasle, Python occurs an AssertionError

# Example
def function_name(arg1, arg2):
    print(isinstance(arg1, str))
    assert isinstance(arg2, bool), f"""The type of 'arg2' is not matched. It should be {bool.__name__}, not {type(arg2).__name__}."""

📌 Configuration - OmegaConf

👉 Basic Usage

from omegaconf import DictConfig

# yaml -> DictConfig
conf = OmegaConf.load('source/example.yaml')
# DictConfig -> yaml
print(OmegaConf.to_yaml(conf))

# Access
conf.dataset.name
conf['dataset']['name']

# Default Values
conf.get('missing_key', 'default_value')

# Merge configs
conf = OmegaConf.merge(base_cfg, model_cfg, optimizer_cfg, dataset_cfg) # each params are DictConfig types

# Convert to primitive container (dict)
primitive = OmegaConf.to_container(conf) # to_container(conf, resolve=True)

👉 Resolvers

• oc.env: environment variables
• oc.create: make new DictConfig

user: ${oc.env:USER}

📌 Set the root directory

프로젝트 폴더 내에서 from, import 문을 사용해야 할 때 헷갈리는 경우가 있다. 루트 디렉토리를 설정하면 from 폴더1_이름.폴더2_이름 import 파일_이름 식으로 사용이 쉽다.

• Choice 1: pyrootutils.setup_root()

  # .git 이 있는 곳을 root로 지정
  import pyrootutils
  root = pyrootutils.setup_root(
      search_from=__file__,
      indicator=[".git"],
      pythonpath=True,
      dotenv=True,
  )

• Choice 2: sys.path.insert()

  # os.path.dirname(__file__) : 현 파일이 있는 디렉토리 경로
  # sys.path.insert(0, [PATH]): [PATH]를 환경변수에 등록
  import sys, os
  sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '.')))

📌 Skip warning messages

import warnings
warnings.simplefilter("ignore", UserWarning)

📌 Progress bar

from tqdm import tqdm

for item in tqdm(my_list, desc="description")
for idx, item in enumerate(tqdm(my_list, desc='description'))

• References
  • Reference1

📌 Parsing the arguments

import argparse

parser = argparse.ArgumentParser(description="Description of this project")
parser.add_argument("--arg_name", type=int, default=None, help="description of this argument")
args = parser.parse_args()

• Description & default value of the argument

  parser.add_argument("--arg_name", default=None, help="description of this argument")

• Define the names of the argument

  parser.add_argument("--arg_name", "-n")

• Specify the type (e.g., string)

  parser.add_argument("--arg_name", type=str)

• Specify the options

  parser.add_argument("--arg_name", choices=[1, 2, 3])
  parser.add_argument("--arg_name", choices=range(0, 100))

• Actions
  • (1) store (default): store the value to the argument
  • (2) append: when you want to store multiple values as an list
    • e.g., --arg_name 1 --arg_name "12", --arg_name False -> [1, "12", False]
  • (3) store_true: store true

  parser.add_argument('--arg_name', action='store_true')
  # [Wrong] parser.add_argument('--test', type=bool) -> if `--test False`, it also save True!
  # just `python main.py --arg_name`. If this argument not mentioned, False is stored.

• Specify the number of values
  • N: read N values (e.g., --arg_name "spring" "winter")
  • *: read multiple values (e.g., --arg_name 1 2 3 4)
  • +: read at least one value
  • etc...

  parser.add_argument('--arg_name', nargs='2') 

• Change the variable name to store the value

  parser.add_argument("--arg_name", dest="arg_new_name")

• Positional (you must pass the value)
  • There isn't - before the name of the argument
  • You can just pass the value without the name (e.g., python example.py "happy"), just keep the sequence of positional arguments
  • If you want to change optional to positional, `parser.add_argument("--arg_name", required=True)``

  parser.add_argument("arg_name")

• the number of arguments: len(sys.argv)
• Print the help: parser.print_help()

Useful modules & functions

🌱 Running arguments

Python running arguements

• -m: run python module directly

  project/
  │── mypackage/
  │   │── __init__.py
  │   │── myscript.py
  │── main.py
  

  • You can run the myscript.py with python -m mypackage.myscript rather than python mypackage/myscript (it may occur import error)
• -u

🌱 Get information about current status

Date & Time in text

import datetime
datetime.datetime.now().strftime("%y_%m_%d-%H_%M_%S")
# e.g., 24_02_16-17_26_20

Current running file/directory

import os
# file name
f_name = os.path.abspath(__file__) # absolute path
f_name = os.path.realpath(__file__) # relateive path
# directory name
os.path.dirname(f_name)

Name of function

import sys
sys._getframe(1).f_code.co_name # 현재 함수
sys._getframe(2).f_code.co_name # 이를 호출한 함수

Print the file name, line number, and function name

import inspect
cf = inspect.currentframe()
print(f'\nFile "{cf.f_code.co_filename}", line {cf.f_lineno}, in {cf.f_code.co_name}')
# e.g., File "/home/eungi/4D-Humans/hmr2/datasets/__init__.py", line 68, in __init__

Attributes of Object

hasattr(obj, 'age') # obj라는 개체에 'age'라는 속성이 있으면 True
getattr(obj, 'age', 'No age attribute') # obj라는 개체에 'age'라는 속성의 값을 가져오고, 없으면 세 번째 텍스트 출력
setattr(obj, 'age', 25) # obj라는 개체에 'age'라는 속성을 25로 추가/변경

🌱 File/Directory Paths

Existance of File/Directory

import os
os.path.exist(PATH)

Compose file paths

import os
path = '/home/data/my_dataset'
file_name = 'image_list.txt'
os.path.join(path, file_name)

Files in the directory

import os
# file names
list_of_files = os.listdir('PATH_OF_DIR') # list
# file paths
list_of_paths = [os.path.join('DIR_PATH', fname) for fname in list_of_files]

List of files with condition

import glob
file_list = glob.glob("*.jpg")

🌱 Control

Turn off the program here

import sys; sys.exit()

pdb debugger

• import: import pdb
• break point: pdb.set_trace()
  • n to execute next line
  • c to continue (next break point)
  • q to quite
  • s to step into
• References
  • pytorch 디버깅 함수 (Blog)

🌱 File Handling

text 파일 읽/쓰기

with open("foo.txt", "r") as f:
    lines = f.readlines()

with open("foo.txt", "w") as f:
    f.write("Life is too short, you need python")

pickle (.pkl) 파일 읽/쓰기

import pickle

# save
SOMETHING = [1, 2, 3] # example
with open("FILE_NAME.pickle", "wb") as f:
    pickle.dump(SOMETHING, f)

# load
with open("FILE_NAME.pickle", "rb") as f:
    data = pickle.load(f)

🪄 NumPy

import numpy as np

📦 Load npy, npz file

# npz: 키 목록 보기
data = np.load(PATH)
keys = [k for k in data.keys()] # print(data.keys())는 안 보임

# 저장된 데이터가 딕셔너리라면
data = (np.load(PATH, allow_pickle=True)).item()
data[KEY] # 키 이용해 데이터 접근

🔥 PyTorch

Process Image/Video

Image at PIL / OpenCV / PyTorch

	PIL	OpenCV	PyTorch
load	Image.open()	cv2.imread()
size func.	img.size	img.shape	tensor.shape or tensor.size()
size	(w, h)	(h, w, c)	(c, h, w)
dtype	8 (img.bits)	uint8 (img.dtype)	torch.float32 (0~1) (tensor.dtype)
range	0 ~ 255	0 ~ 255	0 ~ 1
format	RGB (img.mode)	BGR	RGB

• PIL

  from PIL import Image
  img = Image.open('path_of_image')
  
  # PIL -> Numpy
  import numpy as np
  img = np.asarray(img) # or np.array(img)
  # Numpy -> PIL
  img = Image.fromarray(img)

• OpenCV

  import cv2
  img = cv2.imread('path_of_image')

• PyTorch

  # PIL -> tensor
  import torchvision.transforms.functional as F
  img = Image.open('path_of_image')
  img = F.to_tensor(img)
  # Numpy -> tensor
  from torchvision.transforms import ToTensor
  toTensor = ToTensor()
  img = toTensor(img)
  # cv -> tensor (1)
  img = cv2.imread(path)
  img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # RGB -> BGR
  img = img.transpose((2, 0, 1)) # H,W,C -> C,H,W
  img = img.float().div(255.0) # normalize
  # cv -> tensor (2)
  img = cv2.imread(path)
  img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # RGB -> BGR
  img = img.Tensor(img) # normalize
  img = img.permute(2, 0, 1) # H,W,C -> C,H,W
  
  # tensor -> PIL, NumPy
  from torchvision.transforms import ToPILImage
  toPILImage = ToPILImage()
  img = toPILImage(img)
  # tensor -> cv
  img = img.detach().cpu().numpy() # tensor -> numpy
  img = np.transpose(img, (1, 2, 0)) # C,H,W -> H,W,C
  img = img*255 # denormalize
  img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # BGR -> RGB
  img = img.astype(np.uint8).copy() # np.float32 -> np.uint8

• cv to torch in lambda func.

  • Reference: Jinsol Kim

  load_images = lambda path, h, w: cv2.resize(cv2.cvtColor(cv2.imread(path, cv2.IMREAD_UNCHANGED), cv2.COLOR_BGR2RGB), ((w, h)))
  tensorify = lambda x: torch.Tensor(x.transpose((2, 0, 1))).unsqueeze(0).float().div(255.0)
  
  img_tensor = tensorify(load_images("img.png", 400, 300))
  print(img_tensor.shape) # torch.Size([1, 3, 400, 300])

Save the image

• Tensor type

  # (1) torchvision
  # Option: nrow (한 줄에 몇 개의 이미지), padding (이미지 간 몇 픽셀 간격), etc
  from torchvision.utils import save_image
  save_iamge(img, 'path_of_image') # (B, C, H, W) -> (W, H, C)
  
  # (2) plt
  import matplotlib.pyplot as plt
  img = img.permute(1, 2, 0) # [C, H, W] -> [H, W, C]

• Numpy, PIL type

  import numpy as np
  from PIL import Image
  img = Image.fromarray(img) # numpy -> PIL
  img.save('path_of_image', 'jpg')

Save the video

import torchvision
# video: np.ndarray, [Time, Hight, Width, Channel], 0~255, np.uint8
torchvision.io.write_video(save_fname, video, fps=fps, audio_codec='aac')

Use CUDA (GPU)

Check CUDA

import torch; print(torch.cuda.is_available()) # True of False

Setting GPU Devices

# Method 1)
import os
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = <gpu_numbers> 
    # e.g., "1, 2" - assign GPU number 0 and 1 for each GPU 1, GPU 2

# Method 2)
import torch; torch.cuda.set_device(1)

# Method 3) Commandline
CUDA_VISIBLE_DEVICES=2,3 python script_fname.py

Checkpoint and Pre-trained model

Load model

• PATH: checkpoint file
• DEVICE: running device (type: torch.device)
• MODEL: model to load parameters

checkpoint = torch.load(PATH, map_location=DEVICE)

# if you save only model_state_dict
MODEL.load_state_dict(checkpoint)
# if you save all parameters of model, optimizer, etc.
MODEL.load_state_dict(checkpoint["model_state_dict"])

Tensors

Merge lists to tensors

# list[tesor, tensor, ...] -> tensor[tensor, tensor, ...]
torch.stack(list_name, dim=0)

Dataset & Dataloader

Sampler

• 커스텀 샘플러 만들기

🚀 Other Python Tools

wandb

import wandb

initiate

# init
wandb.login()
wandb.init(
    project="PROJECT_NAME",
    entity="USER_NAME",
    name="EXPERIMENT_NAME",
    config = {
        "CONFIG1": config1,
    },
    notes="NOTES",
)

Logging

# logging - number
wandb.log({
    "train/loss1": loss.item(), 
    "val/metric1": metric,
})
# logging - image
# e.g., wandb.log({"result_img": wandb.Image(output_img, mode="RGB", caption="step_2 result")})
wandb.log({'<NAME>': wandb.Image(<IMAGE>, mode="<MODE>", caption="<CAPTION>")})

# logging - video
# e.g., wandb.log({"video": wandb.Video("/home/eungi/video.mp4", fps=30, format="mp4")})
wandb.log({"<NAME>": wandb.Video(<VIDEO_PATH>, fps=<FPS>, format="<FORMAT>")})

Tensorboard

Show tensorboard

tensorboard --logdir=<log_directory_path> --port=<port_number>

Port forwarding

ssh -NfL localhost:<server_port>:localhost:<local_port> <server_name>

# example
ssh -NfL localhost:6007:localhost:6007 eungi@gpu01

• References
  • Remote 서버에서 Tensorboard 연결하기
  • remote server 로부터 Tensorboard 사용하는 방법

dotenv

dotenv로 환경변수 관리

• .env 파일에 환경변수 정의
  • 코드 내 민감 정보를 적지 않고도 환경변수 관리 용이

API_KEY=your_api_key

• 설치: pip install python-dotenv
• 사용: from dotenv import load_dotenv; load_dotenv()
• 환경변수 값 가져오기: os.getenv('API_KEY') 혹은 os.environ['API-KEY]

🔦 Dev Tools

tmux

Usage

• seesion list: tmux ls

• make session: tmux new -s <session-name>

• session attach: tmux a -t <session-name>

• session detach: Ctrl + b → d

• Split vertically: Ctrl + b → %

• Split horizontally: Ctrl + b → >

• Change focus: Ctrl + b → direction_key or space

• Scroll: Control + b → [ / q to quit

Installation

### Install

# ubuntu
sudo apt install tmux

# mac
brew install tmux

### Check installation
tmux -V

tmux configuration

Create/Edit ~/.tmux.conf file:

vi ~/.tmux.conf

the, run:

tmux source-file ~/.tmux.conf

Configs:

• 마우스 사용 허용: set -g mouse on
• Other options

Anaconda

Usage

• environment list: conda env list
• create environment: conda create --name <env_name> [python=<py_version>]
• remove environment: conda env remove --name <env_name>
• clone environment: conda create --name <AFTER> --clone <ORIGINAL>
• change environment name: (이름 변경은 지원 안 함) 원하는 이름으로 그 환경을 __복사__해두고 원래 이름의 환경은 지우기
• activate environment: conda activate <env_name>
• deactivate environment: conda deactivate
• Package List: conda list
• Clean: conda clean --all
• pip clean: pip cache purge

Git and GitHub

Remote Repository

# Check registered remotes
# You can use `git remote get-url origin` instead
git remote -v

# After making an empty repository in GitHub,
# add remote repository in local repository.
git remote add origin <URL-OF-REMOTE-REPOSITORY>

# Push
git branch -M main
git push -u origin master

# GitHub에서 merge하고 local에 동기화
git fetch -p # 원격 브랜치 삭제 내역 반영
git pull
git branch -d <branch_name> # 로컬 브랜치 삭제

Branch naming convention

• https://medium.com/@abhay.pixolo/naming-conventions-for-git-branches-a-cheatsheet-8549feca2534

Clone specific vertion of commit

1. Clone repo: git clone <repo_address>
2. Go to that commit: git reset --hard <commitID>

VSCode

Debugging Configurations

• 항상 특정 파일에서 디버깅하기: "program": "파일명". ${file}은 디버깅 버튼을 누른 해당 파일을 의미
• 환경 변수 설정하기: env 딕셔너리에 입력
• 루트 경로가 아닌, 특정 경로에서 디버깅 시작 (change directory): cwd에 입력. 현재 열려있는 파일의 디렉토리 이름은 ${fileDirname}

"env": {
	"CUDA_VISIBLE_DEVICES": "6"
},
"cwd": "src" 

• python -m으로 시작하는 실행

"module": "dir/.../file" # program  대신

Kill VSCode server process

# check process list
ps -ef | grep <UserName> | grep vscode
# Kill all processes
#kill -9 $(ps -eL | grep <UserName> | grep vscode)

https://bakyeono.net/post/2015-05-05-linux-kill-process-by-name.html

Change all upper/lowercases

• (Windows) Ctrl + Shift + U
• 변경할 부분 선택 -> Cmd + Shift + P -> transform to ...

Extensions

• indent-rainbow: Colorize indentations
• Comment Anchors: Comment with anchor tags
• Black Formatter: Python code formatter
• isort: Python import part formatter

Rulers (에디터 세로선)

cmd + shift + P → Open settings (JSON)

"editor.rulers": [
    {
    	"column": 88,
    },
],

ffmpeg/ffprobe

Video <-> image frames

Options:

• -ss/-to/-t: 추출 시작/종료시점/종료길이 설정. hh:mm:ss, hh:mm:ss.sss, s 형식
• -framerate: '입력' 비디오/이미지 스트림의 FPS. 주로 이미지 파일을 비디오로 변환 시 사용
• -r: '출력' 파일의 초당 프레임 레이트를 설정. 입력 비디오의 프레임 레이트 조정 혹은 비디오 인코딩 시 사용.
• -f: 출력 파일의 포맷 지정. image2이면 입력 파일을 비디오가 아니라 이미지로 처리하도록 지시.
• 출력 파일 이름 포맷: %d이면 순차적으로 1, 2, 3, ...이고, %06d이면 여섯 자리를 맞추되 앞 부분을 0으로 채우는 식.
• -qscale:v 또는 -q:v: 비디오 품질 비율. 낮을수록 품질 좋고 파일 크기가 큼. 기본 2
• -c:v: 비디오 코덱 지정
  • libx264: H.264 코덱
  • mpeg4: MPEG-4 Part 2 코덱. 오래된 장치나 SW의 호환을 위해 사용
  • copy: 재인코딩 없이 원본파일에서 그대로 복사(속도 빠름, 품질 손실 없음)
• pix_fmt: 비디오의 픽셀 포맷 설정. yuv420p이면 H.264에서 널리 사용되는 포맷.

# Extract frames from a video
ffmpeg -i <VideoPath> -f image2 <ImgPath%d.png>
# ffmpeg -ss 00:01:00 -to 00:21:00 -i input.mp4 -r 25 -f image2 image_%06d.png
# PNG로 변환하지 않으면 화질이 깨질 때가 종종 있음

# Merge frames into single video
ffmpeg -framerate <FPS> -i <PathPattern> -c:v <Value> -pix_fmt <Value> <OutVideoPath.mp4>
# ffmpeg -framerate 25 -i iamge_%03d.png -c:v libx264 -pix_fmt yuv420p <OutVideoPath.mp4>

Merge multiple images in one frames

# 4 images to one (upper left, upper right, lower left, lower right)
ffmpeg \
-i [ul_path] -i [ur_path] -i [ll_path] -i [lr_path] \
-filter_complex "[0:v][1:v]hstack=inputs=2[top];[2:v][3:v]hstack=inputs=2[bottom];[top][bottom]vstack=inputs=2[out]" \
-map", "[out]" \
[save_path]

import subprocess
cmd = [
    'ffmpeg', '-y', '-loglevel', "error",
    '-i', ul, '-i', ur, '-i', ll, '-i', lr,
    "-filter_complex",
    "[0:v][1:v]hstack=inputs=2[top];"
    "[2:v][3:v]hstack=inputs=2[bottom];"
    "[top][bottom]vstack=inputs=2[out]",
    "-map", "[out]",
    save_path
]
return_code = subprocess.call(cmd)

Extract audio from video

Options:

• -ac: 오디오 채널 설정. 1은 모노(1채널), 2는 스테레오(2채널)
• -vn: 비디오 스트림 제외
• -ar: 오디오 샘플링 레이트 설정
• -acodec 혹은 -c:a: 오디오 코덱 설정
  • pcm_s16le는 비압축 오디오(고품질, 고용량)이며, 확장자는 wav로 저장하는 게 일반적.
  • aac는 mp3 대체 위한 고효율 오디오 코덱
  • copy이면 별도의 인코딩 없이 원본파일에서 그대로 복사(속도 빠름, 품질 손실 없음)

ffmpeg -i <VideoPath> -ac 1 -c:a <Value> -ar <SampleRate> -vn <OutPath.[wav/mp4/m4a/aac]>

Merge audio and video

Options:

• -c:v: 비디오 코덱 지정
  • libx264: H.264 코덱
  • mpeg4: MPEG-4 Part 2 코덱. 오래된 장치나 SW의 호환을 위해 사용
  • copy: 재인코딩 없이 원본파일에서 그대로 복사(속도 빠름, 품질 손실 없음)
• -acodec 혹은 -c:a: 오디오 코덱 설정
  • pcm_s16le: 비압축 오디오(고품질, 고용량)이며, 확장자는 wav로 저장하는 게 일반적.
  • aac: mp3 대체 위한 고효율 오디오 코덱
  • copy: 재인코딩 없이 원본파일에서 그대로 복사(속도 빠름, 품질 손실 없음)

ffmpeg -i <VideoPaht> -i <AudioPath> -c copy -c:v <Value> -c:a <Value> <OutputPath.mp4>

Cut the audio

ffmpeg -i <AudioPath> -ss <StartTime> -to <EndTime> <OutAudioPath.wav>

Give offset (delay) to audio and video

ffmpeg -i <VideoPaht> -itsoffset <Offset(sec)> -i <VideoPaht> -map 0:v -map 1:a <OutputPath.mp4>
# map -0:v : 첫 번째 입력 파일을 video 입력으로 삼음
# map -1:a : 두 번째 입력 파일을 audio 입력으로 삼음

# 오디오를 뒤로 밀기
subprocess.run(
    f"ffmpeg -loglevel {loglevel} -y "
    + f"-i {video_path} "
    + f"-itsoffset {delay_time} "
    + f"-i {video_path} "
    + "-map 0:v -map 1:a "  # -c:v copy -c:a copy "
    + str(save_path),
    shell=True,
)

# 비디오를 뒤로 밀기
subprocess.run(
    f"ffmpeg -loglevel {loglevel} -y "
    + f"-i {video_path} "
    + f"-itsoffset {delay_time} "
    + f"-i {video_path} "
    + "-map 0:a -map 1:v "  # -c:v copy -c:a copy "
    + str(save_path),
    shell=True,
)

ffmpeg: Other Options

• -loglevel: 출력 레벨 설정. /error/이면 출력 안 나옴
  • quiet: 오류 메시지 외 출력 안 함
  • panic, fatal: 치명적 오류만 출력
  • error: 오류 메시지만 출력
• -y: 이미 파일이 있으면 덮어쓰기
• threads: 사용할 쓰레드 수 설정. 별도 지정이 없으면 자동으로 최적화.

Information of Video/Audio

Options:

• -v: error이면 오류 메시지만 출력하게 해 깔끔한 결과를 제공
• -show_entries: 출력할 부분 지정
  • FPS: stream=r_frame_rate
  • Duration: format=duration
  • Codecs: stream=codec_type
• -of: 출력 포맷 지정. json으로 JSON 형태로 출력 가능.

# one query. just single line
ffprobe -v error -show_entries format=duration -of default=nk=1:nw=1 input.mp4

# multiple query. one line, one output
ffprobe -v error -show_entries format=duration,stream=codec_type -of default=noprint_wrappers=1 input.mp4

# If you want to get as scalar value in python pipeline
def get_duration(video_path):
    command = [
        "ffprobe",
        "-v",
        "error",
        "-show_entries",
        "format=duration",
        "-of",
        "json",
        video_path,
    ]
    result = subprocess.run(
        command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
    )
    ffprobe_output = json.loads(result.stdout)
    duration = float(ffprobe_output["format"]["duration"])
    return duration

How to run in python

• subprocess.call(command): 명령어를 수행하고 종료 코드를 반환

  • args command: 리스트/튜플 혹은 문자열로 전달(shell=True일 때만)
  • args shell: True일 경우 명렁어를 셸을 통해 실행하고(command가 문자영리어야 하며, 파이프나 리디렉션 사용 가능), False(default)일 경우 직적 수행함
  • 명령어 수행의 출력을 받으려면 subprocess.run() 사용
  • return이 0이면 성공적으로 수행되었음을 뜻함

    result = subprocess.call(
        [
            "ffmpeg", "-y", "-framerate", "60",
            "-i", "frame_%04d.png",
            "-c:v", "libx264",
            "-pix_fmt", "yuv420p",
            "output.mp4"
        ]
    )

• subprocess.run(command): 명령을 실행하고 완료 시까지 대기

  • args command: 리스트로 전달
  • capture_output: True 시 stdout, stderr를 캡쳐함
  • text: True시 출력을 문자열로 변환함

  run(
        f"ffmpeg -loglevel {loglevel} -y "
        + f"-i {video_path} "
        + f"-itsoffset {delay_time} "
        + f"-i {video_path} "
        + "-map 0:a -map 1:v "
        + str(save_path),
        shell=True
  )

• 만약 터미널에서 잘 작동하는 명령어가 subprocess를 했을 때 잘 작동하지 않는다면? (에러, 일부 기능 작동 안 함)

  • ffmpeg의 프로그램 경로를 ffmpeg 대신 적어주기
  • where ffmpeg → subprocess.call(["/usr/bin/ffmpeg", ...])

Terminal Customize

iTerm2 + oh-my-zsh

• Change bash to zsh: chsh -s /usr/bin/zsh

• https://salmonpack.tistory.com/52

• https://kdohyeon.tistory.com/122

• https://luidy.tistory.com/entry/Terminal-Mac-%ED%84%B0%EB%AF%B8%EB%84%90-%ED%99%98%EA%B2%BD-%EC%84%A4%EC%A0%95%ED%95%98%EA%B8%B0-%EA%BE%B8%EB%AF%B8%EA%B8%B0-iTerm2-oh-my-zsh-tmux

• Key mapping: https://stackoverflow.com/questions/6205157/how-to-set-keyboard-shortcuts-to-jump-to-beginning-end-of-line/29403520#29403520

OS 환경변수

Setting environment variables when you train a deep learning model

• python: os.environ으로 설정 (숫자는 str처리)
• 또는 bash 파일에 export로 설정

OMP_NUM_THREADS
MKL_NUM_THREADS
NUMEXPR_NUM_THREADS

OPENBLAS_NUM_THREADS
VECLIP_MAXIMUM_THREADS

🐧 Linux

Move & Copy Files

• move file: mv <from> <to>
• copy file: cp <from> <to>

Count the number of files/directories

# All types
ls | wc -l

# Files
ls -l | grep ^- | wc -l

# Directories
ls -l | grep ^d | wc -l

Copy file server ↔️ local

• scp

# if you want to copy directory, add `-r` option
scp -P <PORT_NUM> [OPTIONS] <source> <destination>

# example (server -> local) (run in local)
scp -P PORT_NUM USER@ADDRESS:SERVER_FILE LOCAL_PATH

# example (local -> server) (run in local)
scp -P PORT_NUM LOCAL_FILE USER@ADDRESS:SERVER_PATH

• rsync
  • -e 'ssh -p <Port>': 포트 변경
  • -a: 아카이브 모드. 파일 속성, 심볼릭 링크 등 유지
  • -v: 상세 출력
  • -z: 전송 중 데이터 압축
  • -h: 파일 크기를 사람이 읽기 쉬운 형식으로 표시
  • --progress: 전송 진행상황 표시

# 포트 변경
rsync -avz -e 'ssh -p <Port>' <Src> <Dst>

# 폴더 전체의 진행상황 표시
rsync -avz --info=progress2 <Src> <Dst>

Monitor GPU status

• nvidia-smi
  • Keep watching: watch nvidia-smi
• gpustat [OPTIONS]
  • Install: pip install gpustat
  • With -pi option, the command runs iteratively

Symbolic Link

ln -s [SOURCE] [DEST]

# e.g., you can access 'original.txt' with 'linked.txt'
ln -s /home/eungi/original.txt /home/eungi/yeah/linked.txt

# e.g., you can access 'origin_dir' with 'linked_dir'
# Don't need to make 'linked_dir' first, just type the command blow
# Do not add `/` behind the name of directories
ln -s /home/eungi/origin_dir /home/eungi/linked_dir

# e.g., change link
ln -Tfs [SOURCE] [DEST]

Disk usage, File size

# `-h` option: print the sizes in human readable format (e.g., 12M)
df -h [PATH] # Disk usage
du -h [--max-depth=0] [PATH] # Size of file/directory
ls -lh [PATH] # just for file

CPU/Memory status

htop

Process

# kill
kill -9 PID1 PID2 ...

# process list
ps -e
ps -eL | grep <Query>

Find file

• find

   find {where-to-find} -name {name} # e.g., find / -name test*
   find {where-to-find} -name {name} -type {type} # e.g., {type} - `d` for directory, `f` for file

• which: 실행파일/명령어 위치
• whereis: 실행파일, 소스, 매뉴얼 파일 위치 (모든 내용 출력)

zsh + ohmyzsh + tmux

apt-get update
apt install tmux -y

apt install -y zsh
chsh -s `which zsh` # VSCode Terminal - select default profile 도 변경

# ohmyzsh 설치
sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
conda init zsh

# 테마 변경
# https://github.com/ohmyzsh/ohmyzsh/wiki/Themes
vi ~/.zshrc -> 변경(crunch) -> source ~/.zshrc

# 줄 바꿈
vi ~/.oh-my-zsh/themes/{THEME}.zsh-theme
# 아래 내용 추가
NEWLINE=$'\n'
COND='%(?.%F{green}❯%f.%F{red}❯%f) '
# PROMPT 끝에 ${NEWLINE}${COND} 추가

# auto suggestion, highlighting
cd ~/.oh-my-zsh/plugins

git clone https://github.com/zsh-users/zsh-autosuggestions.git
git clone https://github.com/zsh-users/zsh-syntax-highlighting.git

echo "source ${(q-)PWD}/zsh-autosuggestions/zsh-autosuggestions.zsh" >> ${ZDOTDIR:-$HOME}/.zshrc
echo "source ${(q-)PWD}/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh" >> ${ZDOTDIR:-$HOME}/.zshrc
 
vi ~/.zshrc
plugins=(git zsh-autosuggestions zsh-syntax-highlighting)
source ~/.zshrc

🍎 Mac

유용한 초기 설정

1. Install programs
   • Snipaste: capture, pin images
   • Keka: zip
   • CopyClip: Clipboard
   • Rectangle: window control
   • MS Edge or Chrome
   • Notion or Obsidian
2. Trackpad
   • Drag with three figures
3. Settings
   1. Settings > Function Keys > enable 'Use F1, F2, ...'
   2. 'Finder' app > View > 'Show Path Bar', 'Show Status Bar'
   3. 'Finder' app > Tool bar right click > Customize... > insert/delete icons

iTerm2 + zsh + ohmyzsh

• Install

  # Install homebrew
  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
  echo 'export PATH=/opt/homebrew/bin:$PATH' >> ~/.zshrc
  source ~/.zshrc
  
  # Install iTerm2
  brew install iterm2
  
  # Install ohmyzsh
  sh -c "$(curl -fsSL https://raw.github.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

• Theme: vi ~/.zshrc -> Find ZSH_THEME and change to what you want (e.g., agnoster)
• Color
  1. Browse colors here -> https://iterm2colorschemes.com/
  2. Download the code of the picked color: curl -L0 [URL_OF_COLOR]
  3. iTerm2 > Settings > Profiles > Colors > Color presets > Import > select the downloaded file
• Font: iTerm2 > Settings > Profiles > Font (e.g., 'D2Coding')
• Other custom terminal settings

   ### Newline
   vi ~/.oh-my-zsh/themes/[YOUR_THEME].zsh-theme # or zshrc?
   # Find `build_prompt()` function, insert line below between `prompt_hg` and `prompt_end`
   prompt_newline
   # Insert function below
   prompt_newline() {
     if [[ -n $CURRENT_BG ]]; then
   	echo -n "%{%k%F{$CURRENT_BG}%}$SEGMENT_SEPARATOR
   %{%k%F{blue}%}$SEGMENT_SEPARATOR"
     else
   	echo -n "%{%k%}"
     fi
   
     echo -n "%{%f%}"
     CURRENT_BG=''
   }
   source ~/.zshrc
  
   ### Delete computer name: insert codes below
   vi ~/.zshrc
   prompt_context() {
     if [[ "$USER" != "$DEFAULT_USER" || -n "$SSH_CLIENT" ]]; then
   	prompt_segment black default "%(!.%{%F{yellow}%}.)$USER"
     fi
   }
   source ~/.zshrc
  
   ### Syntax highlighting (commands for M series users)
   brew install zsh-syntax-highlighting
   source /opt/homebrew/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh
   
   ### Auto suggestion
   brew install zsh-autosuggestions
   source /opt/homebrew/share/zsh-autosuggestions/zsh-autosuggestions.zsh

• Tmux install: brew install tmux

Python & virtual env. in Mac

• VSCode에서 파이썬 경로
• pip 경로

🪟 Windows

파일명 대소문자 구분 활성화하기

윈도우에서는 파일명이 대소문자를 구분하지 않음(abc.txt나 ABC.txt나 같다고 취급). 이를 변경하는 방법.

1. 빈 폴더 만들기
2. 명령 프롬프트를 관리자 권한으로 열기
3. fsutil file setCaseSensitiveInfo enable
   1. "대/소문자 구분 특성을 사용할 수 있습니다."라고 출력되면 설정 완료
   2. 비활성화하려면 disable로 인자 주기
4. 어떻게 설정되어 있나 알고 싶다면 queryCaseSensitiveInfo

터미널 꾸미기: oh my posh

1️⃣ 윈도우 보안설정 변경 - 참고 링크

• 파워쉘 관리자 권한으로 열기
• Set-ExecutionPolicy RemoteSigned 입력

2️⃣ oh my posh 설치

• 파워쉘 관리자 권한으로 열기
• 설치: winget install oh-my-posh
• 일반 권한으로 다시 열기
• oh-my-posh get shell: 실행 시 pwsh이 나오면 됨

3️⃣ Theme 선택 - 테마 목록

• New-Item -Path $PROFILE -Type File -Force: 설정 파일 메모장 열기 전, 에러 방지
• notepad $PROFILE: 설정 파일이 메모장 열림 (빈 파일)
• 아래 내용 입력 후 저장

oh-my-posh init pwsh --config 'https://raw.githubusercontent.com/JanDeDobbeleer/oh-my-posh/main/themes/<테마_json_파일>' | Invoke-Expression

4️⃣ 글꼴 선택 - 폰드 목록

• 파워쉘 관리자 권한으로 열기
• oh-my-posh font install: 다운로드 가능한 글꼴 목록 보임. 원하는 것 다운로드.
• 파워쉘 일반 열기 - 설정 - 일반 - 모양 - 글꼴 변경

5️⃣ VSCode 적용

• settings.json 열기
• "terminal.integrated.fontFamily": "CaskaydiaCove Nerd Font" : 폰트 설정

6️⃣ 플러그인 등 설정

• 터미널에서 notepad $PROFILE으로 설정 파일 열기 후 아래 내용 입력

oh-my-posh init pwsh --config "https://raw.githubusercontent.com/JanDeDobbeleer/oh-my-posh/main/themes/atomic.omp.json" | Invoke-Expression

Import-Module PSReadLine
Set-PSReadLineOption -PredictionSource History
Set-PSReadLineOption -PredictionViewStyle ListView

Set-PSReadLineOption -HistorySearchCursorMovesToEnd
Set-PSReadLineKeyHandler -Key UpArrow -Function HistorySearchBackward
Set-PSReadLineKeyHandler -Key DownArrow -Function HistorySearchForward

Import-Module posh-git

7️⃣ Git bash 적용 - 참고 링크

• 테마 json 파일 로컬에 저장
  • .bashrc 파일에 아래 내용 입력 후 저장, 적용

eval "$(oh-my-posh --init --shell bash --config ~/atomic.omp.json)"

8️⃣ 추가 참고 링크

• https://inspire12.tistory.com/344

Blender

• Blender에서 파이썬 사용하기