개미는 오늘도 열심히 일을하네

wsl 자동 실행 & 백그라운드 실행

욱근욱 — Wed, 26 Nov 2025 14:45:30 +0900

1. cmd 에서 wsl 동작 확인

STATE : Stopped

wsl -l -v

2. cmd 에서 명령어 실행 확인

win + r 을 누르고 다음을 입력

powershell -Command "start-process wsl.exe"

3. cmd 에서 다시 wsl 동작 확인

STATE : Running

wsl -l -v

4. 작업 스케줄러 등록

win + r 을 누르고 taskschd.msc 입력
일반
- 이름 : wsl_start
- 사용자 또는 그룹 변경
  - 고급 > 지금 찾기 > Administrators 선택 ( """ s """ ) > 확인
- 보안 옵션
  - 사용자가 로그온할 때만 실행
  - 가장 높은 수준의 권한으로 실행
- 트리거
  - 작업 시작 : 시작할 때
  - 고급 설정
    - 작업 지연 시간 : 30초
- 동작
  - 동작 : 프로그램 시작
  - 설정
    - 프로그램/스크립트 : powershell
    - 인수 추가 : -Command "start-process wsl.exe -WindowStyle Hidden"
- 설정
  - 다음 시간 이상 작업이 실행되면 중지 : 해제
  - 요청할 때 실행중인 작업이 끝나지 않으면 강제로 작업 중지 : 해제
  - 작업이 이미 실행 중이면 다음 규칙 적용 : 새 인스턴스 실행 안함

5. 백그라운드로 실행된 wsl 종료

Powershell에서 다음을 입력하여 ProcessName이 wsl인 Id 숫자 확인

Get-Process | Where-Object { $_.Name -like '*wsl*' }

Stop 수행

Stop-Process -ID 5122

선택적 기능 (WMIC, .NET Framework 3.5)

욱근욱 — Mon, 24 Nov 2025 15:16:12 +0900

Dism /Online /Add-Capability /CapabilityName:WMIC~~~~ /Source:E:\LanguagesAndOptionalFeatures

ISO File

https://www.microsoft.com/en-us/evalcenter/evaluate-windows-server-2025

Windows Server 2025 | Microsoft Evaluation Center

Windows Server 2025 delivers next-generation security improvements, and hybrid cloud capabilities into a modernized and future ready platform.

www.microsoft.com

LINK > Download this ISO > Unzip

WMIC

1. Powershell 관리자 권환으로 열기

2. 선택적 기능 설치

Dism /Online /Add-Capability /CapabilityName:WMIC~~~~ /Source:E:\LanguagesAndOptionalFeatures

3. WMIC 설치

Get-WindowsCapability -Online | Where-Object Name -like "*wmic*"

3.1. State : Installed 확인

.Net Framework 3.5

1. .Net Framework 3.5 설치

Dism /Online /Enable-Feature /FeatureName:NetFx3 /All /LimitAccess /Source:E:\LanguagesAndOptionalFeatures

Pyinstaller cupy 관련 ModuleNotFound 에러

욱근욱 — Thu, 20 Nov 2025 14:25:48 +0900

[filename].spec에 다음을 추가

import sys
import cupy

...

    hiddenimports=[
    ...
    ] + [x for x in sys.modules.keys() if x.startswith('cupy.') or x.startswith('cupyx.') or x.startswith('cupy_backends.')] + ['fastrlock', 'fastrlock.rlock'],
    
...

Python EXE Decompile

욱근욱 — Wed, 1 Oct 2025 13:21:46 +0900

0. 준비물

[필수] Microsoft C++ Build Tools

Python 3.10+ 버전을 지원하는 최신 디컴파일러(pycdc)는 C++로 작성되어 있습니다. 따라서 소스 코드를 직접 컴파일하여 실행 파일을 만들어야 합니다. 아래 링크에서 'Visual Studio Build Tools'를 다운로드하고, 설치 시 'C++를 사용한 데스크톱 개발' 워크로드를 체크하여 설치합니다.

Microsoft C++ Build Tools - Visual Studio

visualstudio.microsoft.com

[선택] HxD

가끔 .exe에서 추출한 .pyc 파일의 헤더(파일 정보가 담긴 앞부분)가 손상되는 경우가 있습니다. 이럴 때 파일의 내용을 16진수 값으로 직접 보고 수정하기 위해 헥스 에디터가 필요할 수 있습니다. 필수는 아니지만, 문제가 발생했을 때 해결할 수 있는 요소입니다.

HxD - Freeware Hex Editor and Disk Editor | mh-nexus

HxD - Freeware Hex Editor and Disk Editor HxD is a carefully designed and fast hex editor which, additionally to raw disk editing and modifying of main memory (RAM), handles files of any size. The easy to use interface offers features such as searching and

mh-nexus.de

1. .exe $\rightarrow$ .pyc

첫 번째 단계는 .exe 실행 파일이라는 압축 패키지에서 파이썬 바이트코드 파일(.pyc)들을 꺼내는 것입니다. 이 작업에는 pyinstxtractor 스크립트가 가장 효과적입니다.

1. pyinstxtractor 다운로드

GitHub - extremecoders-re/pyinstxtractor: PyInstaller Extractor

PyInstaller Extractor. Contribute to extremecoders-re/pyinstxtractor development by creating an account on GitHub.

github.com

2. 스크립트 실행

디컴파일하려는 .exe 파일과 다운로드한 pyinstxtractor.py를 같은 폴더에 위치시킵니다. 그리고 해당 폴더에서 터미널(CMD 또는 PowerShell)을 열어 아래 명령어를 실행하세요.

python pyinstxtractor.py <filename>

3. 결과 확인

명령이 성공적으로 실행되면 <filename>.exe_extracted라는 이름의 폴더가 생성됩니다. 이 폴더 안에 들어가 보면 프로그램 실행에 필요했던 각종 라이브러리 파일과 함께 찾던 .pyc 파일들이 들어있는 것을 확인할 수 있습니다. 보통 메인 스크립트는 원본 파일명과 같거나 main.pyc라는 이름을 가집니다.

2. .pyc $\rightarrow$ .py

추출한 바이트코드(.pyc)를 사람이 읽을 수 있는 파이썬 소스 코드(.py)로 변환합니다.

1. pycdc 다운로드

GitHub - zrax/pycdc: C++ python bytecode disassembler and decompiler

C++ python bytecode disassembler and decompiler. Contribute to zrax/pycdc development by creating an account on GitHub.

github.com

2. x86_x64 Cross Tools Command Prompt for VS 2022 실행

시작 메뉴에서 ** x86_x64 Cross Tools Command Prompt for VS 2022 **를 찾아 실행합니다. 일반 CMD가 아닌 이 개발자용 명령 프롬프트를 사용해야 C++ 컴파일러(cl.exe)가 정상적으로 동작합니다. (MS Build Tools을 설치하면 사용할 수 있습니다.)

3. 컴파일 진행

개발자 명령 프롬프트에서 pycdc 소스 코드를 다운로드한 폴더로 이동한 뒤, 아래 명령어를 차례대로 입력합니다. cmake는 프로젝트 빌드 설정을 생성하고, MSBuild는 해당 설정을 바탕으로 실제 컴파일을 수행합니다.

cmake .
MSBuild pycdc.sln

4. pycdc 실행

컴파일을 완료하였으면, Debug 폴더에 pycdc.exe 파일이 생성된 것을 확인할 수 있습니다. 이 컴파일된 pycdc.exe를 이용해 .pyc 파일을 디컴파일합니다. 터미널에서 아래 형식의 명령어를 사용합니다.

pycdc.exe <변환할_pyc_파일> > <저장할_py_파일명>

참고

가끔 pyinstxtractor가 .pyc 파일의 헤더를 제대로 복원하지 못해 pycdc가 오류를 일으킬 수 있습니다. 이럴 때 헥스 에디터(HxD)를 사용합니다.

HxD로 문제가 되는 .pyc 파일을 엽니다.
파일의 가장 앞부분이 파이썬 버전에 맞는 **매직 넘버(Magic Number)**로 시작하는지 확인합니다.
- Python 3.10의 매직 넘버: 61 0D 0D 0A
파이썬 .pyc 파일은 보통 16바이트의 헤더를 가집니다. pyinstxtractor는 이 헤더 없이 바이트코드만 추출하는 경우가 있는데, 이 경우 다른 정상적인 .pyc 파일(같은 파이썬 버전으로 만든)의 헤더 16바이트를 복사하여 붙여넣으면 문제가 해결될 수 있습니다.

[Dockerfile] From ubuntu, Python with Node.js

욱근욱 — Wed, 16 Jul 2025 16:59:50 +0900

shell은 zsh 사용

FROM ubuntu:latest

RUN apt-get update && apt-get install -y \
    git gcc build-essential curl zsh \
    zlib1g-dev libffi-dev libssl-dev liblzma-dev \
    libbz2-dev libreadline-dev libsqlite3-dev

SHELL ["/usr/bin/zsh", "-c"]

WORKDIR /home/user
ENV SHELL=/usr/bin/zsh

# nvm 설치
RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash && \
    export NVM_DIR="$HOME/.nvm" && \
    [ -s "$NVM_DIR/nvm.sh" ] && source "$NVM_DIR/nvm.sh" && \
    nvm install 22

RUN echo 'export NVM_DIR="$HOME/.nvm"' >> ~/.zshrc && \
    echo '[ -s "$NVM_DIR/nvm.sh" ] && source "$NVM_DIR/nvm.sh"' >> ~/.zshrc

# pyenv 설치
RUN curl -fsSL https://pyenv.run | bash && \
    export PYENV_ROOT="$HOME/.pyenv" && \
    export PATH="$PYENV_ROOT/bin:$PATH" && \
    eval "$(pyenv init -)" && \
    pyenv install 3.10 && \
    pyenv global 3.10

RUN echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.zshrc && \
    echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.zshrc && \
    echo 'eval "$(pyenv init -)"' >> ~/.zshrc

ENV PYENV_ROOT="/home/user/.pyenv"
ENV PATH="$PYENV_ROOT/bin:$PATH"

CMD ["/usr/bin/zsh"]

# docker run -it -d --name dev --ipc host --gpus all --hostname dev dev

[React] 8 vulnerabilities (2 moderate, 6 high)

욱근욱 — Mon, 31 Mar 2025 10:32:51 +0900

문제

npm install 시 다음과 같은 문구 출력

패키지 설치시 라이브러리 충돌로 인한 것으로 판단.

검색하였을 때 react-scripts 라이브러리에서 발생.

8 vulnerabilities (2 moderate, 6 high)

To address all issues (including breaking changes), run:
npm audit fix --force

Run `npm audit` for details.

Npx create-react-app: 8 vulnerabilities (2 moderate, 6 high) · Issue #13607 · facebook/create-react-app

Describe the bug When I create a new npx create-react-app application and install any dependencies I receive the message: 8 vulnerabilities (2 moderate, 6 high) Did you try recovering your dependen...

github.com

해결 방법

package.json에 다음을 추가

  "overrides": {
    "react-scripts": {
    "@svgr/webpack": "8.1.0",
    "typescript": "4.9.5",
    "postcss": "8.4.38"
    }
  }

[React] WSL에 Dockerfile로 React 환경 구축

욱근욱 — Tue, 25 Mar 2025 17:48:53 +0900

React 프로젝트 생성

npx create-react-app frontend

Dockerfile로 Image Build

FROM node:18-alpine

# 유저 설정
USER root

# 작업 디렉토리를 /usr/src/app으로 설정
WORKDIR /usr/src/app/frontend

# 호스트의 package.json, package-lock.json 파일을 작업 디렉토리에 복사
COPY package*.json .

# 필요 패키지 설치
RUN npm install

