[PYTHON] Exécutez PIFuHD dans l'environnement Windows + Anaconda + Git Bash

Aperçu

J'ai essayé un modèle de Deep Learning appelé PIFuHD qui génère un maillage tridimensionnel à partir d'une (ou plusieurs) photos, c'est donc un mémo. C'est un mémo parce que j'étais accro à l'exécuter dans un environnement Windows.

En citant la vidéo publiée sur GitHub, vous pouvez effectuer les opérations suivantes:

• facebookresearch/pifuhd - GitHub

Environnement

Cet environnement utilise Anaconda. (PIFuHD utilise Python, donc un environnement Python est requis)

Normalement, lorsque vous installez Anaconda, une interface graphique est également incluse, vous pouvez donc y définir l'environnement. À partir de là, vous pouvez également lancer un terminal avec l'environnement Anaconda configuré, il vous suffit donc d'exécuter un script Python à partir de la ligne de commande.

Cependant, lorsque j'essaye différents modèles de Deep Learning, il y a toujours des moments où je travaille avec des scripts Shell. Bien sûr, il ne peut pas être exécuté à partir de l'invite de commande Windows.

Donc, cette fois, je voudrais configurer pour utiliser Anaconda (commande conda) même dans l'environnement Bash de Git pour Windows. (Si vous voulez juste essayer la démo PIFuHD, il vous suffit d'appuyer vous-même sur certaines commandes dans .sh, donc je ne peux pas dire que ce n'est pas nécessaire)

Après avoir installé Anaconda, configurez la commande conda pour qu'elle soit disponible sur Git pour Windows.

Installez Anaconda

Tout d'abord, installez Anaconda. Cliquez sur le bouton «Commencer» sur la page Anaconda, puis sur ** Installer Anaconda Individual Edition ** pour accéder à la page de téléchargement (https://www.anaconda.com/products/individual).

Il y a un bouton ** Télécharger ** sur la page de téléchargement, cliquez dessus pour faire défiler jusqu'au lien de téléchargement en bas de la page, sélectionnez ** 64-Bit Graphical Installer ** à partir de là pour télécharger le programme d'installation et Anaconda À installer.

À travers le chemin

Une fois l'installation terminée, transmettez le chemin pour que Bash le reconnaisse. Ensuite, la commande conda elle-même sera reconnue.

Dans mon environnement, j'ai ajouté ce qui suit à .basahrc.

export PATH=$PATH:/c/Users/[USER_NAME]/anaconda3
export PATH=$PATH:/c/Users/[USER_NAME]/anaconda3/Scripts

Veuillez réécrire en fonction de l'emplacement d'installation. Si vous conservez la valeur par défaut, vous pouvez utiliser la même chose que ci-dessus.

J'obtiens une erreur avec conda activate

Après avoir traversé Path, lorsque j'ai essayé d'activer l'environnement Anaconda et exécuté $ conda activate, l'erreur suivante s'est produite.

$ conda activate

CommandNotFoundError: Your shell has not been properly configured to use 'conda activate'.
If using 'conda activate' from a batch script, change your
invocation to 'CALL conda.bat activate'.

To initialize your shell, run

    $ conda init <SHELL_NAME>

Currently supported shells are:
  - bash
  - cmd.exe
  - fish
  - tcsh
  - xonsh
  - zsh
  - powershell

See 'conda init --help' for more information and options.

IMPORTANT: You may need to close and restart your shell after running 'conda init'.

Je l'ai résolu en me référant à l'article suivant.

• Visual Studio code + Anaconda + git bash a préparé un environnement Python qui permet aux commandes Linux d'être utilisées même sous Windows (2020/03/10)

Apparemment, c'est un problème car lorsque je lance conda init, ce qui est écrit automatiquement ne l'est pas. Ainsi, en ajoutant manuellement ce qui suit à .bashrc, conda est reconnu et peut être utilisé en toute sécurité sur Bash of Git pour Windows.

# >>> conda init >>>
__conda_setup="$(CONDA_REPORT_ERRORS=false '$HOME/anaconda3/bin/conda' shell.bash hook 2> /dev/null)"
if [ $? -eq 0 ]; then
    \eval "$__conda_setup"
else
    if [ -f "$HOME/anaconda3/etc/profile.d/conda.sh" ]; then
        . "$HOME/anaconda3/etc/profile.d/conda.sh"
        CONDA_CHANGEPS1=false conda activate base
    else
        \export PATH="$PATH:$HOME/anaconda3/bin"
    fi
fi

unset __conda_setup
# <<< conda init <<<

Après avoir ajouté cela, vous pouvez exécuter $ source ~ / .bashrc ou redémarrer le terminal et vous pourrez exécuter $ conda activate [ENV_NAME]. Si l'environnement est correctement appliqué, vous devriez voir le nom de l'environnement dans l'invite.

Configuration pour PIFuHD

