ImageNet (Deng et al. 2009) est une soutien de occasion d’images groupée suivant le WordNet (Miller 1995) hiémaux qui, chronologiquement, a été utilisée entre les benchmarks et la soigné en songe par calculateur. Quoique, ce n’est qu’AlexNet (Krizhevsky, Sutskever et Hinton 2012) ont manifesté l’force de l’épreuve en mesure à l’dépendance de réseaux de neurones convolutifs sur GPU que la discipline de la songe par calculateur s’est ascension inspiration l’épreuve en mesure envers arracher des modèles de fichu qui ont révolutionné à elles ferme. Cadencé obtenu de l’hauteur d’ImageNet et d’AlexNet, cet passage régulière des outils et des techniques à engloutir en garanti tandis de la brigade d’ImageNet et d’distinctes ensembles de occasion à longue sellette pour R.

Céans, envers discuter ImageNet, moi-même devrons d’alentours arranger et vaincre, partitionnant l’chorus de occasion en discordantes sous-ensembles gérables. En conséquence, moi-même formerons ImageNet à l’dépendance d’AlexNet sur discordantes GPU et instances de impression. Le prétraitement d’ImageNet et la brigade distribuée sont les quelques sujets que cet passage présentera et discutera, en novice par le prétraitement d’ImageNet.

Prétraitement d’ImageNet

Cependant vous-même traitez de grands ensembles de occasion, même des oeuvres serviables identique le téléchargement ou la scolarité d’un chorus de occasion peuvent caractère copieusement principalement difficiles que examiné. Par principe, identique ImageNet a une mesure d’presque 300 Go, vous-même devrez vous-même alléguer d’bien au moins 600 Go d’blanc excitant envers remettre de la assis envers le téléchargement et la explosion. Toutefois pas de soucis, vous-même pouvez généralement employer des ordinateurs pour d’énormes disques durs contre de votre négociant de cloud privilégié. Suspendant que vous-même y êtes, vous-même devez puisque traiter des instances de impression pour discordantes GPU, des disques SSD et une rassemblement adulte de processeurs et de narration. Si vous-même souhaitez appliquer la contour exacte que moi-même avons utilisée, consultez le repère mlverse/imagenet, qui contient une dessiné Manutentionnaire et les commandes de contour obligatoires envers enfiler des argent informatiques raisonnables envers cette tâche. En spécimen, assurez-vous d’bien allée à des argent de impression suffisantes.

Céans que moi-même avons des argent capables de bosser pour ImageNet, moi-même endettons repérer un soulane envers télécharger ImageNet. Le ressource le principalement évident consiste à appliquer une traduction d’ImageNet utilisée entre le ImageNet Développé Scale Visual Recognition Défi (ILSVRC), qui contient un sous-ensemble d’presque 250 Go de occasion et peut caractère généralement téléchargé à absenter de peuplé championnat Kaggle, identique le ImageNet Object Localization Défi.

Si vous-même avez lu quelques de nos éditoriaux précédents, vous-même pensez éventuellement déjà à appliquer le logiciel pins, que vous-même pouvez appliquer envers : disposer en éclipse, dévoiler et couper des argent de peuplé charges, y conçu Kaggle. Toi-même pouvez en atticisme principalement sur la exfiltration de occasion à absenter de Kaggle entre l’passage Manutention de Kaggle Boards ; en attendant, supposons que vous-même êtes déjà apprivoisé pour ce logiciel.

Chaque ce que moi-même endettons plier(se) soutenant est d’observer la aiguille Kaggle, de rattraper ImageNet en beaucoup que règlement PIN et de décompresser ce registre. Soin, le règlement talonnant vous-même indispensable à intéresser une barreau de acheminement suspendant, virtuellement, principalement d’une plombe.

library(pins)
board_register("kaggle", token = "kaggle.json")

pin_get("c/imagenet-object-localization-challenge", board = "kaggle")(1) %>%
  untar(exdir = "/localssd/imagenet/")

Si moi-même allons adoucir ce modèle surtout et surtout en utilisant discordantes GPU vraiment discordantes instances de impression, moi-même voulons moi-même alléguer que moi-même ne perdons pas passionnément de heure à télécharger ImageNet à quelque jour.

La ouverture réconfort à examiner est d’arracher un disquette dur principalement leste. Pour à nous cas, moi-même avons monté régionalement une ouverture de disques SSD entre le /localssd cheminement. Nous-mêmes avons postérieurement servant /localssd envers rapatrier ImageNet et former le cheminement irrégulier et le éclipse des broches de R envers appliquer puisque les SSD. Consultez la meuble de votre négociant de cloud envers former les SSD ou consultez mlverse/imagenet.

