Plugin import keras

.gitattributes

@@ -0,0 +1 @@
+* text eol=lf

.gitignore

@@ -30,3 +30,9 @@ node_modules
 tmp/
 blob-local-storage/
 notes/
+
+#IntelliJ
+.idea
+
+#vscode
+.vscode

src/plugins/ImportKeras/ImportKeras.js

@@ -0,0 +1,299 @@
+/*globals define*/
+/*eslint-env node, browser*/
+
+/**
+ * Generated by PluginGenerator 2.20.5 from webgme on Tue Sep 10 2019 15:28:36 GMT-0500 (Central Daylight Time).
+ * A plugin that inherits from the PluginBase. To see source code documentation about available
+ * properties and methods visit %host%/docs/source/PluginBase.html.
+ */
+
+define([
+    'plugin/PluginConfig',
+    'text!./metadata.json',
+    'plugin/PluginBase',
+    './utils/JSONModelMaps',
+    './utils/json-model-parser',
+], function (
+    PluginConfig,
+    pluginMetadata,
+    PluginBase,
+    ModelMaps,
+    JSONLayerParser,
+) {
+    'use strict';
+
+    pluginMetadata = JSON.parse(pluginMetadata);
+
+
+    /**
+     * Initializes a new instance of ImportKeras.
+     * @class
+     * @augments {PluginBase}
+     * @classdesc This class represents the plugin ImportKeras.
+     * @constructor
+     */
+    var ImportKeras = function () {
+        // Call base class' constructor.
+        PluginBase.call(this);
+        this.pluginMetadata = pluginMetadata;
+    };
+
+    /**
+     * Metadata associated with the plugin. Contains id, name, version, description, icon, configStructure etc.
+     * This is also available at the instance at this.pluginMetadata.
+     * @type {object}
+     */
+    ImportKeras.metadata = pluginMetadata;
+
+    // Prototypical inheritance from PluginBase.
+    ImportKeras.prototype = Object.create(PluginBase.prototype);
+    ImportKeras.prototype.constructor = ImportKeras;
+
+    /**
+     * Main function for the plugin to execute. This will perform the execution.
+     * Notes:
+     * - Always log with the provided logger.[error,warning,info,debug].
+     * - Do NOT put any user interaction logic UI, etc. inside this method.
+     * - callback always has to be called even if error happened.
+     *
+     * @param {function(Error|null, plugin.PluginResult)} callback - the result callback
+     */
+    ImportKeras.prototype.main = async function(callback){
+        let srcJsonHash = this.getCurrentConfig().srcModel;
+        if (!srcJsonHash) {
+            callback(new Error('Keras Json Not Provided'), this.result);
+            return;
+        }
+        try {
+            this.archName = this.getCurrentConfig().archName;
+            let metadata = await this.blobClient.getMetadata(srcJsonHash);
+            this.archName = this.archName ? this.archName : metadata.name.replace('.json', '');
+            let modelJson = await this.blobClient.getObjectAsJSON(srcJsonHash);
+            this.modelInfo = JSONLayerParser.flatten(modelJson).config;
+            this.addNewArchitecture();
+            this.addLayers();
+            await this.addConnections();
+            await this.save('Completed Import Model');
+            this.result.setSuccess(true);
+            callback(null, this.result);
+        } catch (err) {
+            this.logger.debug(`Something Went Wrong, Error Message: ${err}`);
+            callback(err, this.result);
+        }
+    };
+
+    ImportKeras.prototype.addNewArchitecture = function () {
+        // Add Architecture
+        this.importedArch = this.core.createNode({
+            parent: this.activeNode,
+            base: this.META.Architecture
+        });
+        const uniqueName = this.archName;
+        this.core.setAttribute(this.importedArch, 'name', uniqueName);
+
+        this.logger.debug(`Added ${uniqueName} as a new architecture.`);
+    };
+
+    // This should add layers. constraints, initializers, regularizers as well as activations to the layer.
+    ImportKeras.prototype.addLayers = function () {
+        let layers = this.modelInfo.layers;
+        let layerToCreate = null;
+        this.layerInfo = {};
+        layers.forEach((layer) => {
+            layerToCreate = this._getMetaTypeForClass(layer.class_name);
+            let layerNode = this.core.createNode({
+                parent: this.importedArch,
+                base: this.META[layerToCreate]
+            });
+            this.logger.debug(`Added ${layerToCreate}\
+            to ${this.core.getAttribute(this.importedArch, 'name')}`);
+
+            // Add all attributes, from the model JSON, as well as from the layers schema
+            this._addLayerAttributes(layerNode, layer);
+            this._addConfigurableNodes(layerNode, layer);
+        });
+    };
+
+    // All the attributes, which do not require a separate node to be created
+    // 1. First find the validAttributeNames for the layer
+    // 2. If the name is in layer, set it.
+    // 3. If the name is in layer.config, set it.
+    // 4. Finally, check the layers schema for remaining attributes.
+    ImportKeras.prototype._addLayerAttributes = function (layerNode, attrObj) {
+        let config = attrObj.config;
+        let validAttributeNamesForThisLayer = this.core.getValidAttributeNames(layerNode);
+        let configKeys = Object.keys(config);
+        let remainingKeys = Object.keys(attrObj)
+            .filter(value => value !== 'config');
+
+        validAttributeNamesForThisLayer.forEach((attribute) => {
+            if (remainingKeys.indexOf(this._jsonConfigToNodeAttr(attribute)) > -1) {
+                this.core.setAttribute(layerNode, attribute, this._toPythonIterable(attrObj[this._jsonConfigToNodeAttr(attribute)]));
+                this.logger.debug(`Set ${attribute} for ${this.core.getGuid(layerNode)}` +
+                    ` to ${this.core.getAttribute(layerNode, attribute)}`);
+            } else if (configKeys.indexOf(this._jsonConfigToNodeAttr(attribute)) > -1) {
+                this.core.setAttribute(layerNode, attribute, this._toPythonIterable(config[this._jsonConfigToNodeAttr(attribute)]));
+                this.logger.debug(`Set ${attribute} for ${this.core.getGuid(layerNode)}` +
+                    ` to ${this.core.getAttribute(layerNode, attribute)}`);
+
+            }
+        });
+        let layerName = this.core.getAttribute(layerNode, 'name');
+        this.layerInfo[layerName] = layerNode;
+
+    };
+
+    ImportKeras.prototype._addConfigurableNodes = function (layerNode, layerConfig) {
+        let allPointerNames = this.core.getValidPointerNames(layerNode);
+        let config = layerConfig.config;
+        this.logger.debug(`Layer ${this.core.getAttribute(layerNode, 'name')}` +
+            ` has following configurable attributes ${allPointerNames.join(', ')}`);
+        allPointerNames.filter(pointer => !!config[pointer])
+            .forEach((pointer) => {
+                if (typeof config[pointer] == 'string') {
+                    this._addStringPropertiesNode(layerNode, config, pointer);
+                } else {
+                    this._addPluggableNodes(layerNode, config, pointer);
+                }
+            });
+    };
+
+    ImportKeras.prototype._addStringPropertiesNode = function(layerNode, config, pointer) {
+        let configurableNode = this.core.createNode({
+            parent: layerNode,
+            base: this.META[config[pointer]]
+        });
+        // This will set the necessary pointers.
+        // Of things like activations and so on...
+        this.core.setPointer(layerNode, pointer, configurableNode);
+        this.logger.debug(`Added ${this.core.getAttribute(configurableNode, 'name')}`
+            + ` as ${pointer} to the layer `
+            + `${this.core.getAttribute(layerNode, 'name')}`);
+    };
+
+    ImportKeras.prototype._addPluggableNodes = function (layerNode, config, pointer){
+        let pluggableNode = this.core.createNode({
+            parent: layerNode,
+            base: this.META[config[pointer].class_name]
+        });
+        this.logger.debug(`Added ${this.core.getAttribute(pluggableNode, 'name')} as` +
+            ` ${pointer} to the layer ${this.core.getAttribute(layerNode, 'name')}`);
+        let validArgumentsForThisNode = this.core.getValidAttributeNames(pluggableNode);
+        let configForAddedNode = config[pointer].config;
+        if (validArgumentsForThisNode && configForAddedNode) {
+            validArgumentsForThisNode.forEach((arg) => {
+                if (configForAddedNode[arg])
+                    this.core.setAttribute(pluggableNode, arg,
+                        this._toPythonIterable(configForAddedNode[arg]));
+            });
+        }
+    };
+
+    // This method is used to convert javascript arrays to a
+    // tuple/ list(Python) in string Representation. Needed for
+    // Code generation.
+    ImportKeras.prototype._toPythonIterable = function (obj) {
+        if (obj == null) {
+            return 'None';
+        }
+        if (obj instanceof Array) {
+            return '[' + obj.map((val) => {
+                return this._toPythonIterable(val);
+            }).join(', ') + ']';
+        } else {
+            return obj;
+        }
+    };
+
+    // This method is used to convert various classes from the
+    // keras JSON to deepforge meta Nodes
+    ImportKeras.prototype._getMetaTypeForClass = function (kerasClass) {
+        let classMap = ModelMaps.CLASS_MAP;
+        if (Object.keys(classMap).indexOf(kerasClass) > -1) {
+            return classMap[kerasClass];
+        } else {
+            return kerasClass;
+        }
+    };
+
+    // Change the model converts some JSON
+    // layer attributes names (from keras) to the correct
+    // attribute name for deepforge-keras nodes
+    ImportKeras.prototype._jsonConfigToNodeAttr = function (orgName) {
+        let argMap = ModelMaps.ARGUMENTS_MAP;
+        if (Object.keys(argMap).indexOf(orgName) > -1) {
+            return argMap[orgName];
+        } else {
+            return orgName;
+        }
+    };
+
+    /**********************The functions below Add Connections between the Layers**************/
+    ImportKeras.prototype.addConnections = async function () {
+        // this._findNodeByName();
+        let layers = this.modelInfo.layers;
+        let layerInputConnections = {};
+        let layerOutputConnections = {};
+        let connections = null;
+        layers.forEach((layer) => {
+            layerInputConnections[layer.name] = [];
+            layerOutputConnections[layer.name] = [];
+        });
+
+        layers.forEach((layer) => {
+            if (layer.inbound_nodes.length > 0) {
+                connections = layer.inbound_nodes;
+                connections.forEach((connection) => {
+
+                    if (this._layerNameExists(connection)) {
+                        layerInputConnections[layer.name].push(connection);
+                        layerOutputConnections[connection].push(layer.name);
+                    }
+                });
+
+            }
+        });
+
+        await this._updateConnections(layerInputConnections);
+    };
+
+
+    ImportKeras.prototype._layerNameExists = function (layerName) {
+        let allLayerNames = this.modelInfo.layers.map((layer) => {
+            return layer.name;
+        });
+
+        return allLayerNames.indexOf(layerName) > -1;
+    };
+
+    ImportKeras.prototype._updateConnections = function (inputs) {
+        let allLayerNames = Object.keys(inputs);
+        return Promise.all(allLayerNames.map((layerName) => {
+            let dstLayer = this.layerInfo[layerName];
+            let srcs = inputs[layerName];
+            return Promise.all(srcs.map((src, index) => {
+                return this._connectLayers(this.layerInfo[src], dstLayer, index);
+            }));
+        }));
+    };
+
+    ImportKeras.prototype._connectLayers = async function (srcLayer, dstLayer, index) {
+
+        let srcPort = await this.core.loadMembers(srcLayer, 'outputs');
+        let dstPort = await this.core.loadMembers(dstLayer, 'inputs');
+        if (dstPort && srcPort) {
+            this.core.addMember(dstPort[0], 'source', srcPort[0]);
+            this.core.setMemberRegistry(dstPort[0],
+                'source',
+                this.core.getPath(srcPort[0]),
+                'position', {x: 100, y: 100});
+            this.core.setMemberAttribute(dstPort[0], 'source',
+                this.core.getPath(srcPort[0]),
+                'index', index);
+            this.logger.debug(`Connected ${this.core.getAttribute(srcLayer, 'name')} ` +
+                `with ${this.core.getAttribute(dstLayer, 'name')} as input ${index}`);
+        }
+    };
+
+    return ImportKeras;
+});