Après avoir créé l'environnement pour Anaconda, nous installerons PIFU HD. Le fichier README de GitHub indique ce qui suit, nous allons donc le configurer pour qu'ils puissent être utilisés.

Requirements

• Python 3
• PyTorch tested on 1.4.0, 1.5.0
• json
• PIL
• skimage
• tqdm
• cv2 For visualization

• trimesh with pyembree
• PyOpenGL
• freeglut (use sudo apt-get install freeglut3-dev for ubuntu users)
• ffmpeg

À propos, la configuration manuelle est décrite dans le README de Référentiel de la version sans HD comme suit, donc je l'ai configuré en faisant référence à cela. (J'ai fait référence à la partie ** OU configuration manuelle de l'environnement **. ** Je n'ai pas fait référence à la partie ci-dessus car j'utilise miniconda **)

Windows demo installation instuction

• Install miniconda
• Add conda to PATH
• Install git bash
• Launch Git\bin\bash.exe
• eval "$(conda shell.bash hook)" then conda activate my_env because of this
• Automatic env create -f environment.yml (look this)
• OR manually setup environment
  • conda create —name pifu python where pifu is name of your environment
  • conda activate
  • conda install pytorch torchvision cudatoolkit=10.1 -c pytorch
  • conda install pillow
  • conda install scikit-image
  • conda install tqdm
  • conda install -c menpo opencv
• Download wget.exe
• Place it into Git\mingw64\bin
• sh ./scripts/download_trained_model.sh
• Remove background from your image (this,forexample)
• Create black-white mask .png
• Replace original from sample_images/
• Try it out - sh ./scripts/test.sh
• Download Meshlabbecauseofthis
• Open .obj file in Meshlab

Installer les modules supplémentaires requis

En plus de ce qui précède, j'ai également installé les éléments suivants. (Il est écrit dans le README de PIFuHD)

• trimesh
• PyOpenGL
• freeglut

Installez chacun comme suit.

$ conda install -c conda-forge trimesh

$ conda install -c anaconda pyopengl

Installez GLUT sur Windows

Lorsque j'ai essayé d'exécuter l'exemple sans installer GLUT, l'erreur suivante s'est produite.

OpenGL.error.NullFunctionError: Attempt to call an undefined function glutInit, check for bool(glutInit) before calling

C'est une erreur car il n'y a pas de GLUT. Cependant, je ne savais pas comment l'installer et cet article m'a aidé.

• J'ai essayé d'exécuter PIFuHD sur Windows pour le moment --Qiita

Dans cet article, il est écrit qu'il a été résolu en se référant à un autre article. Cliquez ici pour un autre article (Utilisation d'OpenGL avec Python sur le journal de Windows-Tadao Yamaoka)

Permettez-moi d'en citer

Installation gratuite de GLUT

Vous devez installer GLUT séparément de PyOpenGL. GLUT semble être une bibliothèque indépendante de la plate-forme pour gérer OpenGL.

Original GLUT ne peut pas télécharger le binaire 64 bits de Windows. À la place, installez FreeGLUT, qui fournit un binaire 64 bits.

Depuis la page FreeGLUT Martin Payne's Windows binaries (MSVC and MinGW) Suivez le lien, Download freeglut 3.0.0 for MSVC Téléchargez freeglut-MSVC-3.0.0-2.mp.zip depuis.

Copiez freeglut.dll de freeglut \ bin \ x64 \ dans le fichier zip vers C: \ Windows \ System32.

Vous pouvez maintenant utiliser GLUT.

Installation de ffmpeg

Pour l'installation de ffmpeg, je me suis référé à cet article.

• [Window] Procédure d'installation de FFmpeg

