[ python ] argparse 사용 방법. 예제.

머신러닝 모델의 하이퍼 파라미터를 쉽게 관리할 수 있다.
파이썬 3.7 기준

사용법

먼저, 다음과 같은 python file 을 만든다.

import argparse

# 인자값을 받을 수 있는 인스턴스 생성
parser = argparse.ArgumentParser(description='Argparse Tutorial')

# 입력받을 인자값 설정 (default 값 설정가능)
parser.add_argument('--epoch',          type=int,   default=150)
parser.add_argument('--batch_size',     type=int,   default=128)
parser.add_argument('--lr_initial',     type=float, default=0.1)

# args 에 위의 내용 저장
args    = parser.parse_args()

# 입력받은 인자값 출력
print(args.epoch)
print(args.batch_size)
print(args.lr_initial)

이후, 터미널에서 파이썬 파일을 실행 시키면 아래와 같은 결과를 보여준다.

파이썬 파일 실행 방법은

python 파일이름.py

로 실행할 수 있다.

# python 파일을 터미널에서 실행 시킨다.

$ python argparse_example.py 

  150  # default epoch
  128  # default batch size
  0.1  # default learning rate


# 뒤쪽에 -h 또는 --help 를 붙이면 내용에 대해서 보여준다.

$ python argparse_example.py -h 

  usage: argparse_example.py [-h] [--epoch EPOCH] [--batch_size BATCH_SIZE]
                             [--lr_initial LR_INITIAL]

  Argparse Tutorial

  optional arguments:
    -h, --help            show this help message and exit
    --epoch EPOCH
    --batch_size BATCH_SIZE
    --lr_initial LR_INITIAL


# 다음과 같이 명령시에 직접 값을 설정해 적용할 수 있다.

$ python argparse_example.py --epoch=256 --batch_size 64 --lr_initial 0.1111

  256    # epoch
  64     # batch_size
  0.1111 # learning rate

일반적인 머신러닝에서 위의 모듈을 사용하는 방법은 다음과 같다.

main.py : 모델 학습/평가가 수행되는 파이썬 코드 ( run in python)
main.sh : main.py 에 특정한 하이퍼 파라미터를 부여하는 코드 ( run in shell )

# main.py

import argparse

# 인자값을 받을 수 있는 인스턴스 생성
parser = argparse.ArgumentParser(description='Argparse Tutorial')

# 입력받을 인자값 설정 (default 값 설정가능)
parser.add_argument('--epoch',          type=int,   default=150)
parser.add_argument('--batch_size',     type=int,   default=128)
parser.add_argument('--lr_initial',     type=float, default=0.1)

# args 에 위의 내용 저장
args    = parser.parse_args()

# 입력받은 인자값 출력
print(args.epoch)
print(args.batch_size)
print(args.lr_initial)

# main.sh

# 본인이 원하는대로 값을 설정해줄 수 있다.

python argparse_example.py  # default value
python argparse_example.py --epoch=200 --batch_size=256 --lr_initial=0.3
python argparse_example.py --epoch=300 --batch_size=64 --lr_initial=0.03
python argparse_example.py --epoch=400 --batch_size=32 --lr_initial=0.003

위와 같은 .py .sh 파일을 만든 후 터미널에서 다음과 같이 sh 파일을 실행 시켜준다.

$ sh main.sh

  # 결과
  150    # default epoch
  128    # default batch size
  0.1    # default learning rate

  200    # epoch
  256    # batch size
  0.3    # learning rate

  300    # epoch
  64     # batch size
  0.03   # learning rate

  400    # epoch
  32     # batch size
  0.003  # learning rate

ArgumentParser 객체

class argparse.ArgumentParser(prog=None, usage=None, description=None, epilog=None, parents=[], formatter_class=argparse.HelpFormatter, prefix_chars='-', fromfile_prefix_chars=None, argument_default=None, conflict_handler='error', add_help=True, allow_abbrev=True)