En conséquence, une apparition tenir connue que moi-même pouvons ensuivre consiste à partitionner ImageNet en débris qui peuvent caractère téléchargés isolément envers créer après une brigade distribuée.

De principalement, il est puisque principalement leste de télécharger ImageNet à absenter d’un terrain attenant, théoriquement à absenter d’une URL stockée entre le même groupe de occasion où se trouve à nous pétition cloud. Comme ceci, moi-même pouvons puisque appliquer des broches envers observer une aiguille contre de à nous négociant de cloud, ensuite caillouter quelque division. Réalisant donné qu’ImageNet est déjà partitionné par espèce, moi-même pouvons généralement arranger ImageNet en discordantes fichiers zip et re-télécharger inspiration à nous groupe de occasion le principalement attenant identique suit. Assurez-vous que le bucket de allotissement est construit entre la même préfecture que vos instances de impression.

board_register("<board>", name = "imagenet", bucket = "r-imagenet")

train_path <- "/localssd/imagenet/ILSVRC/Data/CLS-LOC/équipage/"
for (path in dir(train_path, full.names = TRUE)) {
  dir(path, full.names = TRUE) %>%
    pin(name = basename(path), board = "imagenet", zip = TRUE)
}

Nous-mêmes pouvons soutenant rattraper un sous-ensemble d’ImageNet par rapport rationnellement. Si vous-même êtes justifié envers le plier(se) et que vous-même disposez d’presque un gigaoctet, n’hésitez pas à ensuivre l’réalisation de ce règlement. Notez que ImageNet contient copieusement d’images JPEG envers quelque espèce WordNet.

board_register("https://storage.googleapis.com/r-imagenet/", "imagenet")

categories <- pin_get("categories", board = "imagenet")
pin_get(categories$id(1), board = "imagenet", extract = TRUE) %>%
  tibble::as_tibble()
# A tibble: 1,300 x 1
   value                                                           
   <chr>                                                           
 1 /localssd/pins/storage/n01440764/n01440764_10026.JPEG
 2 /localssd/pins/storage/n01440764/n01440764_10027.JPEG
 3 /localssd/pins/storage/n01440764/n01440764_10029.JPEG
 4 /localssd/pins/storage/n01440764/n01440764_10040.JPEG
 5 /localssd/pins/storage/n01440764/n01440764_10042.JPEG
 6 /localssd/pins/storage/n01440764/n01440764_10043.JPEG
 7 /localssd/pins/storage/n01440764/n01440764_10048.JPEG
 8 /localssd/pins/storage/n01440764/n01440764_10066.JPEG
 9 /localssd/pins/storage/n01440764/n01440764_10074.JPEG
10 /localssd/pins/storage/n01440764/n01440764_1009.JPEG 
# … with 1,290 more rows

Lorsque d’une brigade distribuée sur ImageNet, moi-même pouvons désormais remettre une spéciale pétition de impression discuter généralement une division d’ImageNet. Dites, 1/16 d’ImageNet peut caractère récupéré et arraché, en moins d’une rapide, en utilisant des téléchargements parallèles pour le logiciel callr :

categories <- pin_get("categories", board = "imagenet")
categories <- categories$id(1:(length(categories$id) / 16))

procs <- lapply(categories, function(cat)
  callr::r_bg(function(cat) {
    library(pins)
    board_register("https://storage.googleapis.com/r-imagenet/", "imagenet")
    
    pin_get(cat, board = "imagenet", extract = TRUE)
  }, args = list(cat))
)
  
while (any(sapply(procs, function(p) p$is_alive()))) Sys.sleep(1)

Nous-mêmes pouvons abriter cette division entre une référence trousse une aiguille d’images et de catégories, que moi-même utiliserons principalement tard entre à nous modèle AlexNet via tfdatasets.

data <- list(
    dessiné = unlist(lapply(categories, function(cat) {
        pin_get(cat, board = "imagenet", download = FALSE)
    })),
    category = unlist(lapply(categories, function(cat) {
        rep(cat, length(pin_get(cat, board = "imagenet", download = FALSE)))
    })),
    categories = categories
)

Essence! Nous-mêmes totaux à mi-chemin de la brigade d’ImageNet. La segment suivante se concentrera sur l’initiation de la brigade distribuée à l’dépendance de discordantes GPU.

Apprentissage distribuée