En gros, déposez simplement le fichier ʻexe, enregistrez-le, ajoutez-le à Path et faites-le reconnaître. L'article ci-dessus est un exemple utilisé à l'invite de commande, mais comme j'utilise Git Bash cette fois, j'ai ajouté le chemin vers .bashrc` comme suit.

export PATH=$PATH:/path/to/bin/ffmpeg

Corriger le fichier Python

Comme mentionné dans cet article auquel j'ai fait référence, j'ai toujours une erreur même après avoir terminé la configuration ci-dessus. L'erreur qui s'est produite est la suivante.

Traceback (most recent call last):
  File "C:\Users\[USER_NAME]\anaconda3\envs\pifu\lib\runpy.py", line 193, in _run_module_as_main
    "__main__", mod_spec)
  File "C:\Users\[USER_NAME]\anaconda3\envs\pifu\lib\runpy.py", line 85, in _run_code
    exec(code, run_globals)
  File "D:\MyDesktop\Python-Projects\pifuhd\apps\render_turntable.py", line 69, in <module>
    renderer = ColorRender(width=args.width, height=args.height)
  File "D:\MyDesktop\Python-Projects\pifuhd\lib\render\gl\color_render.py", line 34, in __init__
    CamRender.__init__(self, width, height, name, program_files=program_files)
  File "D:\MyDesktop\Python-Projects\pifuhd\lib\render\gl\cam_render.py", line 32, in __init__
    Render.__init__(self, width, height, name, program_files, color_size, ms_rate)
  File "D:\MyDesktop\Python-Projects\pifuhd\lib\render\gl\render.py", line 45, in __init__
    _glut_window = glutCreateWindow("My Render.")
  File "C:\Users\[USER_NAME]\anaconda3\envs\pifu\lib\site-packages\OpenGL\GLUT\special.py", line 73, in glutCreateWindow
    return __glutCreateWindowWithExit(title, _exitfunc)
ctypes.ArgumentError: argument 1: <class 'TypeError'>: wrong type

Si vous vous référez à l'article ci-dessus, cela semble être résolu en réécrivant la partie suivante dans lib / render / gl / render.py.

class Render:
    def __init__(self, width=1600, height=1200, name='GL Renderer',
                 program_files=['simple.fs', 'simple.vs'], color_size=1, ms_rate=1):
        self.width = width
        self.height = height
        self.name = name
        self.display_mode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH
        self.use_inverse_depth = False

        global _glut_window
        if _glut_window is None:
            glutInit()
            glutInitDisplayMode(self.display_mode)
            glutInitWindowSize(self.width, self.height)
            glutInitWindowPosition(0, 0)
            #Pour spécifier la chaîne d'argument`b`Ajouter
            #_glut_window = glutCreateWindow("My Render.")
            _glut_window = glutCreateWindow(b"My Render.")

Exécutez la démo et affichez les résultats

Eh bien, c'est vraiment la configuration. Tout ce que vous avez à faire maintenant est d'exécuter le script de démonstration fourni.

bash ./scripts/demo.sh

Lorsque ceci est exécuté, la sortie vidéo de la photo d'exemple sera affichée comme indiqué ci-dessous.

Au fait, voici la photo qui a servi de base à la génération de ce modèle ↓

Générez un maillage avec votre propre photo

Jetons d'abord un coup d'œil au script Shell utilisé pour générer le maillage.

# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.

python -m apps.simple_test
# python apps/clean_mesh.py -f ./results/pifuhd_final/recon
python -m apps.render_turntable -f ./results/pifuhd_final/recon -ww 512 -hh 512

C'est tout ce qu'on peut en dire. L'un a commenté, mais c'est probablement s'il faut effacer le maillage précédemment généré, etc.

En regardant le premier processus (ʻapps / simple_test.py`), j'ai défini quelques paramètres.

# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.


from .recon import reconWrapper
import argparse


###############################################################################################
##                   Setting
###############################################################################################
parser = argparse.ArgumentParser()
parser.add_argument('-i', '--input_path', type=str, default='./sample_images')
parser.add_argument('-o', '--out_path', type=str, default='./results')
parser.add_argument('-c', '--ckpt_path', type=str, default='./checkpoints/pifuhd.pt')
parser.add_argument('-r', '--resolution', type=int, default=512)
parser.add_argument('--use_rect', action='store_true', help='use rectangle for cropping')
args = parser.parse_args()
###############################################################################################
##                   Upper PIFu
###############################################################################################

resolution = str(args.resolution)

start_id = -1
end_id = -1
cmd = ['--dataroot', args.input_path, '--results_path', args.out_path,\
       '--loadSize', '1024', '--resolution', resolution, '--load_netMR_checkpoint_path', \
       args.ckpt_path,\
       '--start_id', '%d' % start_id, '--end_id', '%d' % end_id]
reconWrapper(cmd, args.use_rect)

Les éléments de réglage sont l'emplacement des données d'entrée, l'emplacement des données de sortie, la résolution, etc.

En regardant l'entrée, il semble que les images du dossier . / Sample_images soient utilisées. Donc, j'ai placé l'image que je veux générer un maillage là-bas et l'ai exécutée.

Cliquez ici pour les résultats.

Vous pouvez le générer normalement. (L'image d'origine a été récupérée, je ne la publierai donc pas ici.)

Il a été confirmé qu'il peut être généré normalement même s'il n'est pas inclus à l'origine.

Out of Memory ne génère pas de maillage

Je n'ai rencontré ce problème que quelques fois, mais lorsque j'ai essayé de générer des maillages, j'ai eu un problème en raison de l'interruption de la génération du maillage en raison d'une erreur CUDA Out of Memory.

Il y a peut-être un moyen normal de libérer la mémoire, mais j'ai pu le résoudre en effectuant une fois $ conda deactivate. (Une fois que vous l'avez fait, il n'y a plus d'erreur de mémoire après cela ... mystère)

Si vous le rencontrez, essayez-le.

Environnement de génération réussi

En référence à cet article, je publierai l'environnement d'Anaconda qui a réussi à sortir PI FuHD.

• Comment enregistrer et reconstruire l'environnement conda

<détails>

<details>

Ce qui précède est écrit avec la commande suivante.

```console
$ conda list --explicit > env_name.txt

$ conda create -n [env_name] --file env_name.txt