새로운 ArgumentParser 객체를 만듭니다. 모든 매개 변수는 키워드 인자로 전달되어야 한다. 매개 변수마다 아래에서 더 자세히 설명되지만, 요약하면 다음과 같다:

prog - 프로그램의 이름 (기본값: sys.argv[0])
- 참고로 sys.argv[0] 에는 해당하는 스크립트가 놓여지는 장소가 저장된다.
- sys.argv[1] 에는 처리할 파일 이름이 놓인다.
- 기본적으로 argument parser은 sys.argv[0] 을 사용하여 도움말 메시지에 프로그램의 이름을 표시한다.
- parser = argparse.ArgumentParser(prog='myprogram')
  - 위와 같이 prog를 설정할 경우
  - parser.print_help() 의 결과 myprogram [-h] 으로 이름이 재 설정 된다.
- %(prog)s 포맷 지정자를 사용해서 도움말에 쓸 수도 있다.
  - parser.add_argument('--foo', help='foo of the %(prog)s program')
usage - 프로그램 사용법을 설명하는 문자열 (기본값: 파서에 추가된 인자로부터 만들어지는 값)
- parser = argparse.ArgumentParser(prog='PROG'. usage='%(prog)s [options]')
- usage 또한 재정의 가능.
description - 인자 도움말 전에 표시할 텍스트 (기본값: none)
- parser = argparse.ArgumentParser(description='A foo that bars')
epilog - 인자 도움말 후에 표시할 텍스트 (기본값: none)
- parser = argparse.ArgumentParser(epilog="And that's how you'd foo a bar")
parents - ArgumentParser 객체들의 리스트이고, 이 들의 인자들도 포함된다
- 때로 여러 바서가 공통 인자 집합을 공유하는 경우가 있다.
- 반복정의하는 대신, 모든 공유인자를 갖는 파서를 ArgumentParser 에 parents= 인자로 전달할 수 있다.
- parent_parser = argparse.ArgumentParser(add_help=False)
- parent_parser.add_argument('--parent', type=int)
- foo_parser = argparse.ArgumentParser(parents=[parent_parser])
formatter_class - 도움말 출력을 사용자 정의하기 위한 클래스
- argparse.RawDescriptionHelpFormatter
- argparse.RawTextHelpFormatter
- argparse.ArgumentDefaultsHelpFormatter
- argparse.MetavarTypeHelpFormatter
prefix_chars - 선택 인자 앞에 붙는 문자 집합 (기본값: - ).
- -f /--foo 같이 앞에 붙는 접두사를 다른 것으로 바꿀 수 있다.
fromfile_prefix_chars - 추가 인자를 읽어야 하는 파일 앞에 붙는 문자 집합 (기본값: None).
- 긴 인자 목록을 다룰 때, 인자 목록을 명령행에 입력하는 대신 파일에 보관하는 것이 좋다.
- fromfile_prefix_chars= 인자는 말 그대로, 지정된 문자로 시작하는 인자는 파일로 간주하고 파일에 포함된 인자로 대체한다.
- with open('args.txt', 'w') as fp: fp.write('-f\nbar')
- parser = argparse.ArgumentParser(fromfile_prefix_chars='@')
- parser.add_argument('-f')
- parser.parse_args(['-f', 'foo', '@args.txt'])
  - 위의 ['-f', 'foo', '@args.txt'] 식은 ['-f', 'foo', '-f', 'bar'] 와 동등하게 취급된다.

argument_default - 인자의 전역 기본값 (기본값: None)
conflict_handler - 충돌하는 선택 사항을 해결하기 위한 전략
- 같은 옵션 문자열을 가진 두 개의 액션을 허용하지 않기 때문에 예전인자를 대체할 수 있다.
- conflict_handler = 'resolve'
add_help - 파서에 -h/--help 옵션을 추가합니다 (기본값: True)
allow_abbrev - 약어가 모호하지 않으면 긴 옵션을 축약할 수 있도록 합니다. (기본값: True)

add_argument() 메서드

ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])