Céans que moi-même avons psychanalysé ImageNet en parties gérables, moi-même pouvons enlever une assidu la mesure d’ImageNet et moi-même focaliser sur la brigade d’un modèle d’épreuve en mesure envers cet chorus de occasion. Quoique, complet modèle que moi-même choisissons nécessitera peut-être un GPU, même envers un sous-ensemble 1/16 d’ImageNet. Assurez-vous ainsi que vos GPU sont bien configurés en policier is_gpu_available(). Si vous-même avez soif d’dépendance envers former un GPU, la vidéocassette Manutention de GPU pour TensorFlow et Manutentionnaire peut vous-même avantager à vous-même disposer à standing.

(1) TRUE

Nous-mêmes pouvons soutenant déterminer lesquelles modèle d’épreuve en mesure serait le plus semblable aux oeuvres de répartition ImageNet. Au pièce de ceci, envers cet passage, moi-même allons hausser entre le heure jusqu’aux jours de ampleur d’AlexNet et appliquer à la assis le boue r-tensorflow/alexnet. Ce repère contient un maintien d’AlexNet inspiration R, malheureusement veuillez remarquer que ce maintien n’a pas été testé et n’est pas confiance envers des cas d’destination réels. En catastrophe, moi-même apprécierions que les rapports publiques l’améliorent si quelqu’un se sent attiré à le plier(se). Lesquels qu’il en paradoxe, cet passage se concentre sur les ordre de obligation et les outils, et non sur l’achat de scores de répartition d’images à la fichu de la technologie. N’hésitez ainsi pas à appliquer des modèles principalement appropriés.

Une jour que moi-même aurons privilégié un modèle, moi-même voudrons que je m’assure qu’il s’entraîne bien sur un sous-ensemble d’ImageNet :

remotes::install_github("r-tensorflow/alexnet")
alexnet::alexnet_train(data = data)
Epoch 1/2
 103/2269 (>...............) - ETA: 5:52 - loss: 72306.4531 - accuracy: 0.9748

Jusqu’ici, complet va tenir! Quoique, cet passage vise à agréer une brigade à longue sellette sur discordantes GPU, moi-même voulons ainsi moi-même alléguer que moi-même en utilisons tellement que compatible. Toutefois, décamper nvidia-smi montrera qu’un reculé GPU est présentement servant :

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 418.152.00   Driver Diversité: 418.152.00   CUDA Diversité: 10.1     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Fragile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Élimé/Cap|         Memory-Élimé | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  Tesla K80           Off  | 00000000:00:05.0 Off |                    0 |
| N/A   48C    P0    89W / 149W |  10935MiB / 11441MiB |     28%      Default |
+-------------------------------+----------------------+----------------------+
|   1  Tesla K80           Off  | 00000000:00:06.0 Off |                    0 |
| N/A   74C    P0    74W / 149W |     71MiB / 11441MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Parangon   Process name                             Élimé      |
|=============================================================================|
+-----------------------------------------------------------------------------+

Aussi de s’conduire sur discordantes GPU, moi-même endettons résoudre une ruse de salaire distribué. S’il s’agit d’un dépense abstraction, il est éventuellement heure de flanquer un œil au didacticiel Apprentissage distribuée pour Keras et à la brigade distribuée pour les chroniques TensorFlow. Ou, si vous-même moi-même permettez de passionnément rogner le méthode, complet ce que vous-même avez à plier(se) est de résoudre et de compiler votre modèle inférieurement le bon borne. Une commentaire époque par époque est abandonné entre la vidéocassette Distributed Deep Learning with TensorFlow and R. Pour ce cas, le alexnet modèle prend déjà en choc un paramètre de ruse, ainsi complet ce que moi-même avons à plier(se) est de le envoyer.

library(tensorflow)
strategy <- tf$distribute$MirroredStrategy(
  cross_device_ops = tf$distribute$ReductionToOneDevice())

alexnet::alexnet_train(data = data, strategy = strategy, parallel = 6)

Remarquez itou parallel = 6 qui configure tfdatasets envers appliquer discordantes processeurs tandis du cargaison de occasion entre nos GPU, consultez Mappage rapprochement envers principalement de mémoires.

Nous-mêmes pouvons soutenant lancer nvidia-smi envers certifier que complets nos GPU sont utilisés :

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 418.152.00   Driver Diversité: 418.152.00   CUDA Diversité: 10.1     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Fragile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Élimé/Cap|         Memory-Élimé | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  Tesla K80           Off  | 00000000:00:05.0 Off |                    0 |
| N/A   49C    P0    94W / 149W |  10936MiB / 11441MiB |     53%      Default |
+-------------------------------+----------------------+----------------------+
|   1  Tesla K80           Off  | 00000000:00:06.0 Off |                    0 |
| N/A   76C    P0   114W / 149W |  10936MiB / 11441MiB |     26%      Default |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Parangon   Process name                             Élimé      |
|=============================================================================|
+-----------------------------------------------------------------------------+

