Reformat code snippet in README

README.md

@@ -17,21 +17,27 @@ I have tested on:
 
 First create lmdb datasets:
 
-> python prepare_data.py --out LMDB_PATH --n_worker N_WORKER --size SIZE1,SIZE2,SIZE3,... DATASET_PATH
+```shell
+python prepare_data.py --out LMDB_PATH --n_worker N_WORKER --size SIZE1,SIZE2,SIZE3,... DATASET_PATH
+```
 
 This will convert images to jpeg and pre-resizes it. This implementation does not use progressive growing, but you can create multiple resolution datasets using size arguments with comma separated lists, for the cases that you want to try another resolutions later.
 
 Then you can train model in distributed settings
 
-> python -m torch.distributed.launch --nproc_per_node=N_GPU --master_port=PORT train.py --batch BATCH_SIZE LMDB_PATH
+```shell
+python -m torch.distributed.launch --nproc_per_node=N_GPU --master_port=PORT train.py --batch BATCH_SIZE LMDB_PATH
+```
 
 train.py supports Weights & Biases logging. If you want to use it, add --wandb arguments to the script.
 
 #### SWAGAN
 
 This implementation experimentally supports SWAGAN: A Style-based Wavelet-driven Generative Model (https://arxiv.org/abs/2102.06108). You can train SWAGAN by using
 
-> python -m torch.distributed.launch --nproc_per_node=N_GPU --master_port=PORT train.py --arch swagan --batch BATCH_SIZE LMDB_PATH
+```shell
+python -m torch.distributed.launch --nproc_per_node=N_GPU --master_port=PORT train.py --arch swagan --batch BATCH_SIZE LMDB_PATH
+```
 
 As noted in the paper, SWAGAN trains much faster. (About ~2x at 256px.)
 
@@ -41,35 +47,47 @@ You need to clone official repositories, (https://github.com/NVlabs/stylegan2) a
 
 For example, if you cloned repositories in ~/stylegan2 and downloaded stylegan2-ffhq-config-f.pkl, You can convert it like this:
 
-> python convert_weight.py --repo ~/stylegan2 stylegan2-ffhq-config-f.pkl
+```shell
+python convert_weight.py --repo ~/stylegan2 stylegan2-ffhq-config-f.pkl
+```
 
 This will create converted stylegan2-ffhq-config-f.pt file.
 
 ### Generate samples
 
-> python generate.py --sample N_FACES --pics N_PICS --ckpt PATH_CHECKPOINT
+```shell
+python generate.py --sample N_FACES --pics N_PICS --ckpt PATH_CHECKPOINT
+```
 
 You should change your size (--size 256 for example) if you train with another dimension.
 
 ### Project images to latent spaces
 
-> python projector.py --ckpt [CHECKPOINT] --size [GENERATOR_OUTPUT_SIZE] FILE1 FILE2 ...
+```shell
+python projector.py --ckpt [CHECKPOINT] --size [GENERATOR_OUTPUT_SIZE] FILE1 FILE2 ...
+```
 
 ### Closed-Form Factorization (https://arxiv.org/abs/2007.06600)
 
 You can use `closed_form_factorization.py` and `apply_factor.py` to discover meaningful latent semantic factor or directions in unsupervised manner.
 
 First, you need to extract eigenvectors of weight matrices using `closed_form_factorization.py`
 
-> python closed_form_factorization.py [CHECKPOINT]
+```shell
+python closed_form_factorization.py [CHECKPOINT]
+```
 
 This will create factor file that contains eigenvectors. (Default: factor.pt) And you can use `apply_factor.py` to test the meaning of extracted directions
 
-> python apply_factor.py -i [INDEX_OF_EIGENVECTOR] -d [DEGREE_OF_MOVE] -n [NUMBER_OF_SAMPLES] --ckpt [CHECKPOINT] [FACTOR_FILE]
+```shell
+python apply_factor.py -i [INDEX_OF_EIGENVECTOR] -d [DEGREE_OF_MOVE] -n [NUMBER_OF_SAMPLES] --ckpt [CHECKPOINT] [FACTOR_FILE]
+```
 
 For example,
 
-> python apply_factor.py -i 19 -d 5 -n 10 --ckpt [CHECKPOINT] factor.pt
+```shell
+python apply_factor.py -i 19 -d 5 -n 10 --ckpt [CHECKPOINT] factor.pt
+```
 
 Will generate 10 random samples, and samples generated from latents that moved along 19th eigenvector with size/degree +-5.