Add PaddlePaddle .pbtxt support (#198)

source/paddle-proto.js

@@ -27,6 +27,23 @@ $root.paddle.framework.proto.Version = class Version {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.Version();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "version":
+                    message.version = reader.integer();
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.Version.prototype.version = protobuf.Int64.create(0);
@@ -85,6 +102,37 @@ $root.paddle.framework.proto.OpDesc = class OpDesc {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.OpDesc();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "type":
+                    message.type = reader.string();
+                    break;
+                case "inputs":
+                    message.inputs.push($root.paddle.framework.proto.OpDesc.Var.decodeText(reader, true));
+                    break;
+                case "outputs":
+                    message.outputs.push($root.paddle.framework.proto.OpDesc.Var.decodeText(reader, true));
+                    break;
+                case "attrs":
+                    message.attrs.push($root.paddle.framework.proto.OpDesc.Attr.decodeText(reader, true));
+                    break;
+                case "is_target":
+                    message.is_target = reader.boolean();
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "type"))
+            throw new protobuf.Error("Excepted 'type'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.OpDesc.prototype.type = "";
@@ -162,6 +210,66 @@ $root.paddle.framework.proto.OpDesc.Attr = class Attr {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.OpDesc.Attr();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "name":
+                    message.name = reader.string();
+                    break;
+                case "type":
+                    message.type = reader.enum($root.paddle.framework.proto.AttrType);
+                    break;
+                case "i":
+                    message.i = reader.integer();
+                    break;
+                case "f":
+                    message.f = reader.float();
+                    break;
+                case "s":
+                    message.s = reader.string();
+                    break;
+                case "ints":
+                    reader.array(message.ints, () => reader.integer());
+                    break;
+                case "floats":
+                    reader.array(message.floats, () => reader.float());
+                    break;
+                case "strings":
+                    reader.array(message.strings, () => reader.string());
+                    break;
+                case "b":
+                    message.b = reader.boolean();
+                    break;
+                case "bools":
+                    reader.array(message.bools, () => reader.boolean());
+                    break;
+                case "block_idx":
+                    message.block_idx = reader.integer();
+                    break;
+                case "l":
+                    message.l = reader.integer();
+                    break;
+                case "blocks_idx":
+                    reader.array(message.blocks_idx, () => reader.integer());
+                    break;
+                case "longs":
+                    reader.array(message.longs, () => reader.integer());
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "name"))
+            throw new protobuf.Error("Excepted 'name'.");
+        if (!Object.prototype.hasOwnProperty.call(message, "type"))
+            throw new protobuf.Error("Excepted 'type'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.OpDesc.Attr.prototype.name = "";
@@ -201,6 +309,28 @@ $root.paddle.framework.proto.OpDesc.Var = class Var {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.OpDesc.Var();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "parameter":
+                    message.parameter = reader.string();
+                    break;
+                case "arguments":
+                    reader.array(message["arguments"], () => reader.string());
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "parameter"))
+            throw new protobuf.Error("Excepted 'parameter'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.OpDesc.Var.prototype.parameter = "";
@@ -247,6 +377,39 @@ $root.paddle.framework.proto.OpProto = class OpProto {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.OpProto();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "type":
+                    message.type = reader.string();
+                    break;
+                case "inputs":
+                    message.inputs.push($root.paddle.framework.proto.OpProto.Var.decodeText(reader, true));
+                    break;
+                case "outputs":
+                    message.outputs.push($root.paddle.framework.proto.OpProto.Var.decodeText(reader, true));
+                    break;
+                case "attrs":
+                    message.attrs.push($root.paddle.framework.proto.OpProto.Attr.decodeText(reader, true));
+                    break;
+                case "comment":
+                    message.comment = reader.string();
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "type"))
+            throw new protobuf.Error("Excepted 'type'.");
+        if (!Object.prototype.hasOwnProperty.call(message, "comment"))
+            throw new protobuf.Error("Excepted 'comment'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.OpProto.prototype.type = "";
@@ -291,6 +454,39 @@ $root.paddle.framework.proto.OpProto.Var = class Var {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.OpProto.Var();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "name":
+                    message.name = reader.string();
+                    break;
+                case "comment":
+                    message.comment = reader.string();
+                    break;
+                case "duplicable":
+                    message.duplicable = reader.boolean();
+                    break;
+                case "intermediate":
+                    message.intermediate = reader.boolean();
+                    break;
+                case "dispensable":
+                    message.dispensable = reader.boolean();
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "name"))
+            throw new protobuf.Error("Excepted 'name'.");
+        if (!Object.prototype.hasOwnProperty.call(message, "comment"))
+            throw new protobuf.Error("Excepted 'comment'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.OpProto.Var.prototype.name = "";
@@ -338,6 +534,38 @@ $root.paddle.framework.proto.OpProto.Attr = class Attr {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.OpProto.Attr();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "name":
+                    message.name = reader.string();
+                    break;
+                case "type":
+                    message.type = reader.enum($root.paddle.framework.proto.AttrType);
+                    break;
+                case "comment":
+                    message.comment = reader.string();
+                    break;
+                case "generated":
+                    message.generated = reader.boolean();
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "name"))
+            throw new protobuf.Error("Excepted 'name'.");
+        if (!Object.prototype.hasOwnProperty.call(message, "type"))
+            throw new protobuf.Error("Excepted 'type'.");
+        if (!Object.prototype.hasOwnProperty.call(message, "comment"))
+            throw new protobuf.Error("Excepted 'comment'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.OpProto.Attr.prototype.name = "";
@@ -384,6 +612,40 @@ $root.paddle.framework.proto.VarType = class VarType {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.VarType();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "type":
+                    message.type = reader.enum($root.paddle.framework.proto.VarType.Type);
+                    break;
+                case "selected_rows":
+                    message.selected_rows = $root.paddle.framework.proto.VarType.TensorDesc.decodeText(reader, true);
+                    break;
+                case "lod_tensor":
+                    message.lod_tensor = $root.paddle.framework.proto.VarType.LoDTensorDesc.decodeText(reader, true);
+                    break;
+                case "tensor_array":
+                    message.tensor_array = $root.paddle.framework.proto.VarType.LoDTensorArrayDesc.decodeText(reader, true);
+                    break;
+                case "reader":
+                    message.reader = $root.paddle.framework.proto.VarType.ReaderDesc.decodeText(reader, true);
+                    break;
+                case "tuple":
+                    message.tuple = $root.paddle.framework.proto.VarType.Tuple.decodeText(reader, true);
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "type"))
+            throw new protobuf.Error("Excepted 'type'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.VarType.prototype.type = 0;
@@ -446,6 +708,28 @@ $root.paddle.framework.proto.VarType.TensorDesc = class TensorDesc {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.VarType.TensorDesc();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "data_type":
+                    message.data_type = reader.enum($root.paddle.framework.proto.VarType.Type);
+                    break;
+                case "dims":
+                    reader.array(message.dims, () => reader.integer());
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "data_type"))
+            throw new protobuf.Error("Excepted 'data_type'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.VarType.TensorDesc.prototype.data_type = 0;
@@ -477,6 +761,28 @@ $root.paddle.framework.proto.VarType.LoDTensorDesc = class LoDTensorDesc {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.VarType.LoDTensorDesc();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "tensor":
+                    message.tensor = $root.paddle.framework.proto.VarType.TensorDesc.decodeText(reader, true);
+                    break;
+                case "lod_level":
+                    message.lod_level = reader.integer();
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "tensor"))
+            throw new protobuf.Error("Excepted 'tensor'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.VarType.LoDTensorDesc.prototype.tensor = null;
@@ -509,6 +815,28 @@ $root.paddle.framework.proto.VarType.LoDTensorArrayDesc = class LoDTensorArrayDe
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.VarType.LoDTensorArrayDesc();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "tensor":
+                    message.tensor = $root.paddle.framework.proto.VarType.TensorDesc.decodeText(reader, true);
+                    break;
+                case "lod_level":
+                    message.lod_level = reader.integer();
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "tensor"))
+            throw new protobuf.Error("Excepted 'tensor'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.VarType.LoDTensorArrayDesc.prototype.tensor = null;
@@ -536,6 +864,23 @@ $root.paddle.framework.proto.VarType.ReaderDesc = class ReaderDesc {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.VarType.ReaderDesc();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "lod_tensor":
+                    message.lod_tensor.push($root.paddle.framework.proto.VarType.LoDTensorDesc.decodeText(reader, true));
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.VarType.Tuple = class Tuple {
@@ -560,6 +905,23 @@ $root.paddle.framework.proto.VarType.Tuple = class Tuple {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.VarType.Tuple();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "element_type":
+                    reader.array(message.element_type, () => reader.enum($root.paddle.framework.proto.VarType.Type));
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.VarDesc = class VarDesc {
@@ -598,6 +960,36 @@ $root.paddle.framework.proto.VarDesc = class VarDesc {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.VarDesc();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "name":
+                    message.name = reader.string();
+                    break;
+                case "type":
+                    message.type = $root.paddle.framework.proto.VarType.decodeText(reader, true);
+                    break;
+                case "persistable":
+                    message.persistable = reader.boolean();
+                    break;
+                case "need_check_feed":
+                    message.need_check_feed = reader.boolean();
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "name"))
+            throw new protobuf.Error("Excepted 'name'.");
+        if (!Object.prototype.hasOwnProperty.call(message, "type"))
+            throw new protobuf.Error("Excepted 'type'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.VarDesc.prototype.name = "";
@@ -646,6 +1038,39 @@ $root.paddle.framework.proto.BlockDesc = class BlockDesc {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.BlockDesc();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "idx":
+                    message.idx = reader.integer();
+                    break;
+                case "parent_idx":
+                    message.parent_idx = reader.integer();
+                    break;
+                case "vars":
+                    message.vars.push($root.paddle.framework.proto.VarDesc.decodeText(reader, true));
+                    break;
+                case "ops":
+                    message.ops.push($root.paddle.framework.proto.OpDesc.decodeText(reader, true));
+                    break;
+                case "forward_block_idx":
+                    message.forward_block_idx = reader.integer();
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "idx"))
+            throw new protobuf.Error("Excepted 'idx'.");
+        if (!Object.prototype.hasOwnProperty.call(message, "parent_idx"))
+            throw new protobuf.Error("Excepted 'parent_idx'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.BlockDesc.prototype.idx = 0;
@@ -676,6 +1101,25 @@ $root.paddle.framework.proto.OpVersion = class OpVersion {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.OpVersion();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "version":
+                    message.version = reader.integer();
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "version"))
+            throw new protobuf.Error("Excepted 'version'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.OpVersion.prototype.version = 0;
@@ -702,6 +1146,23 @@ $root.paddle.framework.proto.OpVersionMap = class OpVersionMap {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.OpVersionMap();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "pair":
+                    message.pair.push($root.paddle.framework.proto.OpVersionMap.OpVersionPair.decodeText(reader, true));
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.OpVersionMap.OpVersionPair = class OpVersionPair {
@@ -734,6 +1195,30 @@ $root.paddle.framework.proto.OpVersionMap.OpVersionPair = class OpVersionPair {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.OpVersionMap.OpVersionPair();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "op_name":
+                    message.op_name = reader.string();
+                    break;
+                case "op_version":
+                    message.op_version = $root.paddle.framework.proto.OpVersion.decodeText(reader, true);
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, "op_name"))
+            throw new protobuf.Error("Excepted 'op_name'.");
+        if (!Object.prototype.hasOwnProperty.call(message, "op_version"))
+            throw new protobuf.Error("Excepted 'op_version'.");
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.OpVersionMap.OpVersionPair.prototype.op_name = "";
@@ -767,6 +1252,29 @@ $root.paddle.framework.proto.ProgramDesc = class ProgramDesc {
         }
         return message;
     }
+
+    static decodeText(reader) {
+        const message = new $root.paddle.framework.proto.ProgramDesc();
+        reader.start();
+        while (!reader.end()) {
+            const tag = reader.tag();
+            switch (tag) {
+                case "blocks":
+                    message.blocks.push($root.paddle.framework.proto.BlockDesc.decodeText(reader, true));
+                    break;
+                case "version":
+                    message.version = $root.paddle.framework.proto.Version.decodeText(reader, true);
+                    break;
+                case "op_version_map":
+                    message.op_version_map = $root.paddle.framework.proto.OpVersionMap.decodeText(reader, true);
+                    break;
+                default:
+                    reader.field(tag, message);
+                    break;
+            }
+        }
+        return message;
+    }
 };
 
 $root.paddle.framework.proto.ProgramDesc.prototype.version = null;

source/paddle.js

@@ -11,24 +11,50 @@ paddle.ModelFactory = class {
         if (identifier === '__model__' || extension === 'paddle' || extension === 'pdmodel') {
             return true;
         }
+        if (extension === 'pbtxt' || extension === 'txt') {
+            const tags = context.tags('pbtxt');
+            if (tags.has('blocks')) {
+                return true;
+            }
+        }
         return false;
     }
 
     open(context, host) {
         return host.require('./paddle-proto').then(() => {
-            let desc = null;
-            try {
-                paddle.proto = protobuf.get('paddle').paddle.framework.proto;
-                const reader = protobuf.Reader.create(context.buffer);
-                desc = paddle.proto.ProgramDesc.decode(reader);
-            }
-            catch (error) {
-                const message = error && error.message ? error.message : error.toString();
-                throw new paddle.Error('File format is not paddle.ProgramDesc (' + message.replace(/\.$/, '') + ').');
+            let programDesc = null;
+            const identifier = context.identifier;
+            const extension = identifier.split('.').pop().toLowerCase();
+            switch (extension) {
+                case 'pbtxt':
+                case 'txt': {
+                    try {
+                        paddle.proto = protobuf.get('paddle').paddle.framework.proto;
+                        const reader = protobuf.TextReader.create(context.buffer);
+                        programDesc = paddle.proto.ProgramDesc.decodeText(reader);
+                    }
+                    catch (error) {
+                        const message = error && error.message ? error.message : error.toString();
+                        throw new paddle.Error('File text format is not paddle.ProgramDesc (' + message.replace(/\.$/, '') + ').');
+                    }
+                    break;
+                }
+                default: {
+                    try {
+                        paddle.proto = protobuf.get('paddle').paddle.framework.proto;
+                        const reader = protobuf.Reader.create(context.buffer);
+                        programDesc = paddle.proto.ProgramDesc.decode(reader);
+                    }
+                    catch (error) {
+                        const message = error && error.message ? error.message : error.toString();
+                        throw new paddle.Error('File format is not paddle.ProgramDesc (' + message.replace(/\.$/, '') + ').');
+                    }
+                    break;
+                }
             }
             return paddle.Metadata.open(host).then((metadata) => {
                 const vars = new Set();
-                for (const block of desc.blocks) {
+                for (const block of programDesc.blocks) {
                     const blockVars = new Set();
                     for (const variable of block.vars) {
                         if (variable.persistable && variable.type &&
@@ -54,9 +80,9 @@ paddle.ModelFactory = class {
                     for (let i = 0; i < keys.length; i++) {
                         map.set(keys[i], buffers[i]);
                     }
-                    return new paddle.Model(metadata, desc, map);
+                    return new paddle.Model(metadata, programDesc, map);
                 }).catch((err) => {
-                    return new paddle.Model(metadata, desc, new Map());
+                    return new paddle.Model(metadata, programDesc, new Map());
                 });
             });
         });

source/view.js

@@ -1230,7 +1230,7 @@ view.ModelFactoryService = class {
         this.register('./uff', [ '.uff', '.pb', '.pbtxt', '.uff.txt', '.trt', '.engine' ]);
         this.register('./sklearn', [ '.pkl', '.pickle', '.joblib', '.model', '.meta', '.pb', '.pt', '.h5' ]);
         this.register('./cntk', [ '.model', '.cntk', '.cmf', '.dnn' ]);
-        this.register('./paddle', [ '.paddle', '.pdmodel', '__model__' ]);
+        this.register('./paddle', [ '.paddle', '.pdmodel', '__model__', '.pbtxt', '.txt' ]);
         this.register('./bigdl', [ '.model', '.bigdl' ]);
         this.register('./darknet', [ '.cfg', '.model' ]);
         this.register('./weka', [ '.model' ]);

test/models.json

@@ -3787,6 +3787,13 @@
     "format": "OpenVINO IR",
     "link":   "https://download.01.org/opencv/2020/openvinotoolkit/2020.2/open_model_zoo/models_bin/3/text-spotting-0002-recognizer-decoder/FP32"
   },
+  {
+    "type":   "paddle",
+    "target": "assign.pbtxt",
+    "source": "https://github.com/lutzroeder/netron/files/5485296/assign.pbtxt.zip[assign.pbtxt]",
+    "format": "PaddlePaddle",
+    "link":   "https://github.com/lutzroeder/netron/issues/198"
+  },
   {
     "type":   "paddle",
     "target": "PyramidBox_WiderFace.tar.gz",

tools/paddle

@@ -21,7 +21,7 @@ sync() {
 schema() {
     bold "paddle schema"
     [[ $(grep -U $'\x0D' ./source/paddle-proto.js) ]] && crlf=1
-    node ./tools/protoc.js --root paddle --out ./source/paddle-proto.js ./third_party/source/paddle/paddle/fluid/framework/framework.proto
+    node ./tools/protoc.js --root paddle --text --out ./source/paddle-proto.js ./third_party/source/paddle/paddle/fluid/framework/framework.proto
     if [[ -n ${crlf} ]]; then
         unix2dos --quiet --newfile ./source/paddle-proto.js ./source/paddle-proto.js
     fi