[PYTHON] Führen Sie PIFuHD in der Windows + Anaconda + Git Bash-Umgebung aus

Überblick

Ich habe ein Deep Learning-Modell namens PIFuHD ausprobiert, das aus einem (oder mehreren) Fotos ein dreidimensionales Netz generiert. Dies ist also ein Memo. Es ist ein Memo, weil ich süchtig danach war, es in einer Windows-Umgebung auszuführen.

Wenn Sie das auf GitHub veröffentlichte Video zitieren, können Sie Folgendes tun:

• facebookresearch/pifuhd - GitHub

Umgebung

Diese Umgebung verwendet Anaconda. (PIFuHD verwendet Python, daher ist eine Python-Umgebung erforderlich.)

Normalerweise ist bei der Installation von Anaconda auch eine grafische Benutzeroberfläche enthalten, sodass Sie die Umgebung dort einstellen können. Von dort aus können Sie auch ein Terminal mit eingerichteter Anaconda-Umgebung starten. Sie müssen also lediglich ein Python-Skript über die Befehlszeile ausführen.

Wenn ich jedoch verschiedene Deep Learning-Modelle ausprobiere, gibt es immer Momente, in denen ich mit Shell-Skripten arbeite. Natürlich kann es nicht über die Windows-Eingabeaufforderung ausgeführt werden.

Daher möchte ich dieses Mal die Verwendung von Anaconda (Befehl conda) auch in der Bash-Umgebung von Git für Windows einrichten. (Wenn Sie nur die PIFuHD-Demo ausprobieren möchten, müssen Sie nur einige Befehle in .sh selbst eingeben, daher kann ich nicht sagen, dass dies nicht erforderlich ist.)

Konfigurieren Sie nach der Installation von Anaconda den Befehl conda so, dass er auf Git für Windows verfügbar ist.

Installieren Sie Anaconda

Installieren Sie zuerst Anaconda. Klicken Sie auf der Anaconda-Seite auf die Schaltfläche "Erste Schritte" und dann auf "Anaconda Individual Edition installieren" **, um zur Download-Seite (https://www.anaconda.com/products/individual) zu springen.

Auf der Download-Seite befindet sich eine Schaltfläche ** Herunterladen **. Klicken Sie darauf, um zum Download-Link unten auf der Seite zu blättern. Wählen Sie dort ** 64-Bit-Grafikinstallationsprogramm ** aus, um das Installationsprogramm und Anaconda herunterzuladen Installieren.

Durch den Weg

Übergeben Sie nach Abschluss der Installation den Pfad, damit Bash ihn erkennt. Dann wird der Befehl "conda" selbst erkannt.

In meiner Umgebung habe ich Folgendes zu .basahrc hinzugefügt.

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

Bitte schreiben Sie entsprechend dem Installationsort neu. Wenn Sie die Standardeinstellung beibehalten, können Sie dieselbe wie oben verwenden.

Ich erhalte eine Fehlermeldung mit "conda enabled"

Als ich nach dem Durchlaufen von Path versuchte, die Anaconda-Umgebung zu aktivieren und "$ conda enable" ausführte, trat der folgende Fehler auf.

$ 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'.

Ich habe es unter Bezugnahme auf den folgenden Artikel gelöst.

• Visual Studio-Code + Anaconda + git bash hat eine Python-Umgebung vorbereitet, mit der Linux-Befehle auch unter Windows verwendet werden können (2020/03/10)

Anscheinend ist es ein Problem, denn wenn ich "conda init" starte, wird das, was automatisch geschrieben wird, nicht geschrieben. Durch manuelles Hinzufügen des Folgenden zu ".bashrc" wird "conda" erkannt und kann sicher unter Bash of Git für Windows verwendet werden.

# >>> 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 <<<

Wenn Sie dies hinzufügen und dann "$ source ~ / .bashrc" ausführen oder das Terminal neu starten, können Sie "$ conda activ [ENV_NAME]" ausführen. Wenn die Umgebung erfolgreich angewendet wurde, sollte der Umgebungsname in der Eingabeaufforderung angezeigt werden.

Setup für PIFuHD

Nachdem wir die Umgebung für Anaconda erstellt haben, werden wir uns für PIFU HD einrichten. Die GitHub-README-Datei gibt Folgendes an, daher richten wir sie so ein, dass sie verwendet werden können.

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

Das manuelle Setup wird übrigens in der README-Datei von Repository der Version ohne HD wie folgt beschrieben, daher habe ich es unter Bezugnahme darauf eingerichtet. (Ich habe auf den Teil ** ODER manuelle Einrichtung der Umgebung ** verwiesen. ** Ich habe nicht auf den obigen Teil verwiesen, weil ich Miniconda ** verwende.)

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

Installieren Sie zusätzliche erforderliche Module

Zusätzlich zu den oben genannten habe ich auch die folgenden Elemente installiert. (Es ist in der README von PIFuHD geschrieben)

• trimesh
• PyOpenGL
• freeglut

Installieren Sie jedes wie folgt.

$ conda install -c conda-forge trimesh

$ conda install -c anaconda pyopengl

Installieren Sie GLUT unter Windows

Als ich versuchte, das Beispiel ohne Installation von GLUT auszuführen, trat der folgende Fehler auf.

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

Dies ist ein Fehler, da kein GLUT vorhanden ist. Ich wusste jedoch nicht, wie ich es installieren sollte, und dieser Artikel half mir.

• Ich habe vorerst versucht, PIFuHD unter Windows auszuführen - Qiita

In diesem Artikel wird geschrieben, dass es durch Bezugnahme auf einen anderen Artikel behoben wurde. Klicken Sie hier für einen weiteren Artikel (Verwenden von OpenGL mit Python in Windows-Tadao Yamaokas Tagebuch)

Lassen Sie mich daraus zitieren

Kostenlose GLUT-Installation

Sie müssen GLUT separat von PyOpenGL installieren. GLUT scheint eine plattformunabhängige Bibliothek für den Umgang mit OpenGL zu sein.

Original GLUT kann die 64-Bit-Binärdatei von Windows nicht herunterladen. Installieren Sie stattdessen FreeGLUT, das eine 64-Bit-Binärdatei bereitstellt.

Von der Seite FreeGLUT Martin Payne's Windows binaries (MSVC and MinGW) Folge dem Link, Download freeglut 3.0.0 for MSVC Laden Sie freeglut-MSVC-3.0.0-2.mp.zip von herunter.

Kopieren Sie die Datei freeglut.dll aus freeglut \ bin \ x64 \ in der Zip-Datei nach C: \ Windows \ System32.

Jetzt können Sie GLUT verwenden.

Fmpeg installieren

Für die Installation von ffmpeg habe ich auf diesen Artikel verwiesen.

• [Fenster] FFmpeg-Installationsverfahren

Legen Sie einfach die exe-Datei ab, speichern Sie sie, fügen Sie sie dem Pfad hinzu und lassen Sie sie erkennen. Der obige Artikel ist ein Beispiel, das an der Eingabeaufforderung verwendet wird. Da ich diesmal Git Bash verwende, habe ich den Pfad zu ".bashrc" wie folgt hinzugefügt.

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

Python-Datei reparieren

Wie in diesem Artikel erwähnt, auf den ich mich bezog, wurde auch nach Abschluss des obigen Setups immer noch ein Fehler angezeigt. Der aufgetretene Fehler ist wie folgt.

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

Wenn Sie sich auf den obigen Artikel beziehen, scheint dies gelöst zu sein, indem Sie den folgenden Teil in "lib / render / gl / render.py" umschreiben.

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)
            #Angabe der Argumentzeichenfolge`b`Hinzufügen
            #_glut_window = glutCreateWindow("My Render.")
            _glut_window = glutCreateWindow(b"My Render.")