src/plugins/ImportKeras/metadata.json

@@ -0,0 +1,29 @@
+{
+  "id": "ImportKeras",
+  "name": "ImportKeras",
+  "version": "0.1.0",
+  "description": "",
+  "icon": {
+    "class": "glyphicon glyphicon-download-alt",
+    "src": ""
+  },
+  "disableServerSideExecution": false,
+  "disableBrowserSideExecution": false,
+  "dependencies": [],
+  "writeAccessRequired": false,
+  "configStructure": [{
+    "name": "srcModel",
+    "displayName": "Keras Model JSON File",
+    "description": "The Keras model JSON to import.",
+    "valueType": "asset",
+    "readOnly": false
+  },
+    {
+      "name": "archName",
+      "displayName": "Model Name",
+      "description": "Name of the imported model",
+      "valueType": "string",
+      "readOnly": false
+    }
+  ]
+}

src/plugins/ImportKeras/utils/JSONModelMaps.js

@@ -0,0 +1,26 @@
+/*globals define */
+define([], function() {
+    const ModelMaps = {};
+
+    ModelMaps.CLASS_MAP = {
+        InputLayer: 'Input'
+    };
+
+    ModelMaps.ARGUMENTS_MAP = {
+        batch_shape: 'batch_input_shape'
+    };
+
+    ModelMaps.ModelTypes = {
+        sequential : 'Sequential',
+        functional : 'Model'
+    };
+
+    ModelMaps.AbstractLayerTypeMapping = {
+        Activation: 'activation',
+        ActivityRegularization: 'activity_regularizer'
+    };
+
+
+    return ModelMaps;
+
+});