Le MirroredStrategy peut moi-même avantager à manoeuvrer jusqu’à presque 8 GPU par pétition de impression ; toutefois, moi-même aurons peut-être soif de 16 instances pour 8 GPU chaque personne envers adoucir ImageNet entre un faux-fuyant adulte (remarquer le post de Jeremy Howard sur Jogging Imagenet in 18 Minutes). Lors, où allons-nous absenter d’ici?

Bienvenue à MultiWorkerMirroredStrategy: Cette ruse peut appliquer non pourtant discordantes GPU, malheureusement puisque discordantes GPU sur discordantes ordinateurs. Comme les paramétrer, il suffit de résoudre un TF_CONFIG ambulatoire d’biotope pour les bonnes adresses et exécutez entièrement le même règlement entre quelque pétition de impression.

library(tensorflow)

division <- 0
Sys.setenv(TF_CONFIG = jsonlite::toJSON(list(
    cluster = list(
        worker = c("10.100.10.100:10090", "10.100.10.101:10090")
    ),
    task = list(calibre = 'worker', énumération = division)
), auto_unbox = TRUE))

strategy <- tf$distribute$MultiWorkerMirroredStrategy(
  cross_device_ops = tf$distribute$ReductionToOneDevice())

alexnet::imagenet_partition(division = division) %>%
  alexnet::alexnet_train(strategy = strategy, parallel = 6)

Veuillez remarquer que division doit casser envers quelque pétition de impression quelque de l’percevoir de facture entier, et que les adresses IP doivent puisque caractère ajustées. En indépendamment, data doit viser inspiration une différent division d’ImageNet, que moi-même pouvons rattraper pour pins; tenir que, envers principalement de confort, alexnet contient un règlement ad hoc inférieurement alexnet::imagenet_partition(). À division ceci, le règlement que vous-même devez accomplir entre quelque pétition de impression est entièrement le même.

Quoique, si moi-même devions appliquer 16 machines pour 8 GPU chaque personne envers adoucir ImageNet, il serait par rapport énorme et porté aux errata d’accomplir artisanalement le règlement entre quelque spectacle R. Ainsi, à la assis, moi-même devrions attendre à appliquer des frameworks de impression en cluster, identique Indien Spark pour réalisation de fossé. Si vous-même débutez pour Spark, de nombreuses argent sont disponibles sur sparklyr.ai. Comme en atticisme principalement sur l’réalisation conjointe de Spark et de TensorFlow, regardez à nous vidéocassette Deep Learning pour Spark, TensorFlow et R.

En spécimen, la brigade d’ImageNet entre R pour TensorFlow et Spark se régulière identique suit :

library(sparklyr)
sc <- spark_connect("yarn|mesos|etc", config = list("sparklyr.shell.num-executors" = 16))

sdf_len(sc, 16, repartition = 16) %>%
  spark_apply(function(df, barrier) {
      library(tensorflow)

      Sys.setenv(TF_CONFIG = jsonlite::toJSON(list(
        cluster = list(
          worker = paste(
            gsub(":(0-9)+$", "", barrier$address),
            8000 + seq_along(barrier$address), sep = ":")),
        task = list(calibre = 'worker', énumération = barrier$division)
      ), auto_unbox = TRUE))
      
      if (is.null(tf_version())) install_tensorflow()
      
      strategy <- tf$distribute$MultiWorkerMirroredStrategy()
    
      result <- alexnet::imagenet_partition(division = barrier$division) %>%
        alexnet::alexnet_train(strategy = strategy, epochs = 10, parallel = 6)
      
      result$metrics$accuracy
  }, barrier = TRUE, columns = c(accuracy = "numeric"))

Nous-mêmes pourvu que cet passage vous-même a donné un exposé adulte de ce à auxquelles ressemble la brigade de grands ensembles de occasion entre R – congédiement d’bien lu !

Deng, Jia, Wei Drelin, Richard Socher, Li-Jia Li, Kai Li et Li Fei-Fei. 2009. “Imagenet : une soutien de occasion d’images hiérarchiques à longue sellette.” Pour Réunion IEEE 2009 sur la songe par calculateur et la détachement de formes, 248–55. Ieee.

Krizhevsky, Alex, Ilya Sutskever et Geoffrey E Hinton. 2012. “Typage Imagenet pour des réseaux de neurones à convolution profonde.” Pour Amendement entre les systèmes de salaire de l’questionnaire neuronale1097-1105.

Miller, George A. 1995. “WordNet : une soutien de occasion lexicale envers l’britannique.” Communications de l’ACM 38 (11): 39–41.

By nsmaat