# 컨테이너 외부로 노출할 포트 설정 (React dev server 기본값: 3000)
EXPOSE 3000

# 컨테이너 실행 시 npm start 명령 수행
CMD ["npm", "start"]

docker build -t react-image .

Container 생성

docker run -dit --name [CONTAINER NAME] -p [HOST PORT]:[CONTAINER PORT] -v [HOST DIR]:[PROJECT DIR] [IMAGE NAME]
docker run -dit --name web_server -p 3000:3000 -v ${PWD}:/usr/src/app/frontend react-image

[DiPE-Linear] Disentangled Interpretable Representation for Efficient Long-term Time Series Forecasting

욱근욱 — Mon, 24 Mar 2025 15:40:39 +0900

[Paper] [Github]

이 논문은 장기 시계열 예측(Long-term Time Series Forecasting, LTSF)을 위한 효율적이고 해석 가능한 DiPE-Linear(Disentangled interpretable-Parameter-Efficient Linear network)를 제안합니다.

Introduction

딥러닝 모델들은 높은 정확도를 제공하지만, 블랙박스(Black Box) 특성으로 인해 사용자 신뢰를 떨어뜨립니다.

또한, 기존의 시계열 예측 방법(또는 기법)들은 다음과 같은 한계점을 가지고 있습니다.

RNN : 병렬화가 어렵습니다.
CNN : 높은 계산 비용을 요구합니다.
Transformer : 여러 개선에도 불구하고 많은 수의 파라미터를 가지, 긴 입력 시퀀스에 쉽게 과적합됩니다.
FC(Fully Connected) : 이차 복잡도(Quadratic Complexity)로 인한 파라미터 중복 ? 복제 ?(Parameter Redundancy) 문제가 있습니다.

※ 이차 복잡도 (Quadratic Complexity) [참고]

입력 데이터 크기를 $L$이라고 할 때, 계산량이나 메모리 사용량이 $L^2$에 비례하여 증가하는 현상.

※ 파라미터 중복 (Parameter Redundancy) [GPT 답변]

모델이 필요 이상으로 많은 파라미터를 가지면서 실제로 유의미하지 않거나 중복된 정보를 학습하는 현상.

$\rightarrow$ LTSF의 경우, 긴 시퀀스을 예측해야 하기 때문에 입력 데이터 긴 시퀀스를 필요로 함. FC는 모든 입력마다 모든 출력으로 연결을 유지하므로 파라미터 수가 제곱에 비례함. 따라서, 과도하게 많은 파라미터가 존재하고 이는 비용 증가, 과적합 문제 등이 발생과 동시에 많은 파라미터들 중 중복된 파라미터들로 인해 모델 성능 향상에 기여하지 않으면서 계산 비용만 증가시키고, 최적점을 찾아가는데 방해됨.

DiPE-Linear

DiPE-Linear 모델은 다음 세 가지 모듈로 구성됩니다.

1. Static Frequential Attention (SFA)

실수 푸리에 변환(Real Fast Fourier Transform, rFFT)을 통해 시간 도메인 데이터를 주파수 도메인 데이터로 변환 후 이 영역에서 학습된 필터 중 중요한 신호만 선택적으로 증폭하거나 억제.
역 실수 푸리에 변환(inverse rFFT)을 사용하여 필터링된 데이터를 다시 시간 영역으로 변환
필터는 시계열의 시간적 구조를 보존하고, 이어지는 시간적 특징 추출에 영향을 주지 않기 위해 zero-phase filter로 제한
주파수 분석을 통해 잡음(noise)을 줄이고 유의미한 정보를 더 강조

※ zero-phase filter

신호의 진폭(amplitude)만을 수정하며 원본의 위상(phase) 정보는 유지

$x$는 입력 단변량 시계열(univariate series), $F$는 rFFT를, $\theta_{SFA}$는 학습 가능한 정적 주파수 어텐션 맵, $\odot$는 원소 단위 곱셈(element-wise multiplication)를 의미합니다.

2. Static Temporal Attention (STA)

