À propos de la gestion de projet de deep learning (DNN)

introduction

Je fais des recherches en utilisant DNN.

Au bout d'un an, je sens que j'ai enfin trouvé la meilleure pratique de gestion de projet, je vais donc l'exposer.

environnement

• Apprentissage et inférence DNN en utilisant Python + PyTorch
• Entrez le serveur informatique (Ubuntu) avec SSH et exécutez le programme. (Le PC principal est Windows)
• Utilisez Onedrive et GitHub ensemble pour la synchronisation de fichiers avec le serveur informatique

Depuis Onedrive est une assurance lorsqu'un fichier est soudainement explosé, je pense que GitHub est fondamentalement suffisant.

Structure du répertoire

program/
  ├ dataset/
  │   ├ dev/
  │   └ test/
  └ src/
      ├ common/
      │   ├ hoge.py
      │   ├ fuga.py
      │   ├ ...
      ├ method_xxx/
      │   ├ output/
      │   │   ├ YYYYMMDD_ID/
      │   │   │  ├ loss/
      │   │   │  │   ├ training_loss.npy
      │   │   │  │   └ validation_loss.npy
      │   │   │  ├ prediction/
      │   │   │  │   ├ img/
      │   │   │  │   ├ wav/
      │   │   │  │   ├ ...
      │   │   │  ├ condition.json
      │   │   │  ├ model.pth
      │   │   │  └ network.txt
      │   │   ├ YYYYMMDD_ID/
      │   │   ├ ...
      │   ├ generate_dataset.py
      │   ├ dataset_loader.py
      │   ├ dnn_model.py
      │   ├ dnn_training.py
      │   ├ dnn_evaluation.py
      │   ├ training_config.json
      │   └ evaluation_config.json
      ├ method_zzz/
      ├　...

Description de chaque dossier / fichier

• method_xxx / method_zzz: Les modèles DNN et les ensembles de données sont créés de différentes manières, donc les dossiers sont créés en conséquence.
• common: contient les modules couramment utilisés par chaque méthode.
• method_xxx / output /: Le résultat d'apprentissage et le résultat de l'inférence sont crachés ici.
• Reportez-vous à "Exposing my machine learning project management", et le dossier devient un dossier unique avec un identifiant après la date.
• YYYYMMDD_ID / network.txt: Décrit la structure réseau du modèle créé. L'instance du modèle défini par PyTorch est sortie telle quelle.

Structure du modèle DNN de sortie

class Model(nn.Module):
    def __init__(self, in_units, hidden_units, out_units):
        super(Model, self).__init__()
        self.l1 = nn.Linear(in_units, hidden_units)
        self.a1 = nn.ReLU()
        self.l2 = nn.Linear(hidden_units, hidden_units)
        self.a2 = nn.ReLU()

    def forward(self, x):
        x = self.a1(self.l1(x))
        y = self.a2(self.l2(x))

        return y

#Exporter les informations réseau pour le modèle DNN(.txt)
model = Model(in_size, hidden_size, out_size)
with open(OUT_DIR_NAME+'/network.txt', 'w') as f:
    f.write(str(model))

network.txt

Model(
  (l1): Linear(in_features=8546, out_features=682, bias=True)
  (a1): ReLU()
  (l2): Linear(in_features=682, out_features=682, bias=True)
  (a2): ReLU()
)

À propos des fichiers JSON

Les réglages des paramètres d'apprentissage, l'évaluation du modèle et les résultats expérimentaux sont gérés dans un fichier json. Le contenu de chacun est le suivant.

training_config.json

{
    "method": "Une explication détaillée de la méthode est décrite ici.",
    "parameters": {
        "max_epochs": 1000,
        "batch_size": 128,
        "optimizer": "adam",
        "learning_rate": 0.001,
        "patience": 50,
        "norm": true
    },
    "datasets": {
        "data1": "../../dataset/dev/<file1_name>",
        "data2": "../../dataset/dev/<file2_name>"
    }
}

evaluation_config.json

{
    "target_dir": "YYYYMMDD_ID",
    "src_dir": {
        "file1": "../../dataset/test/<file1_name>",
        "file2": "../../dataset/test/<file2_name>"
    },
    "output_dir": "OUTPUT_DIR_NAME"
}

condition.json

{
    "method": "Explication de la méthode",
    "parameters": {
        "max_epochs": 345,
        "batch_size": 128,
        "optimizer": "adam",
        "learning_rate": 0.001,
        "patience": 50,
        "norm": true
    },
    "datasets": {
        "data1": "../../dataset/dev/<file1_name>",
        "data2": "../../dataset/dev/<file1_name>",
    },
    "dnn": {
        "input_size": 8546,
        "output_size": 682
    },
    "loss": {
        "training_loss": 0.087654,
        "validation_loss": 0.152140
    }
}

Pour l'évaluation des performances DNN, ʻevaluation.json est lu en premier, le dossier cible est spécifié à partir de rép_cible, et les paramètres etc. sont acquis à partir de condition.json` qui s'y trouve.

la fin

Après quelques rebondissements, je me suis installé sur ce genre de méthode de gestion, mais dites-moi s'il existe une meilleure méthode de gestion ...