Führen Sie die Demo aus und geben Sie die Ergebnisse aus

Nun, das ist wirklich das Setup. Jetzt müssen Sie nur noch das bereitgestellte Demoskript ausführen.

bash ./scripts/demo.sh

Wenn dies ausgeführt wird, wird die Videoausgabe des Beispielfotos wie unten gezeigt angezeigt.

Hier ist übrigens das Foto, auf dem dieses Modell erstellt wurde ↓

Generieren Sie ein Netz mit Ihrem eigenen Foto

Schauen wir uns zunächst das Shell-Skript an, mit dem das Netz generiert wurde.

# 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

Das ist alles dazu. Einer kommentierte aus, aber dies ist wahrscheinlich, ob das zuvor erzeugte Netz usw. gelöscht werden soll.

Beim ersten Prozess (apps / simple_test.py) habe ich einige Parameter eingestellt.

# 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)

Die Einstellungselemente sind der Ort der Eingabedaten, der Ort der Ausgabedaten, die Auflösung usw.

Bei Betrachtung der Eingabe scheinen die Bilder im Ordner . / Sample_images verwendet zu werden. Also habe ich das Bild, das ich erzeugen möchte, dort platziert und ausgeführt.

Klicken Sie hier für die Ergebnisse.

Sie können es normal generieren. (Das Originalbild wurde aufgenommen, daher werde ich es hier nicht veröffentlichen.)

Es wurde bestätigt, dass es normal generiert werden kann, auch wenn es ursprünglich nicht enthalten ist.

Nicht genügend Speicher erzeugt kein Netz

Ich bin nur ein paar Mal auf dieses Problem gestoßen, aber als ich versuchte, einige Netze zu generieren, hatte ich das Problem, dass die Netzgenerierung aufgrund eines CUDA-Speichermangels unterbrochen wurde.

Es mag einen normalen Weg geben, den Speicher freizugeben, aber ich konnte ihn lösen, indem ich einmal "$ conda disable" machte. (Sobald Sie es tun, gibt es keinen Speicherfehler danach ... Rätsel)

Wenn Sie darauf stoßen, probieren Sie es aus.

Erfolgreiche Generierungsumgebung

In Bezug auf diesen Artikel werde ich die Umgebung von Anaconda veröffentlichen, in der PI FuHD erfolgreich ausgegeben werden konnte.

• Speichern und Wiederherstellen der Conda-Umgebung

$ conda list --explicit > env_name.txt

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