단일 명령행 인자를 구문 분석하는 방법을 정의합니다. 매개 변수마다 아래에서 더 자세히 설명되지만, 요약하면 다음과 같다:

name or flags - 옵션 문자열의 이름이나 리스트, 예를 들어 foo 또는 -f, --foo.
- 선택 인자
  - parser.add_argument('-f', '--foo')
- 위치 인자 : 파일 이름
  - parser.add_argument('bar')
- parse_args() 가 호출 되면 선택 인자는 - 접두사로 식별, 그 밖의 인자는 위치 인자로 간주.

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-f', '--foo')
>>> parser.add_argument('bar')
>>> parser.parse_args(['BAR'])
Namespace(bar='BAR', foo=None)
>>> parser.parse_args(['BAR', '--foo', 'FOO'])
Namespace(bar='BAR', foo='FOO')
>>> parser.parse_args(['--foo', 'FOO'])
usage: PROG [-h] [-f FOO] bar
PROG: error: the following arguments are required: bar

action - 명령행에서 이 인자가 발견될 때 수행 할 액션의 기본형.
- 'store' - 인자 값을 저장. 기본 액션.
- 'store_const' - const 키워드 인자에 의해 지정된 값을 저장.
- 'store_true' / 'store_false' - 각각 true 와 false 를 저장.
- 'append' - 리스트를 저장하고 각 인자 값을 리스트에 추가.
- 'count' - 키워드 인자가 등장한 횟수를 계산.
- 'help' - 현재 파서의 모든 옵션에 대한 완전한 도움말 메시지를 출력하고 종료한다.
- 'version' - add_argument() 호출에서 version= 키워드 인자를 기대하고, 호출되면 버전 정보를 출력하고 종료한다.
- 'extend' - 리스트로 저장하고 각 인자 값으로 리스트를 확장한다.

# 'store'
parser = argparse.ArgumentParser()
parser.add_argument('--foo')
parser.parse_args('--foo 1'.split())
# Namespace(foo='1')

# 'store_const'
parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='store_const', const=42)
parser.parse_args(['--foo'])
# Namespace(foo=42)

# 'store_true' / 'store_false'
parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='store_true')
parser.add_argument('--bar', action='store_false')
parser.add_argument('--baz', action='store_false')
parser.parse_args('--foo --bar'.split())
# Namespace(foo=True, bar=False, baz=True)

# 'append'
parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='append')
parser.parse_args('--foo 1 --foo 2'.split())
# Namespace(foo=['1', '2'])

# 'append_const'
parser = argparse.ArgumentParser()
parser.add_argument('--str', dest='types', action='append_const', const=str)
parser.add_argument('--int', dest='types', action='append_const', const=int)
parser.parse_args('--str --int'.split())
# Namespace(types=[<class 'str'>, <class 'int'>])

# 'count'
parser = argparse.ArgumentParser()
parser.add_argument('--verbose', '-v', action='count', default=0)
parser.parse_args(['-vvv'])
# Namespace(verbose=3)

# 'version'
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('--version', action='version', version='%(prog)s 2.0')
parser.parse_args(['--version'])
PROG 2.0

nargs - 소비되어야 하는 명령행 인자의 수.
- 일반적으로 하나의 명령행 인자를 하나의 액션과 결합한다.
- 그러나 nargs 키워드 인자는 다른 수의 명령행 인자를 하나의 액션으로 연결 할 수 있다.

parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs=2)
parser.add_argument('bar', nargs=1)
parser.parse_args('c --foo a b'.split())
# Namespace(bar=['c'], foo=['a', 'b'])

# '?'
parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs='?', const='c', default='d')
parser.add_argument('bar', nargs='?', default='d')
parser.parse_args(['XX', '--foo', 'YY'])
# Namespace(bar='XX', foo='YY')
parser.parse_args(['XX', '--foo'])
# Namespace(bar='XX', foo='c')
parser.parse_args([])
# Namespace(bar='d', foo='d')