시간 영역에서 중요한 시점만을 선별하여 중요한 시점에 높은 가중치를 부여하는 모듈
최근 데이터가 더 중요하다는 사실 등 시간적 중요도를 반영해 학습 효율성을 높임
입력 시계열에 대해 학습된 시간 어텐션 맵(temporal attention map)과 입력 데이터($Z_{SFA}$의 원소 단위 곱셈(element-wise multiplication)을 수행하여 관련된 과거 시간 포인트에 적절한 중요도를 할당하여 시간적 의존성을 잘 반영

$\theta_{STA}$는 학습 가능한 시간 영역 어텐션 맵을 의미합니다.

3. Idependent Frequential Mapping (IFM)

FITS에 사용된 2차원 스펙트럼 행렬은 대각선만 중요한 가중치를 가지며, 이는 시계열의 서로 다른 주파수 간의 독립성이 상대적으로 강하다는 것을 시사합니다. 이러한 배경에서 각 주파수를 독립적으로 처리하기 위한 IFM 모듈을 제안합니다.
구체적으로 입력 시계열(STA와 SFA를 통해 처리된)이 주파수 영역으로 변환된 후, 독립적 주파수 매핑을 사용하여 각 주파수 성분을 직접 대응되는 출력 주파수 성분으로 매핑합니다.
독립적인 주파수별 가중치를 사용하여 효율적인 예측 수행 후, 최종 출력을 시간 영역으로 다시 변환(inverse rFFT)

정리

SFA는 주파수 영역에서 중요한 신호를 선택적으로 강조하여 노이즈를 감소
STA는 시간 영역에서 중요한 입력 시점의 가중치를 높어 시간적 의존성을 효과적으로 학습
SFA와 STA는 FC의 파라미터 중복(Parameter Redundancy) 문제를 해결하는 과정중 하나
IFM는 각 주파수를 독립적으로 매핑하여 효율성과 해석 가능성을 동시에 높임

Low-Rank Weight Sharing

설명한 SFA, STA, IFM는 단변량(Uni Variate)를 초점으로 설계한 모듈이고, 다변량(Multi Variate)를 위해서 Low-Rank Weight Sharing을 모듈을 제안합니다.

해당 모듈은 다변량 시계열에서 각 변수 간의 상관성을 효율적으로 모델링하기 위해 사용되며, 변수들을 의미 있게 클러스터링하여 파라미터를 공유하고, 모델 복잡성을 크게 줄입니다.

구체적으로, 가중치 행렬을 저랭크(Low-Rank) 행렬로 표현하여 변수 간의 공통적인 정보(shared patterns)과 변수 고유의 특성(individual-specific patterns)을 동시에 모델링하여, 모델의 파라미터 수를 현저히 줄입니다.

SFALoss

기존의 LTSF 모델들은 시간 영역에서만 손실 함수를 정의하고 사용합니다. 시간 영역 손실만으로는 주파수 영역에서의 중요한 신호 패턴을 충분히 반영하지 못할 수 있습니다. 이러한 문제를 해결하기 위해 본 논문은 시간 영역 손실과 주파수 영역 손실을 동시에 고려하는 새로운 손실 함수인 SFALoss를 제안합니다.

$L_{T}$는 시간 영역에서의 표준 손실 함수(ex. MSE)를 의미하며, $L_{F}$는 SFA모듈에서 학습된 주파수 어텐션 맵($\theta_{SFA}$)을 사용하여 학습된 가중치의 주파수 영역의 손실입니다. 이 손실 $L$은 중요한 주파수 성분에 더 많은 가중치를 부여하여 주파수 영역을 더욱 집중적으로 학습하도록 유도합니다.

Results

FCs (완전 연결 모델들)과의 비교

FCs가 아닌 모델들과의 비교

다양한 데이터셋들과의 비교

Code

[Github]

num_experts

모델의 가중치를 몇 개의 전문가(experts)로 나누어 관리할지 결정하는 변수

각 전문가는 시계열 데이터를 서로 다른 방식(독립적)으로 처리하며, 전체적인 예측은 이 전문가들의 조합으로 도출

rank_experts

각 전문가(experts)들의 상대적 중요도를 결정하는 변수

이 값들로 전문가들의 출력을 가중 평균하여 최종 결과를 도출

STA(Static Temporal Attention)

학습 가능한 시간 어텐션 맵(self.weight)을 통해 각 시간 포인트의 중요도를 반영

$\rightarrow$ 입력 데이터에 원소 단위 곱(element-wise multiplication)을 수행하여 중요 시점에 높은 가중치를 부여

class StaticTimeWeight(nn.Module):

    def __init__(self, input_len, num_experts):
        super().__init__()
        self.input_len = input_len
        self.num_experts = num_experts
        self.weight = nn.Parameter(
            torch.ones(1, self.num_experts, 1, self.input_len))

    def forward(self, x, rank_experts=None):
        # x: N, 1, c, input_len
        # if rank_experts provided, output is N, 1, c, input_len//2+1
        # if not, output is N, num_experts, c, input_len//2+1

        if rank_experts is not None:
            weight = self.weight * rank_experts  # 1, num_experts, c, input_len//2+1
            weight = weight.sum(dim=1, keepdim=True)  # 1, 1, c, input_len//2+1
        else:
            weight = self.weight
        x = x * weight
        return x

SFW(Static Frequential Attention)

입력 데이터를 주파수 영역으로 변환하여 주파수 어텐션 맵(self.weight)를 적용

$\rightarrow$ 중요한 주파수를 학습하여 선택적으로 강조하거나 불필요한 주파수를 억제하여 노이즈를 줄임

이후, 다시 시간 영역으로 역변환하여 주파수 어텐션이 반영된 데이터 출력

class StaticFreqWeight(nn.Module):
    # we do not use window function since it is a linear operation

    def __init__(self, input_len, num_experts):
        super().__init__()
        self.input_len = input_len
        self.num_experts = num_experts
        self.weight = nn.Parameter(
            torch.ones(1, self.num_experts, 1, self.input_len // 2 + 1))

    def get_weight_channel(self, rank_experts):

        if rank_experts is not None:
            weight = self.weight * rank_experts  # 1, num_experts, c, input_len//2+1
            weight = weight.sum(dim=1, keepdim=True)  # 1, 1, c, input_len//2+1
        else:
            weight = self.weight
        return weight

    def forward(self, x, rank_experts=None, windowing=False):
        # x: N, 1, c, input_len
        # if rank_experts provided, output is N, 1, c, input_len//2+1
        # if not, output is N, num_experts, c, input_len//2+1

        weight = self.get_weight_channel(rank_experts)

        # x = F.pad(x, [self.input_len // 2, self.input_len // 2])
        if windowing:
            window = torch.hamming_window(self.input_len,
                                          dtype=x.dtype,
                                          device=x.device)
            x = x * window
        x = torch.fft.rfft(x)
        x = x * weight
        x = torch.fft.irfft(x, n=self.input_len)
        if windowing:
            x = x / window
        # x = x[:, :, :, self.input_len // 2:-self.input_len // 2]

        return x

IFM(Independent Frequential Mapping)

입력 데이터( 주파수 어텐션이 반영된 시간 데이터 )를 패딩하여 주파수 영역으로 변환

주파수 영역에서 각 주파수 성분을 독립적으로 처리

class FFTExpandBigConv1d(nn.Module):
    # 专为小输入大卷积核设计
    # 输入：N, 1, l_in
    # 输出：N, num_experts, l_out
    def __init__(
        self,
        num_experts: int,
        input_len: int,
        output_len: int,
    ):
        super().__init__()
        self.num_experts = num_experts
        self.input_len = input_len
        self.output_len = output_len

        # we pad x 1% of length on each end... for bizzare reasons..
        self.pad_len = math.floor((self.input_len + self.output_len - 1) / 100)
        self.pad_len = max(self.pad_len, 1)

        self.time_len = self.input_len + self.output_len - 1 + 2 * self.pad_len
        self.freq_len = self.time_len // 2 + 1

        # Initialized as Average filter
        self.weight = nn.Parameter(
            torch.zeros((1, self.num_experts, 1, self.freq_len),
                        dtype=torch.cfloat))
        self.weight.data[..., 0] = 1
        self.bias = nn.Parameter(
            torch.zeros(1,
                        self.num_experts,
                        1,
                        self.freq_len,
                        dtype=torch.cfloat))

    def forward(self, x: torch.Tensor, rank_experts=None):
        if rank_experts is not None:
            weight = self.weight * rank_experts  # 1, num_experts, input_len//2+1
            weight = weight.sum(dim=1, keepdim=True)  # 1, 1, input_len//2+1

            bias = self.bias * rank_experts
            bias = bias.sum(dim=1, keepdim=True)
        else:
            weight = self.weight
            bias = self.bias

        # input: N, 1, l_in
        # depth-wise convolution
        # pad x to match kernel

        x = F.pad(x, [self.pad_len, self.output_len - 1 + self.pad_len])

        # calculate FFT
        x = torch.fft.rfft(x)
        # weight = torch.fft.rfft(weight)

        # frequency production
        x = x * weight

        # bias
        x = x + bias

        # invert FFT
        x = torch.fft.irfft(x, n=self.time_len)

        x = x[..., -self.output_len - self.pad_len:-self.pad_len]

        # output: N, experts, l_out if rank is None else N, 1, l_out
        return x

Identity

특정 기능(모듈)을 비활성화하여 입력 데이터를 그대로 출

class Identity(nn.Module):

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__()

    def forward(self, x: Tensor, *args: Any, **kwargs: Any) -> Tensor:
        return x

DiPE

시간 모듈 (self.time_w) : STA 모듈

주파수 모듈 (self.freq_w) : SFA 모듈

주파수 매핑 모듈 (self.expert) : IFM 모듈

low-rank weight sharing (self.route) : 전체 가중치를 독립적으로 구성하는 것이 아니라, 소수의 전문가(num_experts)를 정의하여, 각 변수(features)가 이 전문가의 가중치를 공유함

Reversible Instance Normalization (RevIN) 방식의 전처리를 통해 입력 데이터를 정규화하고 예측 값을 다시 원래 척도로 변환

class DiPE(nn.Module):

    def __init__(
        self,
        input_len: int,
        output_len: int,
        input_features: int,
        output_features: int,
        individual_f: bool = False,
        individual_t: bool = False,
        individual_c: bool = False,
        num_experts: int = 1,
        use_revin: bool = True,
        use_time_w: bool = True,
        use_freq_w: bool = True,
        loss_alpha: float = 0.,
        t_loss: Literal['mse', 'mae'] = 'mse',
    ):
        super().__init__()
        self.input_len = input_len
        self.output_len = output_len
        self.num_features = input_features
        self.individual_f = individual_f
        self.individual_t = individual_t
        self.individual_c = individual_c
        self.num_experts = num_experts
        assert input_features == output_features

        self.use_revin = use_revin
        self.use_time_w = use_time_w
        self.use_freq_w = use_freq_w
        self.loss_alpha = loss_alpha
        self.t_loss = t_loss

        self.example_input_array = torch.Tensor(32, input_len, input_features)

        if self.num_experts > 1:
            self.route = nn.Parameter(
                torch.randn(1, num_experts, self.num_features, 1))
            self.temperature = 114514
            self.temperature = float('nan')
            self.router_softmax = nn.Softmax(dim=1)
        # self.static_route = torch.eye(self.num_experts).unsqueeze(0).unsqueeze(-1)
        self.static_route = torch.eye(
            self.num_features).unsqueeze(0).unsqueeze(-1)

        if self.use_time_w:
            if self.individual_t:
                self.time_w = StaticTimeWeight(self.input_len,
                                               self.num_features)
            else:
                self.time_w = StaticTimeWeight(self.input_len, self.num_experts)
        else:
            self.time_w = Identity()

        if self.use_freq_w:
            if self.individual_f:
                self.freq_w = StaticFreqWeight(self.input_len,
                                               self.num_features)
            else:
                self.freq_w = StaticFreqWeight(self.input_len, self.num_experts)
        else:
            self.freq_w = Identity()

        if self.individual_c:
            self.expert = FFTExpandBigConv1d(self.num_features, self.input_len,
                                             self.output_len)
        else:
            self.expert = FFTExpandBigConv1d(self.num_experts, self.input_len,
                                             self.output_len)

        self.dropout = nn.Dropout(0.1)

    def forward(self, x):
        batch_size = x.shape[0]

        x = rearrange(x, 'n l c -> n 1 c l')

        if self.use_revin:

            x_mean = x.mean(dim=-1, keepdim=True).detach()
            x_std = x.std(dim=-1, keepdim=True).detach().clamp(min=1e-7)
            x = (x - x_mean) / x_std

        if self.num_experts > 1:

            rank_experts = self.router_softmax(self.route /
                                               self.temperature)  # 1, h, c, 1

        else:
            rank_experts = None

        if self.individual_f:
            x = self.freq_w(x, self.static_route.to(x.device))
        else:
            x = self.freq_w(x, rank_experts)
        x = self.dropout(x)

        if self.individual_t:
            x = self.time_w(x, self.static_route.to(x.device))
        else:
            x = self.time_w(x, rank_experts)

        if self.individual_c:
            x = self.expert(x, self.static_route.to(x.device))
        else:
            x = self.expert(x, rank_experts)

        if self.use_revin:
            x = x * x_std
            x = x + x_mean

        x = rearrange(x, 'n 1 c l -> n l c')

        return x
        
        ...

SFALoss

논문에서 제안된 SFALoss

시간 영역 손실(time_loss) : MSE 또는 MAE를 사용

주파수 영역 손실(freq_loss) : 주파수 영역에서 SFA 모듈의 주파수 어텐션 가중치를 이용하여 중요한 주파수 손실 강조

두 손실의 가중 합으로 최종 손실을 계산하며, 이로 인해 주파수 성분을 더 집중적으로 학습

class DiPE(nn.Module):

    ...
    
    def loss(self, y, y_hat):
        y = rearrange(y, 'n l c -> n c l')
        y_hat = rearrange(y_hat, 'n l c -> n c l')

        if self.t_loss == 'mse':
            time_loss = F.mse_loss(y, y_hat)
        else:
            time_loss = F.l1_loss(y, y_hat)

        if self.use_freq_w:

            if self.num_experts > 1:
                rank_experts = self.router_softmax(
                    self.route / self.temperature)  # 1, h, c, 1
            else:
                rank_experts = None

            if self.individual_f:
                rank_experts = self.static_route.to(y.device)

            freq_w = self.freq_w.get_weight_channel(rank_experts)
            freq_w = freq_w.detach()
            freq_w = freq_w / freq_w.mean(dim=-1, keepdim=True)

            if freq_w.shape[-1] != y.shape[-1] // 2 + 1:
                with torch.no_grad():
                    freq_w = torch.fft.irfft(freq_w, n=y.shape[-1])
                    freq_w = torch.fft.rfft(freq_w)

        else:
            freq_w = 1

        fft_y = torch.fft.rfft(y, norm='ortho')
        fft_y_hat = torch.fft.rfft(y_hat, norm='ortho')

        freq_loss = F.l1_loss(fft_y * freq_w, fft_y_hat * freq_w)

        return (1 - self.loss_alpha) * time_loss + self.loss_alpha * freq_loss

[LTSF-Linear] / [DLinear, NLinear] Are Transformers Effective for Time Series Forecasting ?

욱근욱 — Mon, 24 Mar 2025 13:11:30 +0900

[paper] [paper2] [Github]

Transformer 기반 시계열 예측 모델의 문제점

https://arxiv.org/pdf/2205.13504

LTSF(Long-term Time Series Forecasting) 분야에서 Transformer 구조를 적용한 모델이 큰 주목을 받으면서 해당 논문 저자들은 다음과 같은 가설들로 "Transformer는 정말 시계열 예측 문제에서 효과적일까?" 하는 근본적인 의문을 가졌습니다. 그리고 여러 실험을 통해 Transformer 기반 모델들의 성능이 다소 과장되었다고 판단했습니다.

1. 순서 정보의 상실

LTSF에서 시간의 순서 정보는 예측에 있어 매우 중요합니다. Transformer는 이 순서 정보를 보존하기 위해 포지셔널 인코딩(Position Encoding) 같은 기법이 있지만, Self-Attention과정에서 순서 불변(permutation-invariant) 특성으로 인해 결국 순서 정보 손실은 불가피합니다. NLP의 경우, 문장 순서가 달라져도 문장의 의미는 대부분 유지 되기 때문에 크게 문제가 되지 않지만, TSF에서는 큰 영향을 미칩니다.

2. 복잡한 모델 구조

Transformer 기반 모델(Informer, Autoformer, FEDformer 등)은 복잡한 구조로 인해 계산량과 메모리 사용량이 많고, 종종 과적합 문제에 직면합니다.

3. 장기 예측 한계

기존 Transformer 기반 시계열 모델들이 실제로는 시계열의 근본적 특징(추세, 주기성)을 제대로 학습하지 못하고, 오히려 잡음(노이즈)에 과적합되어 있습니다. 실제로 Look-back window sizes를 증가시켜도 loss가 감소하지 않는 현상을 관찰할 수 있습니다.

LTSF-Linear

https://arxiv.org/pdf/2205.13504v2

시계열 예측 방법은 다단계(Multi-Step) 예측을 위해 단일 단계 예측기를 학습하고 반복적으로 적용하는 IMS(Iterated Multi-Step) 방법과, 한 번에 다단계 예측을 수행하는 DMS(Diret Multi-Step) 예측 방법이 있습니다.

LSTF-Linear는 가장 간단한 DMS 모델로, 기본적인 구조는 간단한 one-layer linear 구조를 사용하여 시계열에 대한 회귀를 수행 후 미래를 예측합니다.

LSTF-Linear는 시계열을 처리하기 위해 Decomposition, Normalization 전처리 방법을 도입한 DLinear, Nlinear 모델을 제안합니다.

DLinear [Code]

데이터에서 추세(Trend)와 계절성(Seasonality)를 분해(Decomposition)하여 각각 간단한 선형 모델로 예측한 후 합하는 방법. Autoformer와 FEDformer에서 사용된 방법.

[블로그]에서 DLinear 과정을 잘 설명해두었다.

NLinear [Code]

데이터의 마지막 값을 기준으로 간단한 정규화(Normalization)를 진행한 후 예측하는 방법.

실험 결과

https://arxiv.org/pdf/2205.13504

복잡한 Transformer 기반 모델보다 LTSF-Linear가 다양한 데이터셋에서 대부분 좋은 성능을 보였습니다.

주목할 점으로, Transfomer 기반 모델들은 입력 구간(look back window) 또는 예측 구간이 길어질수록 성능이 급격히 나빠지거나 불안정해지지만, LTSF-Linear 모델은 비교적 안정적인 성능을 유지합니다.

[Python] win32api Error - ImportError: DLL load failed while importing win32api: 지정된 모듈을 찾을 수 없습니다.

욱근욱 — Tue, 11 Mar 2025 16:23:55 +0900

https://github.com/mhammond/pywin32/issues/1431

ImportError: DLL load failed while importing win32event: The specified module could not be found. · Issue #1431 · mhammond/pyw

I just installed Python 3.8.0 32-bit, then installed a few modules including pywin32 using pip. When I try "import win32event", I get the following error: Python 3.8.0 (tags/v3.8.0:fa919fd, Oct 14 ...

github.com

1. 이전 버전 설치

pip install pywin32==225

2. postinstall 설치

pywin32를 설치하였다면, [python (가상)환경]\Scripts\pywin32_postinstall.py 파일이 생성되어 있다.

python Scripts\pywin32_postinstall.py -install

pywin32_postinstall.py

# postinstall script for pywin32
#
# copies PyWinTypesxx.dll and PythonCOMxx.dll into the system directory,
# and creates a pth file
import os
import sys
import glob
import shutil
import time
import distutils.sysconfig
try:
    import winreg as winreg
except:
    import winreg

# Send output somewhere so it can be found if necessary...
import tempfile
tee_f = open(os.path.join(tempfile.gettempdir(), 'pywin32_postinstall.log'), "w")
class Tee:
    def __init__(self, file):
        self.f = file
    def write(self, what):
        if self.f is not None:
            try:
                self.f.write(what.replace("\n", "\r\n"))
            except IOError:
                pass
        tee_f.write(what)
    def flush(self):
        if self.f is not None:
            try:
                self.f.flush()
            except IOError:
                pass
        tee_f.flush()

# For some unknown reason, when running under bdist_wininst we will start up
# with sys.stdout as None but stderr is hooked up. This work-around allows
# bdist_wininst to see the output we write and display it at the end of
# the install.
if sys.stdout is None:
    sys.stdout = sys.stderr

sys.stderr = Tee(sys.stderr)
sys.stdout = Tee(sys.stdout)

com_modules = [
    # module_name,                      class_names
    ("win32com.servers.interp",         "Interpreter"),
    ("win32com.servers.dictionary",     "DictionaryPolicy"),
    ("win32com.axscript.client.pyscript","PyScript"),
]

# Is this a 'silent' install - ie, avoid all dialogs.
# Different than 'verbose'
silent = 0

# Verbosity of output messages.
verbose = 1

ver_string = "%d.%d" % (sys.version_info[0], sys.version_info[1])
root_key_name = "Software\\Python\\PythonCore\\" + ver_string

try:
    # When this script is run from inside the bdist_wininst installer,
    # file_created() and directory_created() are additional builtin
    # functions which write lines to Python23\pywin32-install.log. This is
    # a list of actions for the uninstaller, the format is inspired by what
    # the Wise installer also creates.
    file_created
    is_bdist_wininst = True
except NameError:
    is_bdist_wininst = False # we know what it is not - but not what it is :)
    def file_created(file):
        pass
    def directory_created(directory):
        pass
    def get_root_hkey():
        try:
            winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
                           root_key_name, 0, winreg.KEY_CREATE_SUB_KEY)
            return winreg.HKEY_LOCAL_MACHINE
        except OSError as details:
            # Either not exist, or no permissions to create subkey means
            # must be HKCU
            return winreg.HKEY_CURRENT_USER

try:
    create_shortcut
except NameError:
    # Create a function with the same signature as create_shortcut provided
    # by bdist_wininst
    def create_shortcut(path, description, filename,
                        arguments="", workdir="", iconpath="", iconindex=0):
        import pythoncom
        from win32com.shell import shell, shellcon

        ilink = pythoncom.CoCreateInstance(shell.CLSID_ShellLink, None,
                                           pythoncom.CLSCTX_INPROC_SERVER,
                                           shell.IID_IShellLink)
        ilink.SetPath(path)
        ilink.SetDescription(description)
        if arguments:
            ilink.SetArguments(arguments)
        if workdir:
            ilink.SetWorkingDirectory(workdir)
        if iconpath or iconindex:
            ilink.SetIconLocation(iconpath, iconindex)
        # now save it.
        ipf = ilink.QueryInterface(pythoncom.IID_IPersistFile)
        ipf.Save(filename, 0)

    # Support the same list of "path names" as bdist_wininst.
    def get_special_folder_path(path_name):
        import pythoncom
        from win32com.shell import shell, shellcon

        for maybe in """
            CSIDL_COMMON_STARTMENU CSIDL_STARTMENU CSIDL_COMMON_APPDATA
            CSIDL_LOCAL_APPDATA CSIDL_APPDATA CSIDL_COMMON_DESKTOPDIRECTORY
            CSIDL_DESKTOPDIRECTORY CSIDL_COMMON_STARTUP CSIDL_STARTUP
            CSIDL_COMMON_PROGRAMS CSIDL_PROGRAMS CSIDL_PROGRAM_FILES_COMMON
            CSIDL_PROGRAM_FILES CSIDL_FONTS""".split():
            if maybe == path_name:
                csidl = getattr(shellcon, maybe)
                return shell.SHGetSpecialFolderPath(0, csidl, False)
        raise ValueError("%s is an unknown path ID" % (path_name,))

def CopyTo(desc, src, dest):
    import win32api, win32con
    while 1:
        try:
            win32api.CopyFile(src, dest, 0)
            return
        except win32api.error as details:
            if details.winerror==5: # access denied - user not admin.
                raise
            if silent:
                # Running silent mode - just re-raise the error.
                raise
            tb = None
            full_desc = "Error %s\n\n" \
                        "If you have any Python applications running, " \
                        "please close them now\nand select 'Retry'\n\n%s" \
                        % (desc, details.strerror)
            rc = win32api.MessageBox(0,
                                     full_desc,
                                     "Installation Error",
                                     win32con.MB_ABORTRETRYIGNORE)
            if rc == win32con.IDABORT:
                raise
            elif rc == win32con.IDIGNORE:
                return
            # else retry - around we go again.

# We need to import win32api to determine the Windows system directory,
# so we can copy our system files there - but importing win32api will
# load the pywintypes.dll already in the system directory preventing us
# from updating them!
# So, we pull the same trick pywintypes.py does, but it loads from
# our pywintypes_system32 directory.
def LoadSystemModule(lib_dir, modname):
    # See if this is a debug build.
    import imp
    for suffix_item in imp.get_suffixes():
        if suffix_item[0]=='_d.pyd':
            suffix = '_d'
            break
    else:
        suffix = ""
    filename = "%s%d%d%s.dll" % \
               (modname, sys.version_info[0], sys.version_info[1], suffix)
    filename = os.path.join(lib_dir, "pywin32_system32", filename)
    mod = imp.load_dynamic(modname, filename)


def SetPyKeyVal(key_name, value_name, value):
    root_hkey = get_root_hkey()
    root_key = winreg.OpenKey(root_hkey, root_key_name)
    try:
        my_key = winreg.CreateKey(root_key, key_name)
        try:
            winreg.SetValueEx(my_key, value_name, 0, winreg.REG_SZ, value)
        finally:
            my_key.Close()
    finally:
        root_key.Close()
    if verbose:
        print(("-> %s\\%s[%s]=%r" % (root_key_name, key_name, value_name, value)))

def RegisterCOMObjects(register = 1):
    import win32com.server.register
    if register:
        func = win32com.server.register.RegisterClasses
    else:
        func = win32com.server.register.UnregisterClasses
    flags = {}
    if not verbose:
        flags['quiet']=1
    for module, klass_name in com_modules:
        __import__(module)
        mod = sys.modules[module]
        flags["finalize_register"] = getattr(mod, "DllRegisterServer", None)
        flags["finalize_unregister"] = getattr(mod, "DllUnregisterServer", None)
        klass = getattr(mod, klass_name)
        func(klass, **flags)

def RegisterPythonwin(register=True):
    """ Add (or remove) Pythonwin to context menu for python scripts.
        ??? Should probably also add Edit command for pys files also.
        Also need to remove these keys on uninstall, but there's no function
            like file_created to add registry entries to uninstall log ???
    """
    import os

    lib_dir = distutils.sysconfig.get_python_lib(plat_specific=1)
    classes_root=get_root_hkey()
    ## Installer executable doesn't seem to pass anything to postinstall script indicating if it's a debug build,
    pythonwin_exe = os.path.join(lib_dir, "Pythonwin", "Pythonwin.exe")
    pythonwin_edit_command=pythonwin_exe + ' /edit "%1"'

    keys_vals = [
        ('Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\Pythonwin.exe', '', pythonwin_exe),
        ('Software\\Classes\\Python.File\\shell\\Edit with Pythonwin', 'command', pythonwin_edit_command),
        ('Software\\Classes\\Python.NoConFile\\shell\\Edit with Pythonwin', 'command', pythonwin_edit_command),
        ]

    try:
        if register:
            for key, sub_key, val in keys_vals:
                ## Since winreg only uses the character Api functions, this can fail if Python
                ##  is installed to a path containing non-ascii characters
                hkey = winreg.CreateKey(classes_root, key)
                if sub_key:
                    hkey = winreg.CreateKey(hkey, sub_key)
                winreg.SetValueEx(hkey, None, 0, winreg.REG_SZ, val)
                hkey.Close()
        else:
            for key, sub_key, val in keys_vals:
                try:
                    winreg.DeleteKey(classes_root, key)
                except OSError as why:
                    winerror = getattr(why, 'winerror', why.errno)
                    if winerror != 2: # file not found
                        raise
    finally:
        # tell windows about the change
        from win32com.shell import shell, shellcon
        shell.SHChangeNotify(shellcon.SHCNE_ASSOCCHANGED, shellcon.SHCNF_IDLIST, None, None)

def get_shortcuts_folder():
    if get_root_hkey()==winreg.HKEY_LOCAL_MACHINE:
        try:
            fldr = get_special_folder_path("CSIDL_COMMON_PROGRAMS")
        except OSError:
            # No CSIDL_COMMON_PROGRAMS on this platform
            fldr = get_special_folder_path("CSIDL_PROGRAMS")
    else:
        # non-admin install - always goes in this user's start menu.
        fldr = get_special_folder_path("CSIDL_PROGRAMS")

    try:
        install_group = winreg.QueryValue(get_root_hkey(),
                                           root_key_name + "\\InstallPath\\InstallGroup")
    except OSError:
        vi = sys.version_info
        install_group = "Python %d.%d" % (vi[0], vi[1])
    return os.path.join(fldr, install_group)

# Get the system directory, which may be the Wow64 directory if we are a 32bit
# python on a 64bit OS.
def get_system_dir():
    import win32api # we assume this exists.
    try:
        import pythoncom
        import win32process
        from win32com.shell import shell, shellcon
        try:
            if win32process.IsWow64Process():
                return shell.SHGetSpecialFolderPath(0,shellcon.CSIDL_SYSTEMX86)
            return shell.SHGetSpecialFolderPath(0,shellcon.CSIDL_SYSTEM)
        except (pythoncom.com_error, win32process.error):
            return win32api.GetSystemDirectory()
    except ImportError:
        return win32api.GetSystemDirectory()

def fixup_dbi():
    # We used to have a dbi.pyd with our .pyd files, but now have a .py file.
    # If the user didn't uninstall, they will find the .pyd which will cause
    # problems - so handle that.
    import win32api, win32con
    pyd_name = os.path.join(os.path.dirname(win32api.__file__), "dbi.pyd")
    pyd_d_name = os.path.join(os.path.dirname(win32api.__file__), "dbi_d.pyd")
    py_name = os.path.join(os.path.dirname(win32con.__file__), "dbi.py")
    for this_pyd in (pyd_name, pyd_d_name):
        this_dest = this_pyd + ".old"
        if os.path.isfile(this_pyd) and os.path.isfile(py_name):
            try:
                if os.path.isfile(this_dest):
                    print(("Old dbi '%s' already exists - deleting '%s'" % (this_dest, this_pyd)))
                    os.remove(this_pyd)
                else:
                    os.rename(this_pyd, this_dest)
                    print(("renamed '%s'->'%s.old'" % (this_pyd, this_pyd)))
                    file_created(this_pyd+".old")
            except os.error as exc:
                print(("FAILED to rename '%s': %s" % (this_pyd, exc)))

def install(lib_dir):
    import traceback
    # The .pth file is now installed as a regular file.
    # Create the .pth file in the site-packages dir, and use only relative paths
    # We used to write a .pth directly to sys.prefix - clobber it.
    if os.path.isfile(os.path.join(sys.prefix, "pywin32.pth")):
        os.unlink(os.path.join(sys.prefix, "pywin32.pth"))
    # The .pth may be new and therefore not loaded in this session.
    # Setup the paths just in case.
    for name in "win32 win32\\lib Pythonwin".split():
        sys.path.append(os.path.join(lib_dir, name))
    # It is possible people with old versions installed with still have
    # pywintypes and pythoncom registered.  We no longer need this, and stale
    # entries hurt us.
    for name in "pythoncom pywintypes".split():
        keyname = "Software\\Python\\PythonCore\\" + sys.winver + "\\Modules\\" + name
        for root in winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER:
            try:
                winreg.DeleteKey(root, keyname + "\\Debug")
            except WindowsError:
                pass
            try:
                winreg.DeleteKey(root, keyname)
            except WindowsError:
                pass
    LoadSystemModule(lib_dir, "pywintypes")
    LoadSystemModule(lib_dir, "pythoncom")
    import win32api
    # and now we can get the system directory:
    files = glob.glob(os.path.join(lib_dir, "pywin32_system32\\*.*"))
    if not files:
        raise RuntimeError("No system files to copy!!")
    # Try the system32 directory first - if that fails due to "access denied",
    # it implies a non-admin user, and we use sys.prefix
    for dest_dir in [get_system_dir(), sys.prefix]:
        # and copy some files over there
        worked = 0
        try:
            for fname in files:
                base = os.path.basename(fname)
                dst = os.path.join(dest_dir, base)
                CopyTo("installing %s" % base, fname, dst)
                if verbose:
                    print(("Copied %s to %s" % (base, dst)))
                # Register the files with the uninstaller
                file_created(dst)
                worked = 1
                # If this isn't sys.prefix (ie, System32), then nuke
                # any versions that may exist in sys.prefix - having
                # duplicates causes major headaches.
                if dest_dir != sys.prefix:
                    bad_fname = os.path.join(sys.prefix, base)
                    if os.path.exists(bad_fname):
                        # let exceptions go here - delete must succeed
                        os.unlink(bad_fname)
            if worked:
                break
        except win32api.error as details:
            if details.winerror==5:
                # access denied - user not admin - try sys.prefix dir,
                # but first check that a version doesn't already exist
                # in that place - otherwise that one will still get used!
                if os.path.exists(dst):
                    msg = "The file '%s' exists, but can not be replaced " \
                          "due to insufficient permissions.  You must " \
                          "reinstall this software as an Administrator" \
                          % dst
                    print(msg)
                    raise RuntimeError(msg)
                continue
            raise
    else:
        raise RuntimeError(
              "You don't have enough permissions to install the system files")

    # Pythonwin 'compiles' config files - record them for uninstall.
    pywin_dir = os.path.join(lib_dir, "Pythonwin", "pywin")
    for fname in glob.glob(os.path.join(pywin_dir, "*.cfg")):
        file_created(fname[:-1] + "c") # .cfg->.cfc

    # Register our demo COM objects.
    try:
        try:
            RegisterCOMObjects()
        except win32api.error as details:
            if details.winerror!=5: # ERROR_ACCESS_DENIED
                raise
            print("You do not have the permissions to install COM objects.")
            print("The sample COM objects were not registered.")
    except:
        print("FAILED to register the Python COM objects")
        traceback.print_exc()

    # There may be no main Python key in HKCU if, eg, an admin installed
    # python itself.
    winreg.CreateKey(get_root_hkey(), root_key_name)

    # Register the .chm help file.
    chm_file = os.path.join(lib_dir, "PyWin32.chm")
    if os.path.isfile(chm_file):
        # This isn't recursive, so if 'Help' doesn't exist, we croak
        SetPyKeyVal("Help", None, None)
        SetPyKeyVal("Help\\Pythonwin Reference", None, chm_file)
    else:
        print("NOTE: PyWin32.chm can not be located, so has not " \
              "been registered")

    # misc other fixups.
    fixup_dbi()

    # Register Pythonwin in context menu
    try:
        RegisterPythonwin()
    except:
        print('Failed to register pythonwin as editor')
        traceback.print_exc()
    else:
        if verbose:
            print('Pythonwin has been registered in context menu')

    # Create the win32com\gen_py directory.
    make_dir = os.path.join(lib_dir, "win32com", "gen_py")
    if not os.path.isdir(make_dir):
        if verbose:
            print(("Creating directory", make_dir))
        directory_created(make_dir)
        os.mkdir(make_dir)

    try:
        # create shortcuts
        # CSIDL_COMMON_PROGRAMS only available works on NT/2000/XP, and
        # will fail there if the user has no admin rights.
        fldr = get_shortcuts_folder()
        # If the group doesn't exist, then we don't make shortcuts - its
        # possible that this isn't a "normal" install.
        if os.path.isdir(fldr):
            dst = os.path.join(fldr, "PythonWin.lnk")
            create_shortcut(os.path.join(lib_dir, "Pythonwin\\Pythonwin.exe"),
                            "The Pythonwin IDE", dst, "", sys.prefix)
            file_created(dst)
            if verbose:
                print("Shortcut for Pythonwin created")
            # And the docs.
            dst = os.path.join(fldr, "Python for Windows Documentation.lnk")
            doc = "Documentation for the PyWin32 extensions"
            create_shortcut(chm_file, doc, dst)
            file_created(dst)
            if verbose:
                print("Shortcut to documentation created")
        else:
            if verbose:
                print(("Can't install shortcuts - %r is not a folder" % (fldr,)))
    except Exception as details:
        print(details)

    # importing win32com.client ensures the gen_py dir created - not strictly
    # necessary to do now, but this makes the installation "complete"
    try:
        import win32com.client
    except ImportError:
        # Don't let this error sound fatal
        pass
    print("The pywin32 extensions were successfully installed.")

def uninstall(lib_dir):
    # First ensure our system modules are loaded from pywin32_system, so
    # we can remove the ones we copied...
    LoadSystemModule(lib_dir, "pywintypes")
    LoadSystemModule(lib_dir, "pythoncom")

    try:
        RegisterCOMObjects(False)
    except Exception as why:
        print(("Failed to unregister COM objects:", why))

    try:
        RegisterPythonwin(False)
    except Exception as why:
        print(("Failed to unregister Pythonwin:", why))
    else:
        if verbose:
            print('Unregistered Pythonwin')

    try:
        # remove gen_py directory.
        gen_dir = os.path.join(lib_dir, "win32com", "gen_py")
        if os.path.isdir(gen_dir):
            shutil.rmtree(gen_dir)
            if verbose:
                print(("Removed directory", gen_dir))

        # Remove pythonwin compiled "config" files.
        pywin_dir = os.path.join(lib_dir, "Pythonwin", "pywin")
        for fname in glob.glob(os.path.join(pywin_dir, "*.cfc")):
            os.remove(fname)

        # The dbi.pyd.old files we may have created.
        try:
            os.remove(os.path.join(lib_dir, "win32", "dbi.pyd.old"))
        except os.error:
            pass
        try:
            os.remove(os.path.join(lib_dir, "win32", "dbi_d.pyd.old"))
        except os.error:
            pass

    except Exception as why:
        print(("Failed to remove misc files:", why))

    try:
        fldr = get_shortcuts_folder()
        for link in ("PythonWin.lnk", "Python for Windows Documentation.lnk"):
            fqlink = os.path.join(fldr, link)
            if os.path.isfile(fqlink):
                os.remove(fqlink)
                if verbose:
                    print(("Removed", link))
    except Exception as why:
        print(("Failed to remove shortcuts:", why))
    # Now remove the system32 files.
    files = glob.glob(os.path.join(lib_dir, "pywin32_system32\\*.*"))
    # Try the system32 directory first - if that fails due to "access denied",
    # it implies a non-admin user, and we use sys.prefix
    try:
        for dest_dir in [get_system_dir(), sys.prefix]:
            # and copy some files over there
            worked = 0
            for fname in files:
                base = os.path.basename(fname)
                dst = os.path.join(dest_dir, base)
                if os.path.isfile(dst):
                    try:
                        os.remove(dst)
                        worked = 1
                        if verbose:
                            print(("Removed file %s" % (dst)))
                    except Exception:
                        print(("FAILED to remove", dst))
            if worked:
                break
    except Exception as why:
        print(("FAILED to remove system files:", why))

# NOTE: If this script is run from inside the bdist_wininst created
# binary installer or uninstaller, the command line args are either
# '-install' or '-remove'.

# Important: From inside the binary installer this script MUST NOT
# call sys.exit() or raise SystemExit, otherwise not only this script
# but also the installer will terminate! (Is there a way to prevent
# this from the bdist_wininst C code?)


def verify_destination(location):
    if not os.path.isdir(location):
        raise argparse.ArgumentTypeError("Path \"{}\" does not exist!".format(location))
    return location


if __name__ == '__main__':
    import argparse

    parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter,
                                     description="""A post-install script for the pywin32 extensions.

    * Typical usage:

    > python pywin32_postinstall.py -install

    If you installed pywin32 via a .exe installer, this should be run
    automatically after installation, but if it fails you can run it again.

    If you installed pywin32 via PIP, you almost certainly need to run this to
    setup the environment correctly.

    Execute with script with a '-install' parameter, to ensure the environment
    is setup correctly.
    """)
    parser.add_argument("-install",
                        default=False,
                        action='store_true',
                        help="Configure the Python environment correctly for pywin32.")
    parser.add_argument("-remove",
                        default=False,
                        action='store_true',
                        help="Try and remove everything that was installed or copied.")
    parser.add_argument("-wait",
                        type=int,
                        help="Wait for the specified process to terminate before starting.")
    parser.add_argument("-silent",
                        default=False,
                        action='store_true',
                        help="Don't display the \"Abort/Retry/Ignore\" dialog for files in use.")
    parser.add_argument("-quiet",
                        default=False,
                        action='store_true',
                        help="Don't display progress messages.")
    parser.add_argument("-destination",
                        default=distutils.sysconfig.get_python_lib(plat_specific=1),
                        type=verify_destination,
                        help="Location of the PyWin32 installation")

    args = parser.parse_args()

    if not args.quiet:
        print(("Parsed arguments are: {}".format(args)))

    if not args.install ^ args.remove:
        parser.error("You need to either choose to -install or -remove!")

    if args.wait is not None:
        try:
            os.waitpid(args.wait, 0)
        except AttributeError:
            # Python 2.2 - no waitpid - just sleep.
            time.sleep(3)
        except os.error:
            # child already dead
            pass

    silent = args.silent
    verbose = not args.quiet

    if args.install:
        install(args.destination)

    if args.remove:
        if not is_bdist_wininst:
            uninstall(args.destination)

[Python] VSCode Error - Sorry, something went wrong activating IntelliCode support for Python. Please check the "Python" and "VS IntelliCode" output windows for details.

욱근욱 — Tue, 11 Mar 2025 14:51:43 +0900

Sorry, something went wrong activating IntelliCode support for Python · Issue #50 · microsoft/pylance-release

Getting the following error after installing pylance Sorry, something went wrong activating IntelliCode support for Python. Please check the "Python" and "VS IntelliCode" output windows for details...

github.com

VSCode의 Python Extention의 버전을 과거 버전(v2024.2.0)으로 변경으로 해결하였다.

[Ubuntu] E: Unable to locate package

욱근욱 — Fri, 7 Mar 2025 09:34:14 +0900

1. apt update

sudo apt-get update

2. 패키지 명 확인

3. 없는 패키지

4. ubuntu 버전 확인

[Docker] Container Network 연결

욱근욱 — Wed, 5 Mar 2025 11:47:13 +0900

https://captcha.tistory.com/70

현재 네트워크 목록

docker netwokr ls

네트워크 상세 정보

docker network inspect bridge

네트워크 생성

docker network create --driver bridge mynetwork

네트워크 연결

docker run -it --network mynetwork [IMAGE:TAG]

docker network connect mynetwork [CONTAINER]
docker attach [CONTAINER]

네트워크 연결 끊기

docker network disconnect mynetwork [CONTAINER]
docker attach [CONTAINER]

네트워크 연결 확인

docker inspect [NETWORK NAME]

docker inspect [CONTAINER] -f "{{json .NetworkSettings.Networks }}"

[PostgreSQL] ON CONFLICT ERROR (there is no unique or ~)

욱근욱 — Wed, 26 Feb 2025 16:51:49 +0900

상황

ON CONFLICT ~ DO UPDATE ~ 수행 시 다음과 같은 에러 출력

there is no unique or exclusion constraint matching the ON CONFLICT specification

원인

Primary Key, Unique Key가 정의 되어 있지 않아 발생

해결

Unique Key 추가

ALTER TABLE [MY_TABLE]
ADD CONSTRAINT unique_datetime_tag_name UNIQUE (datetime, tag_name);

[Python] 기상청 API Hub의 날씨 & 날씨 예보 데이터 수집 with. airflow

욱근욱 — Fri, 21 Feb 2025 14:03:38 +0900

KimGeunUk/airflow-weather: Weather & Weather Forecast Data Pipeline With Apache Airflow

GitHub - KimGeunUk/airflow-weather: Weather & Weather Forecast Data Pipeline With Apache Airflow

Weather & Weather Forecast Data Pipeline With Apache Airflow - KimGeunUk/airflow-weather

github.com

오탈자, 에러, 수정 제안이 있으시다면 댓글 부탁드립니다.

[Python] Airflow Dag 정보 (Task Context) 전달

욱근욱 — Thu, 13 Feb 2025 10:50:08 +0900

...

from train_model.main import run

local_tz = pendulum.timezone("Asia/Seoul")

...

dag = DAG(
    dag_id='train_model_dag',
    default_args=default_args,
    schedule_interval='30 9 * * *',  # 매일 09:30 실행
    catchup=False
)

process_task = PythonOperator(
    task_id='train_model',
    python_callable=run,
    dag=dag
)

위와 같이 간단한 dag을 구성 후 train_model의 run 함수에서 airflow에서 작업을 수행한 시간인 execution_date를 가져오고 싶었다.

간단하게 run함수에서 **kwargs를 받으면 쉽게 얻을 수 있다.

# train_model.py
def run(**kwargs):
	execution_date = kwargs['execution_date']
    
    # 이외에도 다양한 정보를 kwargs에서 꺼낼 수 있음
    # run_id = kwargs['run_id']
    # dag_run = kwargs['dag_run']
    # etc...
    
    ...

주의할 점으로 execution_date는 datetime이며 UTC를 기준으로 하고, time zone 정보가 포함되어 있다.

따라서 KST를 위해 9시간을 더하고 time zone 정보를 제거하고 사용하는 것이 좋다.

import datetime

...

execution_date_utc = kwargs['execution_date']
execution_date_ktc = run_time_utc + datetime.timedelta(hours=9)
execution_date = execution_date_ktc.replace(tzinfo=None)

...

[Docker] PostgreSQL 설치

욱근욱 — Fri, 7 Feb 2025 16:59:15 +0900

도커 실행

docker pull postgres:latest

docker run --name postgres -p [PORT]:5432 -e POSTGRES_USER=[USER] -e POSTGRES_PASSWORD=[PASSWORD] -d postgres

내부 접속

docker exec -it postgres /bin/bash

Database 목록 확인

접속

psql -U postgres

명령어

\l

외부 접속

# //[PostgreSQL ID]:[PostgreSQL PWD]@[HOST IP]:[PORT]/[DB NAME]
export DB_URL = 'postgresql://postgres:1@127.0.0.1:5432/postgres

[Git] 삭제된 폴더, 파일 반영

욱근욱 — Mon, 3 Feb 2025 14:56:27 +0900

git add 시 로컬에서 삭제한 폴더나 파일이 반영되지 않는 경우가 있다.

이를 해결하기 위해 다음 명령어를 사용한다.

git add -u [file or .]

추가로, commit 시 -a 옵션을 사용하면 삭제된 폴더, 파일만 반영된다.

git commit -a -m "feat: ..."

[Python] Windows에 pyenv 설치

욱근욱 — Thu, 2 Jan 2025 13:10:28 +0900

프로젝트마다 사용하는 python 버전이 달라질 수 있으므로, pyenv를 사용하기로 결정

1. 설치

https://github.com/pyenv-win/pyenv-win

GitHub - pyenv-win/pyenv-win: pyenv for Windows. pyenv is a simple python version management tool. It lets you easily switch bet

pyenv for Windows. pyenv is a simple python version management tool. It lets you easily switch between multiple versions of Python. It's simple, unobtrusive, and follows the UNIX tradition of s...

github.com

Window Powershell의 관리자 모드로 실행을 권장

1. Install pyenv-win in PowerShell.

Invoke-WebRequest -UseBasicParsing -Uri "https://raw.githubusercontent.com/pyenv-win/pyenv-win/master/pyenv-win/install-pyenv-win.ps1" -OutFile "./install-pyenv-win.ps1"; &"./install-pyenv-win.ps1"

이 시스템에서 스크림트를 실행할 수 없으므로 ~ 에러를 출력한다면 다음을 입력 후 다시 시도

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope LocalMachine

2. Reopen PowerShell

3. Run pyenv --version to check if the installation was successful.

설치된 pyenv 버전 확인

pyenv --version

4. Run pyenv install -l to check a list of Python versions supported by pyenv-win

설치 가능한 python 버전 확인

pyenv install -l

5. Run pyenv install <version> to install the supported version

3.10 버전 파이썬 설치

uninstall를 사용하여 해당 버전을 삭제할 수도 있다

pyenv install 3.10

6. Run pyenv global <version> to set a Python version as the global version

global / local / shell 옵션으로 python 적용 범위를 설정 가능

pyenv global 3.10

7. Check which Python version you are using and its path

사용 중인 python version 확인

pyenv version

8. Check that Python is working

사용 중인 python의 위치 확인

python -c "import sys; print(sys.executable)"

2. 가상환경 생성

python -m venv .venv

간단한 Airflow v2.10.5 환경 구축 (with. dockerfile)

욱근욱 — Tue, 31 Dec 2024 10:01:47 +0900

WSL2 Ubuntu

apt 업데이트

sudo apt update

sudo apt install sudo

프로젝트 폴더 권한 부여

sudo chown -R [사용자 계정명] [프로젝트 디렉토리]

파이썬 설치

sudo apt install python3

가상환경 생성 (프로젝트 디렉토리에서)

sudo apt install python3-venv

python3 -m venv venv

source venv/bin/activate

airflow 라이브러리 설치

pip install apache-airflow==2.10.5

airflow 세팅 및 실행 (프로젝트 디렉토리에서)

export AIRFLOW_HOME=$PWD/airflow
airflow db init
sed -i 's/^load_examples = True/load_examples = False/' $AIRFLOW_HOME/airflow.cfg # 예제 로드 X
airflow users create -u user -f user -l user -e user@example.com -p user -r Admin # 계정 생성
airflow webserver -p 8080 & airflow scheduler # 실행

AIRFLOW root 디렉토리를 현재 위치한 프로젝트 디렉토리로 설정하고,

airflow에서 제공하는 예제 DAGs를 띄우지 않게 설정합니다.

Dockerfile (Airflow 2.10.5)

2025-09-16 : flask-limiter 버전 충돌 수정

FROM python:3.9-slim

USER root

RUN apt-get update && \
    apt-get install -y --no-install-recommends vim sudo && \
    rm -rf /var/lib/apt/lists/*

RUN sudo ln -snf /usr/share/zoneinfo/Asia/Seoul /etc/localtime

ENV AIRFLOW_HOME=/root/airflow
RUN mkdir -p $AIRFLOW_HOME
WORKDIR $AIRFLOW_HOME

RUN pip install apache-airflow==2.10.5 flask-limiter==3.10.0

RUN airflow db init && \
    sed -i 's/^load_examples = True/load_examples = False/' $AIRFLOW_HOME/airflow.cfg && \
    airflow users create \
        --username user \
        --firstname user \
        --lastname user \
        --email user@example.com \
        --password user \
        --role Admin

EXPOSE 8080

CMD ["/bin/bash", "-c", "airflow webserver -p 8080 & airflow scheduler"]

docker build -t airflow .
docker run -d -p 8080:8080 \
  -v /home/user/projects/airflow/dags:/root/airflow/dags \
  -v /home/user/projects/airflow/logs:/root/airflow/logs \
  -v /home/user/projects/airflow/plugins:/root/airflow/plugins \
  --name airflow \
  airflow

[Tistory] hELLO. 스킨 카테고리 접기 펼치기 수정

욱근욱 — Fri, 27 Dec 2024 16:24:39 +0900

카테고리 목록에서 서브 카테고리가 있는 경우, 클릭 시 페이지 이동 없이 펼쳐볼 수 있도록 스킨을 수정했습니다.

스킨 편집에서 HTML > body 아래에 다음 코드를 추가합니다.

    <!-- 카테고리 목록 펼치기/접기 -->
    <script>
      $(function() {
        $(".category_list").children("li").each(function() {
          const $li = $(this);
          if ($li.children("ul").length > 0) {
            $li.children("a")
              .removeAttr("href")
              .addClass("duration-200")
              .attr("x-on:click", "open = ! open")
              .attr(":class", "{ &quot;rotate-90 duration-200&quot;: open }");
          }
        });
      });
    </script>

docker-compose로 Airflow 환경 구축

욱근욱 — Fri, 27 Dec 2024 11:26:59 +0900

여기에서 최신 설치 방법을 확인할 수 있습니다.

Python

1. python 설치 (v3.12)

sudo apt update && sudo apt install python3-pip

2. airflow library 설치

pip3 install apache-airflow

Airflow

1. .yaml 파일 가져오기

curl -LfO 'https://airflow.apache.org/docs/apache-airflow/2.10.4/docker-compose.yaml'

2. directory 생성 및 그룹 id 설정

mkdir -p -m 755 ./dags ./logs ./plugins ./config
echo -e "AIRFLOW_UID=$(id -u)" > .env

3. 초기 세팅

AIRFLOW_UID=50000

4. 공통 환경 설정 (postgres, redis 설치 포함)

docker compose up airflow-init

airflow-init-1 exited with code 0 를 출력하면 정상적으로 설치 및 설정되었다는 뜻입니다.

5. 실행

docker compose up -d

6. 확인

docker ps -a

위 명령어를 통해 container가 정상적으로 설치되었는지 확인합니다.

localhost:8080 을 통해 airflow에 접근할 수 있습니다. 기본 id/password는 airflow 입니다.

여기까지가 간단한 실습이고, CPU를 많이 사용하기 때문에 container를 종료 및 제거합니다.

docker-compose down --volumes --rmi all

커스텀

예제 DAG LOAD X

AIRFLOW__CORE__LOAD_EXAMPLES: 'false'

webserver ID/PWD (admin/admin)

    environment:
      ...
      _AIRFLOW_WWW_USER_USERNAME: ${_AIRFLOW_WWW_USER_USERNAME:-admin}
      _AIRFLOW_WWW_USER_PASSWORD: ${_AIRFLOW_WWW_USER_PASSWORD:-admin}
      ...

[Docker] WSL2에 Docker 설치

욱근욱 — Fri, 27 Dec 2024 10:43:09 +0900

1. apt update & upgrade

sudo apt update -y
sudo apt upgrade -y

2. docker에 필요한 패키지 설치

sudo apt install -y apt-transport-https ca-certificates curl software-properties-common

3. docker GPG key 추가

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

4. docker apt 저장소 추가

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

5. apt update

sudo apt-get update

6. docker 설치

sudo apt install -y docker-ce docker-ce-cli containerd.io

7. [WSL 사용 시] sudo 없이 docker를 사용하기 위해 계정 권한 추가

sudo groupadd docker
sudo usermod -aG docker $USER
sudo chmod 666 /var/run/docker.sock
newgrp docker

8. docker 실행

sudo service docker start

[Error] / [Pyinstaller] xgboost XGBoostLibraryNotFound error

욱근욱 — Fri, 29 Nov 2024 11:13:22 +0900

문제 상황

xgboost를 import한 .py 파일을 pyinstaller로 .exe 로 패키징 할 때 다음과 같은 에러를 출력

xgboost.libpath.XGBoostLibraryNotFound: Cannot find XGBoost Library in the candidate path, did you install compilers and run build.sh in root path?
List of candidates:
C:\...\AppData\Local\Temp\_MEI103562\xgboost\xgboost.dll
C:\...\AppData\Local\Temp\_MEI103562\xgboost\../../lib/xgboost.dll
C:\...\AppData\Local\Temp\_MEI103562\xgboost\./lib/xgboost.dll
C:\...\AppData\Local\Temp\_MEI103562\xgboost\xgboost.dll
C:\...\AppData\Local\Temp\_MEI103562\xgboost\../../windows/x64/Release/xgboost.dll
C:\...\AppData\Local\Temp\_MEI103562\xgboost\./windows/x64/Release/xgboost.dll

해결 방법

다음 글을 참고

https://github.com/dmlc/xgboost/issues/7761#issuecomment-1104619556

Pyinstaller and xgboost · Issue #7761 · dmlc/xgboost

Dear coders, I am trying to launch pyinstaller for my app but it appear the commun error with xgboost and pyinstaller. I am using xgboost version 1.5.2. The error is : import xgboost as xgb File ""...

github.com

1. 파일 추가

[PYTHON PATH]\Lib/site-package/_pyinstaller_hooks_contrib/stdhooks 폴더에 hook-xgboost.py 파일을 생성

""" hook-xgboost.py """
from PyInstaller.utils.hooks import collect_all
datas, binaries, hiddenimports = collect_all("xgboost")

2. 패키징

pyinstaller --collect-all "xgboost" test.py

--add-data "[file_path]; [dir_path]"

--hidden-import "[library]"

[Time Sereis Forecasting] One-Step, Multi-Step, Multi-Output

욱근욱 — Mon, 4 Nov 2024 16:22:42 +0900

One-Step

주어진 과거 데이터를 바탕으로 한 시점 뒤의 미래 값을 예측하는 방법

예를 들어, 1시간 간격으로 기록된 데이터가 있다면 0~6시의 데이터를 보고 1시간 뒤인 7시의 데이터를 예측하는 것

일반적으로 모델의 예측이 정확하며, 에러가 축적되지 않아 안정적인 예측 가능

Multi-Step

여러 시점을 동시에 예측하는 방법.

예를 들어, 1시간 간격으로 기록된 데이터가 있다면 0~12시의 데이터를 보고 6시간 뒤인 13~18시 까지의 데이터를 예측하는 것

Direct Multi-Step

각각의 시점을 별도의 모델로 예측하는 방법

예를 들어, t+1, t+2, t+3의 3개의 시점을 예측하고 싶다면 각각의 시점에 대해 독립적으로 모델을 훈련

정확도는 높을 수 있지만, 계산 비용이 증가

Recursive Multi-Step

이전 시점의 예측 결과를 다음 시점의 입력으로 사용하는 방법

예를 들어, t+1 시점의 예측 결과를 입력의 마지막에 붙여 t+2를 예측하는 방식

단일 모델을 반복적으로 사용해 계산 비용이 낮음
이전 예측의 에러가 다음 시점에 반영되어 에러가 누적될 수 있음

Multi-Output

예측하고자 하는 시점을 한 번에 예측하는 방법

단일 모델로 여러 시점의 값을 동시에 예측하기 때문에 복잡성이 낮음

ReLU Family

욱근욱 — Wed, 23 Oct 2024 14:02:03 +0900

ReLU

Rectified Linear Unit

$$ ReLU(x) = max(0,x) $$

LeakyReLU

$$ LeakyReLU_{\alpha} = max(\alpha x, x) $$

GELU

Gaussian Error Linear Unit

$$ GELU(x) = 0.5 \cdot x \cdot (1 + \tanh(\sqrt{2/\pi} \cdot (x + 0.044715 \cdot x^3))) $$

PReLU

Parametric ReLU

$$ PReLU(x) = \max(0, x) + a \cdot \min(0, x) $$

ELU

Exponential Linear Unit

$$ ELU_{\alpha} = \begin{cases} \alpha (\exp(x) - 1) & \text{if } x < 0 \\ x & \text{if } x >= 0 \end{cases} $$

SELU

Scaled Exponential Linear Unit

$$ SELU(x) = \text{scale} \cdot (\max(0, x) + \min(0, \alpha \cdot (\exp(x) - 1))) $$

[Windows 11] 네트워크 자격 증명 로그인 문제 해결 방법

욱근욱 — Thu, 17 Oct 2024 09:54:20 +0900

1. 일반적인 해결 방법

1.1 컴퓨터 공유 허용 문제

대부분 윈도우 업데이트 이후 발생

제어판 > 네트워크 및 인터넷 > 네트워크 및 공유 센터 > 고급 공유 설정 변경

1. 프라이빗 네트워크의 네트워크 검색, 파일 및 프린터 공유를 켬으로 변경

2. 모든 네트워크의 공유 폴더 공유, 암호로 보호된 공유를 켬으로 변경

2. 공유 폴더로 접근할 때 사용자 이름/ 암호가 맞지만, 일치하지 않다고하는 경우

2.1 네트워크 보안 LAN 관리자 인증 수준 문제

win + r > gpedit.msc > 컴퓨터 구성 > Windows 설정 > 보안 설정 > 로컬 정책 > 보안 옵션 > 네트워크 보안: LAN Manager 인증 수준

속성에서 'NTLMv2 응답만 보냅니다. LM 및 NTLM은 거부합니다.' 로 변경

2.2 Microsoft 계정 문제

설정 > 계정 에서 Microsoft 계정을 사용하고 있다면 로그아웃을 하여 로컬 계정으로 전환한 후 접속

3. 로그온 실패: 사용자는 이 컴퓨터에서는 요청된 로그온 유형을 허가 받지 않았습니다.

3.1 네트워크 자격 증명 문제

제어판 > 검색 : 자격 증명 관리자 > Windows 자격 증명 > Windows 자격 증명 추가 > 공유 폴더에 접속하기 위한 주소, 사용자 이름, 암호 입력

주소 입력 시 \\ 를 입력 할 것 (\\192.168.0.1)

[Time Series Forecasting] Sliding Window Dataset

욱근욱 — Mon, 14 Oct 2024 14:56:09 +0900

Sliding Window Dataset

https://mlpills.dev/time-series/forecasting-in-time-series/

Time Series Forecasting에 사용되는 Sliding Window Dataset은 연속적인 시계열 데이터를 여러 개의 고정된 크기의 입력과 출력 윈도우로 나누어 Dataset을 구성하는 방법입니다.

다음은 Pytorch로 Dataset 다변량(Multi-Variate) 다중 스텝(Multi-Step) 데이터셋을 구성하기 위한 코드입니다.

import torch
from torch.utils.data import Dataset

class SlidingWindowDataset(Dataset):
    def __init__(self, train_X, target_variables, input_window, output_window, stride=1):
        self.train_X = train_X
        self.train_y = train_X[target_variables].values

        self.input_window = input_window
        self.output_window = output_window
        self.stride = stride

        self.num_samples = (len(self.train_y) - input_window - output_window) // stride + 1

    def create_features(self, df, idx):
        return np.stack([df[var].values[idx * self.stride:idx * self.stride + self.input_window] for var in self.train_X.columns], axis=-1)

    def create_target(self, target, idx):
        return target[idx * self.stride + self.input_window : idx * self.stride + self.input_window + self.output_window]

    def __getitem__(self, idx):
        X = self.create_features(self.train_X, idx)
        Y = self.create_target(self.train_y, idx)

        X_tensor = torch.tensor(X, dtype=torch.float32)
        Y_tensor = torch.tensor(Y, dtype=torch.float32)

        return X_tensor, Y_tensor

    def __len__(self):
        return self.num_samples

[Time Series Forecasting] LSTM, GRU, CNN, ... PyTorch 구현

욱근욱 — Thu, 10 Oct 2024 15:07:45 +0900

LSTM

class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, dropout):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers

        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)

        self.selu = nn.SELU() # nn.ReLU()
        self.dropout = nn.Dropout(dropout)
        self.fc = nn.Linear(hidden_size, 1)

    def forward(self, x):
        batch_size = x.size(0)
        h0 = Variable(torch.zeros(self.num_layers, batch_size, self.hidden_size)).to(x.device)
        c0 = Variable(torch.zeros(self.num_layers, batch_size, self.hidden_size)).to(x.device)

        x, _ = self.lstm(x, (h0, c0))
        x = x[:, -1, :]

        x = self.dropout(self.selu(x))
        x = self.fc(x)

        return x.unsqueeze(-1)

GRU

class GRUModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, dropout):
        super(GRUModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers

        self.gru = nn.GRU(input_size, hidden_size, num_layers, batch_first=True)

        self.selu = nn.SeLU()
        self.dropout = nn.Dropout(dropout)
        self.fc = nn.Linear(hidden_size, 1)

    def forward(self, x):
        h0 = Variable(torch.zeros(self.num_layers, x.size(0), self.hidden_size)).to(x.device)

        x, _ = self.gru(x, h0)
        x = x[:, -1, :]
        
        x = self.dropout(self.selu(x))
        x = self.fc(x)

        return x.unsqueeze(-1)

CNN

class CNNModel(nn.Module):
    def __init__(self, input_size, hidden_size, kernel_size, input_window, output_window, dropout=0.2):
        super(CNNModel, self).__init__()

        self.conv1d1 = nn.Conv1d(input_size, hidden_size, kernel_size, stride=1, padding=kernel_size // 2)
        self.maxpool = nn.MaxPool1d(kernel_size=2, stride=2)

        self.selu = nn.SELU()
        self.dropout = nn.Dropout(dropout)

        self.fc = nn.Linear(hidden_size * (input_window // 2), output_window)

    def forward(self, x):
        x = x.transpose(1, 2)
        x = self.conv1d1(x)
        x = self.selu(x)
        x = self.maxpool(x)

        x = x.reshape(x.size(0), -1)

        x = self.dropout(self.selu(x))
        x = self.fc(x)

        return x.unsqueeze(-1)

CNN-LSTM

class CNN_LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, dropout, output_size, output_window):
        super(CNN_LSTM, self).__init__()
        
        self.output_size = output_size
        self.output_window = output_window

        self.conv1d = nn.Conv1d(in_channels=input_size, out_channels=hidden_size, kernel_size=3, stride=1, padding=1)
        self.maxpool = nn.MaxPool1d(kernel_size=2)

        self.lstm = nn.LSTM(input_size=hidden_size, hidden_size=hidden_size*2, num_layers=num_layers, batch_first=True)

        self.dropout1 = nn.Dropout(dropout)
        self.fc1 = nn.Linear(hidden_size*2, output_size * output_window)

        self.selu = nn.SELU()

    def forward(self, x):
        x = x.transpose(1, 2)

        x = self.selu(self.conv1d(x))
        x = self.maxpool(x)

        x = x.transpose(1, 2)

        x, _ = self.lstm(x)
        x = x[:, -1, :]

        x = self.dropout1(self.selu(x))
        x = self.fc1(x)
        x = x.reshape(-1, self.output_window, self.output_size)
        
        return x

TCN

"""
https://github.com/hyliush/deep-time-series/blob/master/models/TCN.py
"""

class Chomp1d(nn.Module):
    def __init__(self, chomp_size):
        super(Chomp1d, self).__init__()
        self.chomp_size = chomp_size

    def forward(self, x):
        return x[:, :, :-self.chomp_size].contiguous()


class TemporalBlock(nn.Module):
    def __init__(self, n_inputs, n_outputs, kernel_size, stride, dilation, padding, dropout=0.2):
        super(TemporalBlock, self).__init__()
        self.conv1 = nn.utils.parametrizations.weight_norm(nn.Conv1d(n_inputs, n_outputs, kernel_size,
                                           stride=stride, padding=padding, dilation=dilation))
        self.chomp1 = Chomp1d(padding)
        self.dropout1 = nn.Dropout(dropout)

        self.conv2 = nn.utils.parametrizations.weight_norm(nn.Conv1d(n_outputs, n_outputs, kernel_size,
                                           stride=stride, padding=padding, dilation=dilation))
        self.chomp2 = Chomp1d(padding)
        self.dropout2 = nn.Dropout(dropout)

        self.net = nn.Sequential(self.conv1, self.chomp1, self.dropout1,
                                 self.conv2, self.chomp2, self.dropout2)
        self.downsample = nn.Conv1d(n_inputs, n_outputs, 1) if n_inputs != n_outputs else None
        self.init_weights()

    def init_weights(self):
        self.conv1.weight.data.normal_(0, 0.01)
        self.conv2.weight.data.normal_(0, 0.01)
        if self.downsample is not None:
            self.downsample.weight.data.normal_(0, 0.01)

    def forward(self, x):
        out = self.net(x)
        res = x if self.downsample is None else self.downsample(x)
        return out + res

class TCN(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, kernel_size, dropout=0.2):
        super(TCN, self).__init__()

        num_channels = [hidden_size] * num_layers
        layers = []
        num_levels = len(num_channels)
        for i in range(num_levels):
            dilation_size = 2 ** i
            in_channels = input_size if i == 0 else num_channels[i-1]
            out_channels = num_channels[i]

            layers += [TemporalBlock(in_channels, out_channels, kernel_size, stride=1, dilation=dilation_size,
                                     padding=(kernel_size-1) * dilation_size, dropout=dropout)]

        self.network = nn.Sequential(*layers)
        self.out_proj = nn.Linear(hidden_size, 1)

    def forward(self, x):
        x = x.transpose(1, 2)
        x = self.network(x)
        x = x[:, :, -1:]
        x = self.out_proj(x.transpose(1, 2))
        return x

Transformer Encoder

import math
import torch.nn.functional as F

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, dropout=0.1, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)

        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0).transpose(0, 1)
        self.register_buffer('pe', pe)

    def forward(self, x):
        x = x + self.pe[:x.size(0), :]
        return self.dropout(x)


class TransformerEncoder(nn.Module):
    def __init__(self, input_size, hidden_size, kernel_size, seq_len, n_head, n_layers, output_size, output_window):
        super(TransformerEncoder, self).__init__()

        self.conv = nn.Conv1d(input_size, hidden_size, kernel_size=kernel_size)
        self.pos_encoder = PositionalEncoding(hidden_size, max_len=seq_len)
        self.transformer_layer = nn.TransformerEncoderLayer(d_model=hidden_size, nhead=n_head)
        self.transformer = nn.TransformerEncoder(self.transformer_layer, num_layers=n_layers)
        self.fc = nn.Linear(hidden_size, output_size * output_window)

        self.kernel_size = kernel_size

    def forward(self, x):
        x = x.transpose(1, 2)
        x = F.pad(x, (self.kernel_size-1,0))
        x = self.conv(x).permute(2, 0, 1)
        x = self.pos_encoder(x)
        x = self.transformer(x).transpose(0, 1)[:, -1:]
        x = self.fc(x)
        return x.transpose(1, 2)

D-Linear

class moving_avg(torch.nn.Module):
    def __init__(self, kernel_size, stride):
        super(moving_avg, self).__init__()
        self.kernel_size = kernel_size
        self.avg = torch.nn.AvgPool1d(kernel_size=kernel_size, stride=stride, padding=0)

    def forward(self, x):
        front = x[:, 0:1, :].repeat(1, (self.kernel_size - 1) // 2, 1)
        end = x[:, -1:, :].repeat(1, (self.kernel_size - 1) // 2, 1)
        x = torch.cat([front, x, end], dim=1)
        x = self.avg(x.permute(0, 2, 1))
        x = x.permute(0, 2, 1)
        return x

class series_decomp(torch.nn.Module):
    def __init__(self, kernel_size):
        super(series_decomp, self).__init__()
        self.moving_avg = moving_avg(kernel_size, stride=1)

    def forward(self, x):
        moving_mean = self.moving_avg(x)
        residual = x - moving_mean
        return moving_mean, residual

class LTSF_DLinear(torch.nn.Module):
    def __init__(self, seq_len, pred_len, kernel_size, individual, feature_size):
        super(LTSF_DLinear, self).__init__()

        self.seq_len = seq_len
        self.pred_len = pred_len

        self.decompsition = series_decomp(kernel_size)
        self.individual = individual
        self.channels = feature_size

        if self.individual:
            self.Linear_Seasonal = torch.nn.ModuleList()
            self.Linear_Trend = torch.nn.ModuleList()
            for i in range(self.channels):
                self.Linear_Trend.append(torch.nn.Linear(self.seq_len, self.pred_len))
                self.Linear_Trend[i].weight = torch.nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len, self.seq_len]))
                self.Linear_Seasonal.append(torch.nn.Linear(self.seq_len, self.pred_len))
                self.Linear_Seasonal[i].weight = torch.nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len, self.seq_len]))
        else:
            self.Linear_Trend = torch.nn.Linear(self.seq_len, self.pred_len)
            self.Linear_Trend.weight = torch.nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len, self.seq_len]))
            self.Linear_Seasonal = torch.nn.Linear(self.seq_len,  self.pred_len)
            self.Linear_Seasonal.weight = torch.nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len, self.seq_len]))

        self.fc = nn.Linear(feature_size, 1)

    def forward(self, x):
        trend_init, seasonal_init = self.decompsition(x)
        trend_init, seasonal_init = trend_init.permute(0,2,1), seasonal_init.permute(0,2,1)

        if self.individual:
            trend_output = torch.zeros([trend_init.size(0), trend_init.size(1), self.pred_len], dtype=trend_init.dtype).to(trend_init.device)
            seasonal_output = torch.zeros([seasonal_init.size(0), seasonal_init.size(1), self.pred_len], dtype=seasonal_init.dtype).to(seasonal_init.device)
            for idx in range(self.channels):
                trend_output[:, idx, :] = self.Linear_Trend[idx](trend_init[:, idx, :])
                seasonal_output[:, idx, :] = self.Linear_Seasonal[idx](seasonal_init[:, idx, :])
        else:
            trend_output = self.Linear_Trend(trend_init)
            seasonal_output = self.Linear_Seasonal(seasonal_init)

        x = seasonal_output + trend_output
        x = x.permute(0,2,1)

        if x.size(2) > 1:
            x = self.fc(x)
            return x
        return x

코랩(Colab) 끊김 방지

욱근욱 — Thu, 10 Oct 2024 09:13:52 +0900

F12 > console (콘솔) 창에 아래 코드 입력

var startClickConnect = function startClickConnect(){
    var clickConnect = function clickConnect(){
        console.log("Connnect Clicked - Start");
        document.querySelector("#top-toolbar > colab-connect-button").shadowRoot.querySelector("#connect").click();
        console.log("Connnect Clicked - End"); 
    };

    var intervalId = setInterval(clickConnect, 60000);

    var stopClickConnectHandler = function stopClickConnect() {
        console.log("Connnect Clicked Stopped - Start");
        clearInterval(intervalId);
        console.log("Connnect Clicked Stopped - End");
    };

    return stopClickConnectHandler;
};

var stopClickConnect = startClickConnect();

개미는 오늘도 열심히 일을하네

wsl 자동 실행 & 백그라운드 실행

1. cmd 에서 wsl 동작 확인

2. cmd 에서 명령어 실행 확인

3. cmd 에서 다시 wsl 동작 확인

4. 작업 스케줄러 등록

5. 백그라운드로 실행된 wsl 종료

선택적 기능 (WMIC, .NET Framework 3.5)

ISO File

WMIC

.Net Framework 3.5

Pyinstaller cupy 관련 ModuleNotFound 에러

Python EXE Decompile

0. 준비물

[필수] Microsoft C++ Build Tools

[선택] HxD

1. .exe \(\rightarrow\) .pyc

2. .pyc \(\rightarrow\) .py

참고

[Dockerfile] From ubuntu, Python with Node.js

[React] 8 vulnerabilities (2 moderate, 6 high)

문제

해결 방법

[React] WSL에 Dockerfile로 React 환경 구축

React 프로젝트 생성

Dockerfile로 Image Build

Container 생성

[DiPE-Linear] Disentangled Interpretable Representation for Efficient Long-term Time Series Forecasting

Introduction

DiPE-Linear

1. Static Frequential Attention (SFA)

2. Static Temporal Attention (STA)

3. Idependent Frequential Mapping (IFM)

정리

Low-Rank Weight Sharing

SFALoss

Results

Code

num_experts

rank_experts

STA(Static Temporal Attention)

SFW(Static Frequential Attention)

IFM(Independent Frequential Mapping)

Identity

DiPE

SFALoss

[LTSF-Linear] / [DLinear, NLinear] Are Transformers Effective for Time Series Forecasting ?

Transformer 기반 시계열 예측 모델의 문제점

1. 순서 정보의 상실

2. 복잡한 모델 구조

3. 장기 예측 한계

LTSF-Linear

DLinear [Code]

NLinear [Code]

실험 결과

[Python] win32api Error - ImportError: DLL load failed while importing win32api: 지정된 모듈을 찾을 수 없습니다.

[Python] VSCode Error - Sorry, something went wrong activating IntelliCode support for Python. Please check the "Python" and "VS IntelliCode" output windows for details.

[Ubuntu] E: Unable to locate package

[Docker] Container Network 연결

[PostgreSQL] ON CONFLICT ERROR (there is no unique or ~)

상황

원인

해결

[Python] 기상청 API Hub의 날씨 & 날씨 예보 데이터 수집 with. airflow

[Python] Airflow Dag 정보 (Task Context) 전달

[Docker] PostgreSQL 설치

도커 실행

내부 접속

Database 목록 확인

외부 접속

[Git] 삭제된 폴더, 파일 반영

[Python] Windows에 pyenv 설치

1. 설치

2. 가상환경 생성

간단한 Airflow v2.10.5 환경 구축 (with. dockerfile)

WSL2 Ubuntu

Dockerfile (Airflow 2.10.5)

[Tistory] hELLO. 스킨 카테고리 접기 펼치기 수정

docker-compose로 Airflow 환경 구축

Python