# 선택적 입출력 가능.
parser = argparse.ArgumentParser()
parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),
                     default=sys.stdin)
parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'),
                     default=sys.stdout)
parser.parse_args(['input.txt', 'output.txt'])
# Namespace(infile=<_io.TextIOWrapper name='input.txt' encoding='UTF-8'>,
          outfile=<_io.TextIOWrapper name='output.txt' encoding='UTF-8'>)
parser.parse_args([])
# Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>,
          outfile=<_io.TextIOWrapper name='<stdout>' encoding='UTF-8'>)

const - 일부 action 및 nargs 를 선택할 때 필요한 상숫값.
default - 인자가 명령행에 없는 경우 생성되는 값.
type - 명령행 인자가 변환되어야 할 형.
- open() 함수의 FileType 제공.`

parser = argparse.ArgumentParser()
parser.add_argument('foo', type=int)
parser.add_argument('bar', type=open)
parser.parse_args('2 temp.txt'.split())
# Namespace(bar=<_io.TextIOWrapper name='temp.txt' encoding='UTF-8'>, foo=2)

parser = argparse.ArgumentParser()
parser.add_argument('bar', type=argparse.FileType('w'))
parser.parse_args(['out.txt'])
# Namespace(bar=<_io.TextIOWrapper name='out.txt' encoding='UTF-8'>)

choices - 인자로 허용되는 값의 컨테이너.

parser = argparse.ArgumentParser(prog='doors.py')
parser.add_argument('door', type=int, choices=range(1, 4))
print(parser.parse_args(['3']))
# Namespace(door=3)
parser.parse_args(['4'])
# usage: doors.py [-h] {1,2,3}
# doors.py: error: argument door: invalid choice: 4 (choose from 1, 2, 3)

required - 명령행 옵션을 생략 할 수 있는지 아닌지 (선택적일 때만).
- required=True 일 경우 해당 옵션이 필수로 주어져야 한다.

parser = argparse.ArgumentParser()
parser.add_argument('--foo', required=True)
parser.parse_args(['--foo', 'BAR'])
#Namespace(foo='BAR')

parser.parse_args([])
# usage: argparse.py [-h] [--foo FOO]
# argparse.py: error: option --foo is required

help - 인자가 하는 일에 대한 간단한 설명.
metavar - 사용 메시지에 사용되는 인자의 이름.
- 도움말 메시지를 생성할 때, 기대되는 각 인자를 가리킬 방법이 필요하다.
- 기본적으로 dest 값을 각 객체의 '이름' 으로 사용한다.
- 선택 인자 액션의 경우 dest 값에 대문자가 사용된다.

parser = argparse.ArgumentParser()
parser.add_argument('--foo', metavar='YYY')
parser.add_argument('bar', metavar='XXX')
parser.parse_args('X --foo Y'.split())
# Namespace(bar='X', foo='Y')
parser.print_help()
"""
usage:  [-h] [--foo YYY] XXX

positional arguments:
 XXX

optional arguments:
 -h, --help  show this help message and exit
 --foo YYY
 """

dest - parse_args() 가 반환하는 객체에 추가될 어트리뷰트의 이름.

parser = argparse.ArgumentParser()
parser.add_argument('--foo', dest='bar')
parser.parse_args('--foo XXX'.split())
# Namespace(bar='XXX')

참고

donghwa-kim.github.io/argparser.html

docs.python.org/ko/3/library/argparse.html

'컴퓨터 언어 > Python' 카테고리의 다른 글

[ Python ] print 함수 사용하기 - 기초 (문자열, sep, end) (0)	2022.06.09
[ Python ] python 객체 type 확인하기 ( isinstance() ) (0)	2022.01.09
Latex 수식 정리 (0)	2020.03.28
Window command 명령어.(cd, dir, mkdir...) (0)	2020.03.28
[python 3] 가상환경의 커널(kernel)을 주피터노트북에 생성하기. (4)	2020.03.27

SuperMemi's Study

[ python ] argparse 사용 방법. 예제.